Saya sudah:
uint8 buf[] = {0, 1, 10, 11};
Saya ingin mengubah array byte menjadi string sehingga saya dapat mencetak string menggunakan printf:
printf("%s\n", str);
dan dapatkan (titik dua tidak diperlukan):
"00:01:0A:0B"
Bantuan apa pun akan sangat dihargai.
Jawaban:
printf("%02X:%02X:%02X:%02X", buf[0], buf[1], buf[2], buf[3]);
untuk cara yang lebih umum:
int i;
for (i = 0; i < x; i++)
{
if (i > 0) printf(":");
printf("%02X", buf[i]);
}
printf("\n");
untuk menggabungkan ke string, ada beberapa cara Anda dapat melakukan ini ... Saya mungkin akan menyimpan penunjuk ke akhir string dan menggunakan sprintf. Anda juga harus melacak ukuran larik untuk memastikannya tidak lebih besar dari ruang yang dialokasikan:
int i;
char* buf2 = stringbuf;
char* endofbuf = stringbuf + sizeof(stringbuf);
for (i = 0; i < x; i++)
{
/* i use 5 here since we are going to add at most
3 chars, need a space for the end '\n' and need
a null terminator */
if (buf2 + 5 < endofbuf)
{
if (i > 0)
{
buf2 += sprintf(buf2, ":");
}
buf2 += sprintf(buf2, "%02X", buf[i]);
}
}
buf2 += sprintf(buf2, "\n");
printf("%02X", (unsigned char)buf[i]);harus digunakan karena aslinya akan menyebabkan luapan untuk karakter yang tidak bertanda tangan
printf("%02hhX", buf[i])?
Untuk menyelesaikannya, Anda juga dapat melakukannya dengan mudah tanpa memanggil fungsi library yang berat (tanpa snprintf, tanpa strcat, bahkan memcpy). Ini bisa berguna, katakanlah jika Anda memprogram beberapa mikrokontroler atau kernel OS di mana libc tidak tersedia.
Tidak ada yang benar-benar mewah Anda dapat menemukan kode serupa di sekitar jika Anda google untuk itu. Sungguh tidak jauh lebih rumit daripada memanggil snprintf dan jauh lebih cepat.
#include <stdio.h>
int main(){
unsigned char buf[] = {0, 1, 10, 11};
/* target buffer should be large enough */
char str[12];
unsigned char * pin = buf;
const char * hex = "0123456789ABCDEF";
char * pout = str;
int i = 0;
for(; i < sizeof(buf)-1; ++i){
*pout++ = hex[(*pin>>4)&0xF];
*pout++ = hex[(*pin++)&0xF];
*pout++ = ':';
}
*pout++ = hex[(*pin>>4)&0xF];
*pout++ = hex[(*pin)&0xF];
*pout = 0;
printf("%s\n", str);
}
Ini adalah versi lain yang sedikit lebih pendek. Ini hanya menghindari variabel indeks menengah i dan menduplikasi kode kasus laste (tetapi karakter pengakhiran ditulis dua kali).
#include <stdio.h>
int main(){
unsigned char buf[] = {0, 1, 10, 11};
/* target buffer should be large enough */
char str[12];
unsigned char * pin = buf;
const char * hex = "0123456789ABCDEF";
char * pout = str;
for(; pin < buf+sizeof(buf); pout+=3, pin++){
pout[0] = hex[(*pin>>4) & 0xF];
pout[1] = hex[ *pin & 0xF];
pout[2] = ':';
}
pout[-1] = 0;
printf("%s\n", str);
}
Di bawah ini adalah versi lain untuk menjawab komentar yang mengatakan saya menggunakan "trik" untuk mengetahui ukuran buffer input. Sebenarnya ini bukan tipuan tetapi pengetahuan masukan yang diperlukan (Anda perlu mengetahui ukuran data yang Anda konversi). Saya membuat ini lebih jelas dengan mengekstrak kode konversi ke fungsi terpisah. Saya juga menambahkan kode pemeriksaan batas untuk buffer target, yang sebenarnya tidak diperlukan jika kita tahu apa yang kita lakukan.
#include <stdio.h>
void tohex(unsigned char * in, size_t insz, char * out, size_t outsz)
{
unsigned char * pin = in;
const char * hex = "0123456789ABCDEF";
char * pout = out;
for(; pin < in+insz; pout +=3, pin++){
pout[0] = hex[(*pin>>4) & 0xF];
pout[1] = hex[ *pin & 0xF];
pout[2] = ':';
if (pout + 3 - out > outsz){
/* Better to truncate output string than overflow buffer */
/* it would be still better to either return a status */
/* or ensure the target buffer is large enough and it never happen */
break;
}
}
pout[-1] = 0;
}
int main(){
enum {insz = 4, outsz = 3*insz};
unsigned char buf[] = {0, 1, 10, 11};
char str[outsz];
tohex(buf, insz, str, outsz);
printf("%s\n", str);
}
indan buffer output out? Saya juga dapat memilih untuk menggunakan string dan mengembalikan salinan daripada menyediakan buffer keluaran, dalam pengoptimalan C ++ modern sudah cukup baik untuk tidak terlalu peduli.
Berikut adalah metode yang jauh lebih cepat:
#include <stdlib.h>
#include <stdio.h>
unsigned char * bin_to_strhex(const unsigned char *bin, unsigned int binsz,
unsigned char **result)
{
unsigned char hex_str[]= "0123456789abcdef";
unsigned int i;
if (!(*result = (unsigned char *)malloc(binsz * 2 + 1)))
return (NULL);
(*result)[binsz * 2] = 0;
if (!binsz)
return (NULL);
for (i = 0; i < binsz; i++)
{
(*result)[i * 2 + 0] = hex_str[(bin[i] >> 4) & 0x0F];
(*result)[i * 2 + 1] = hex_str[(bin[i] ) & 0x0F];
}
return (*result);
}
int main()
{
//the calling
unsigned char buf[] = {0,1,10,11};
unsigned char * result;
printf("result : %s\n", bin_to_strhex((unsigned char *)buf, sizeof(buf), &result));
free(result);
return 0
}
ca9e3c972f1c5db40c0b4a66ab5bc1a20ca4457bdbe5e0f8925896d5ed37d726dan Anda akan ÌaÌe3cÌ72f1c5dÌ40c0b4a66Ìb5bÌ1Ì20cÌ4457bÌbÌ5Ì0Ì8Ì258Ì6Ì5Ìd37Ì726keluar. Untuk mengatasinya, bit di hex_strdalam baris pertama loop for perlu diubah menjadi (input[i] >> 4) & 0x0Fseperti dalam jawaban @ kriss. Maka itu bekerja dengan baik.
Jawaban serupa sudah ada di atas, saya menambahkan yang ini untuk menjelaskan bagaimana tepatnya baris kode berikut bekerja:
ptr += sprintf(ptr, "%02X", buf[i])
Itu cukup rumit dan tidak mudah untuk dipahami, penjelasannya saya berikan pada komentar di bawah ini:
uint8 buf[] = {0, 1, 10, 11};
/* Allocate twice the number of bytes in the "buf" array because each byte would
* be converted to two hex characters, also add an extra space for the terminating
* null byte.
* [size] is the size of the buf array */
char output[(size * 2) + 1];
/* pointer to the first item (0 index) of the output array */
char *ptr = &output[0];
int i;
for (i = 0; i < size; i++) {
/* "sprintf" converts each byte in the "buf" array into a 2 hex string
* characters appended with a null byte, for example 10 => "0A\0".
*
* This string would then be added to the output array starting from the
* position pointed at by "ptr". For example if "ptr" is pointing at the 0
* index then "0A\0" would be written as output[0] = '0', output[1] = 'A' and
* output[2] = '\0'.
*
* "sprintf" returns the number of chars in its output excluding the null
* byte, in our case this would be 2. So we move the "ptr" location two
* steps ahead so that the next hex string would be written at the new
* location, overriding the null byte from the previous hex string.
*
* We don't need to add a terminating null byte because it's been already
* added for us from the last hex string. */
ptr += sprintf(ptr, "%02X", buf[i]);
}
printf("%s\n", output);
Saya hanya ingin menambahkan yang berikut ini, meskipun sedikit di luar topik (bukan C standar), tetapi saya sering mencarinya, dan menemukan pertanyaan ini di antara pencarian pertama yang populer. Fungsi cetak kernel Linux printk,, juga memiliki penentu format untuk mengeluarkan isi larik / memori "secara langsung" melalui penentu format tunggal:
https://www.kernel.org/doc/Documentation/printk-formats.txt
Raw buffer as a hex string:
%*ph 00 01 02 ... 3f
%*phC 00:01:02: ... :3f
%*phD 00-01-02- ... -3f
%*phN 000102 ... 3f
For printing a small buffers (up to 64 bytes long) as a hex string with
certain separator. For the larger buffers consider to use
print_hex_dump().
... namun, penentu format ini tampaknya tidak ada untuk ruang pengguna standar (s)printf.
Fungsi btoxmengkonversi data yang sewenang-wenang *bbuntuk string tidak terselesaikan *xpdari ndigit heksadesimal:
void btox(char *xp, const char *bb, int n)
{
const char xx[]= "0123456789ABCDEF";
while (--n >= 0) xp[n] = xx[(bb[n>>1] >> ((1 - (n&1)) << 2)) & 0xF];
}
#include <stdio.h>
typedef unsigned char uint8;
void main(void)
{
uint8 buf[] = {0, 1, 10, 11};
int n = sizeof buf << 1;
char hexstr[n + 1];
btox(hexstr, buf, n);
hexstr[n] = 0; /* Terminate! */
printf("%s\n", hexstr);
}
Hasil: 00010A0B.
Langsung: Tio.run .
Ini adalah salah satu cara untuk melakukan konversi:
#include<stdio.h>
#include<stdlib.h>
#define l_word 15
#define u_word 240
char *hex_str[]={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
main(int argc,char *argv[]) {
char *str = malloc(50);
char *tmp;
char *tmp2;
int i=0;
while( i < (argc-1)) {
tmp = hex_str[*(argv[i]) & l_word];
tmp2 = hex_str[*(argv[i]) & u_word];
if(i == 0) { memcpy(str,tmp2,1); strcat(str,tmp);}
else { strcat(str,tmp2); strcat(str,tmp);}
i++;
}
printf("\n********* %s *************** \n", str);
}
Versi Yannith yang sedikit dimodifikasi. Saya hanya ingin memilikinya sebagai nilai kembali
typedef struct {
size_t len;
uint8_t *bytes;
} vdata;
char* vdata_get_hex(const vdata data)
{
char hex_str[]= "0123456789abcdef";
char* out;
out = (char *)malloc(data.len * 2 + 1);
(out)[data.len * 2] = 0;
if (!data.len) return NULL;
for (size_t i = 0; i < data.len; i++) {
(out)[i * 2 + 0] = hex_str[(data.bytes[i] >> 4) & 0x0F];
(out)[i * 2 + 1] = hex_str[(data.bytes[i] ) & 0x0F];
}
return out;
}Fungsi ini cocok di mana pengguna / pemanggil menginginkan string hex untuk dimasukkan ke dalam array / buffer charactee. Dengan string hex dalam buffer karakter, pengguna / pemanggil dapat menggunakan makro / fungsinya sendiri untuk menampilkan atau mencatatnya ke tempat mana pun yang diinginkan (misalnya ke file). Fungsi ini juga memungkinkan pemanggil untuk mengontrol jumlah (hex) byte untuk dimasukkan ke dalam setiap baris.
/**
* @fn
* get_hex
*
* @brief
* Converts a char into bunary string
*
* @param[in]
* buf Value to be converted to hex string
* @param[in]
* buf_len Length of the buffer
* @param[in]
* hex_ Pointer to space to put Hex string into
* @param[in]
* hex_len Length of the hex string space
* @param[in]
* num_col Number of columns in display hex string
* @param[out]
* hex_ Contains the hex string
* @return void
*/
static inline void
get_hex(char *buf, int buf_len, char* hex_, int hex_len, int num_col)
{
int i;
#define ONE_BYTE_HEX_STRING_SIZE 3
unsigned int byte_no = 0;
if (buf_len <= 0) {
if (hex_len > 0) {
hex_[0] = '\0';
}
return;
}
if(hex_len < ONE_BYTE_HEX_STRING_SIZE + 1)
{
return;
}
do {
for (i = 0; ((i < num_col) && (buf_len > 0) && (hex_len > 0)); ++i )
{
snprintf(hex_, hex_len, "%02X ", buf[byte_no++] & 0xff);
hex_ += ONE_BYTE_HEX_STRING_SIZE;
hex_len -=ONE_BYTE_HEX_STRING_SIZE;
buf_len--;
}
if (buf_len > 1)
{
snprintf(hex_, hex_len, "\n");
hex_ += 1;
}
} while ((buf_len) > 0 && (hex_len > 0));
}
Contoh: Kode
#define DATA_HEX_STR_LEN 5000
char data_hex_str[DATA_HEX_STR_LEN];
get_hex(pkt, pkt_len, data_hex_str, DATA_HEX_STR_LEN, 16);
// ^^^^^^^^^^^^ ^^
// Input byte array Number of (hex) byte
// to be converted to hex string columns in hex string
printf("pkt:\n%s",data_hex_str)
KELUARAN
pkt:
BB 31 32 00 00 00 00 00 FF FF FF FF FF FF DE E5
A8 E2 8E C1 08 06 00 01 08 00 06 04 00 01 DE E5
A8 E2 8E C1 67 1E 5A 02 00 00 00 00 00 00 67 1E
5A 01
Tidak ada primitif untuk ini di C. Saya mungkin akan malloc (atau mungkin alloca) buffer yang cukup lama dan loop di atas input. Saya juga telah melihatnya dilakukan dengan pustaka string dinamis dengan semantik (tetapi bukan sintaks!) Mirip dengan C ++ ostringstream, yang merupakan solusi yang lebih masuk akal lebih umum tetapi mungkin tidak sebanding dengan kerumitan ekstra hanya untuk satu kasus.
Jika Anda ingin menyimpan nilai hex dalam sebuah char *string, Anda bisa menggunakan snprintf. Anda perlu mengalokasikan ruang untuk semua karakter yang dicetak, termasuk nol dan titik dua di depan.
Memperluas jawaban Markus:
char str_buf* = malloc(3*X + 1); // X is the number of bytes to be converted
int i;
for (i = 0; i < x; i++)
{
if (i > 0) snprintf(str_buf, 1, ":");
snprintf(str_buf, 2, "%02X", num_buf[i]); // need 2 characters for a single hex value
}
snprintf(str_buf, 2, "\n\0"); // dont forget the NULL byte
Jadi sekarang str_bufakan berisi string hex.
Solusi ZincX diadaptasi untuk menyertakan pembatas titik dua:
char buf[] = {0,1,10,11};
int i, size = sizeof(buf) / sizeof(char);
char *buf_str = (char*) malloc(3 * size), *buf_ptr = buf_str;
if (buf_str) {
for (i = 0; i < size; i++)
buf_ptr += sprintf(buf_ptr, i < size - 1 ? "%02X:" : "%02X\0", buf[i]);
printf("%s\n", buf_str);
free(buf_str);
}
Saya akan menambahkan versi C ++ di sini untuk siapa saja yang tertarik.
#include <iostream>
#include <iomanip>
inline void print_bytes(char const * buffer, std::size_t count, std::size_t bytes_per_line, std::ostream & out) {
std::ios::fmtflags flags(out.flags()); // Save flags before manipulation.
out << std::hex << std::setfill('0');
out.setf(std::ios::uppercase);
for (std::size_t i = 0; i != count; ++i) {
auto current_byte_number = static_cast<unsigned int>(static_cast<unsigned char>(buffer[i]));
out << std::setw(2) << current_byte_number;
bool is_end_of_line = (bytes_per_line != 0) && ((i + 1 == count) || ((i + 1) % bytes_per_line == 0));
out << (is_end_of_line ? '\n' : ' ');
}
out.flush();
out.flags(flags); // Restore original flags.
}
Ini akan mencetak hexdump dengan bufferpanjang countke std::ostream out(Anda dapat menjadikannya default std::cout). Setiap baris akan berisi bytes_per_linebyte, setiap byte diwakili menggunakan dua digit hex huruf besar. Akan ada spasi di antara byte. Dan di akhir baris atau akhir buffer itu akan mencetak baris baru. Jika bytes_per_linediset ke 0, maka tidak akan mencetak new_line. Coba sendiri.
Untuk penggunaan sederhana saya membuat fungsi yang mengkodekan string input (data biner):
/* Encodes string to hexadecimal string reprsentation
Allocates a new memory for supplied lpszOut that needs to be deleted after use
Fills the supplied lpszOut with hexadecimal representation of the input
*/
void StringToHex(unsigned char *szInput, size_t size_szInput, char **lpszOut)
{
unsigned char *pin = szInput;
const char *hex = "0123456789ABCDEF";
size_t outSize = size_szInput * 2 + 2;
*lpszOut = new char[outSize];
char *pout = *lpszOut;
for (; pin < szInput + size_szInput; pout += 2, pin++)
{
pout[0] = hex[(*pin >> 4) & 0xF];
pout[1] = hex[*pin & 0xF];
}
pout[0] = 0;
}
Pemakaian:
unsigned char input[] = "This is a very long string that I want to encode";
char *szHexEncoded = NULL;
StringToHex(input, strlen((const char *)input), &szHexEncoded);
printf(szHexEncoded);
// The allocated memory needs to be deleted after usage
delete[] szHexEncoded;
Berdasarkan jawaban Yannuth tetapi disederhanakan.
Di sini, panjang dest[]tersirat menjadi dua kali lipat len, dan alokasinya dikelola oleh pemanggil.
void create_hex_string_implied(const unsigned char *src, size_t len, unsigned char *dest)
{
static const unsigned char table[] = "0123456789abcdef";
for (; len > 0; --len)
{
unsigned char c = *src++;
*dest++ = table[c >> 4];
*dest++ = table[c & 0x0f];
}
}
Saya tahu pertanyaan ini sudah memiliki jawaban tetapi saya pikir solusi saya dapat membantu seseorang.
Jadi, dalam kasus saya, saya memiliki array byte yang mewakili kunci dan saya perlu mengubah array byte ini menjadi array karakter nilai heksadesimal untuk mencetaknya dalam satu baris. Saya mengekstrak kode saya ke fungsi seperti ini:
char const * keyToStr(uint8_t const *key)
{
uint8_t offset = 0;
static char keyStr[2 * KEY_SIZE + 1];
for (size_t i = 0; i < KEY_SIZE; i++)
{
offset += sprintf(keyStr + offset, "%02X", key[i]);
}
sprintf(keyStr + offset, "%c", '\0');
return keyStr;
}
Sekarang, saya bisa menggunakan fungsi saya seperti ini:
Serial.print("Public key: ");
Serial.println(keyToStr(m_publicKey));
Serialobject adalah bagian dari library Arduino dan m_publicKeymerupakan anggota kelas saya dengan deklarasi berikut uint8_t m_publicKey[32].
Anda dapat menyelesaikannya dengan snprintf dan malloc.
char c_buff[50];
u8_number_val[] = { 0xbb, 0xcc, 0xdd, 0x0f, 0xef, 0x0f, 0x0e, 0x0d, 0x0c };
char *s_temp = malloc(u8_size * 2 + 1);
for (uint8_t i = 0; i < u8_size; i++)
{
snprintf(s_temp + i * 2, 3, "%02x", u8_number_val[i]);
}
snprintf(c_buff, strlen(s_temp)+1, "%s", s_temp );
printf("%s\n",c_buff);
free(s);
KELUAR: bbccdd0fef0f0e0d0c
Solusi yang sangat rumit!
Malloc dan sprint dan gips oh my. (OZ kutipan)
dan tidak ada satu rem pun di mana pun. Astaga
Bagaimana dengan yang seperti ini?
main()
{
// the value
int value = 16;
// create a string array with a '\0' ending ie. 0,0,0
char hex[]= {0,0,'\0'};
char *hex_p=hex;
//a working variable
int TEMP_int=0;
// get me how many 16s are in this code
TEMP_int=value/16;
// load the first character up with
// 48+0 gives you ascii 0, 55+10 gives you ascii A
if (TEMP_int<10) {*hex_p=48+TEMP_int;}
else {*hex_p=55+TEMP_int;}
// move that pointer to the next (less significant byte)<BR>
hex_p++;
// get me the remainder after I have divied by 16
TEMP_int=value%16;
// 48+0 gives you ascii 0, 55+10 gives you ascii A
if (TEMP_int<10) {*hex_p=48+TEMP_int;}
else {*hex_p=55+TEMP_int;}
// print the result
printf("%i , 0x%s",value,hex);
}
buf[i]harus dicorunsigned char, atau akan meluap jikabuf[i] > 127, yaitu:buf_ptr += sprintf(buf_ptr, "%02X", (unsigned char)buf[i]);