C에서 바이트 배열을 16진수 문자열로 변환하려면 어떻게 해야 합니까?

C에서 바이트 배열을 16진수 문자열로 변환하려면 어떻게 해야 합니까?

다음과 같은 것이 있습니다.

uint8 buf[] = {0, 1, 10, 11};

printf를 사용하여 문자열을 인쇄할 수 있도록 바이트 배열을 문자열로 변환합니다.

printf("%s\n", str);

(콜론은 필요 없습니다)를 취득합니다.

"00:01:0A:0B"

어떤 도움이라도 주시면 감사하겠습니다.

printf("%02X:%02X:%02X:%02X", buf[0], buf[1], buf[2], buf[3]);

보다 일반적인 방법:

int i;
for (i = 0; i < x; i++)
{
    if (i > 0) printf(":");
    printf("%02X", buf[i]);
}
printf("\n");

문자열에 연결하려면 몇 가지 방법이 있습니다.나는 아마도 끈 끝에 포인터를 두고 sprintf를 사용할 것이다.어레이 크기가 할당된 공간보다 커지지 않도록 어레이 크기를 추적해야 합니다.

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");

위와 유사한 답변이 이미 존재합니다.다음 코드 행이 정확히 어떻게 동작하는지를 설명하기 위해 이 답변을 추가했습니다.

ptr += sprintf(ptr, "%02X", buf[i])

꽤 까다롭고 이해하기 쉽지 않습니다.아래의 코멘트에 설명을 넣겠습니다.

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);

또한 무거운 라이브러리 함수(snprintf, strcat, memcpy)를 호출하지 않고도 쉽게 실행할 수 있습니다.예를 들어 libc를 사용할 수 없는 마이크로 컨트롤러나 OS 커널을 프로그래밍하는 경우 유용합니다.

구글을 검색하면 비슷한 코드를 찾을 수 있는 특별한 것은 없습니다.snprintf를 호출하는 것보다 훨씬 더 복잡하고 빠릅니다.

#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);
}

다음은 조금 더 짧은 버전입니다.중간 인덱스 변수 i와 라스트 케이스 코드의 중복을 회피할 뿐입니다(단, 종료 문자는 2회 기입됩니다).

#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);
}

다음은 입력 버퍼 크기를 알기 위해 "꼼수"를 사용했다는 코멘트에 대한 답변입니다.실제로는 트릭이 아니라 필요한 입력 지식입니다(변환하는 데이터의 크기를 알아야 합니다).변환 코드를 다른 함수로 추출하여 더 명확하게 했습니다.타겟 버퍼의 경계 체크 코드도 추가했습니다.이것은 우리가 무엇을 하고 있는지 알고 있다면 그다지 필요하지 않습니다.

#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);
}

솔루션

★★btox의 데이터를 합니다.*bb되지 않은 문자열에 *xpn 16진수:

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);
}

★★★★★00010A0B.

라이브: Tio.run.

조금 주제에서 벗어난(표준 C가 아님) 경우에도 다음과 같은 내용을 추가하고 싶었을 뿐이지만, 자주 찾고 있으며, 첫 번째 검색 히트 중에서 이 질문을 우연히 발견하게 되었습니다.기능 Linux " " " " " " 。printk에는 단일 포맷 지정자를 통해 어레이/메모리 콘텐츠 "signal"을 출력하기 위한 포맷 지정자도 있습니다.

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(). 

그러나 하지 않는 것 단, 이러한 형식 지정자는 표준 사용자 공간에 존재하지 않는 것 같습니다.(s)printf.

snprintf와 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);

출력: bbccdd0fef0f0e0d0c

다음은 훨씬 더 빠른 방법입니다.

#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
}

약간 수정된 Yannith 버전.그냥 반환값으로 받고 싶을 뿐이에요.

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;
}

변환의 1가지 방법은 다음과 같습니다.

#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);

}

이 함수는 사용자/발신자가 16진수 문자열을 문자 배열/버퍼에 넣는 경우에 적합합니다.문자 버퍼에 16진수 문자열이 있는 경우 사용자/콜러는 자체 매크로/함수를 사용하여 원하는 장소(파일 등)에 표시하거나 기록할 수 있습니다.또, 이 함수를 사용하면, 발신자는 각 회선에 입력하는(16 진수) 바이트수를 제어할 수 있습니다.

/**
 * @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));

}

예: 코드

#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) 

산출량

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 

을 「16」에.char * 스트링, 스트링, 스트링, 스트링, 스트링, 스트링, 스트링, 스트링, 스트링, 스트링, 스트링.snprintf. 0 에 공간을 선행 0 및 콜론을 포함하여 인쇄된 모든 문자에 공간을 할당해야 합니다.

Mark의 답변에 대해 자세히 설명하겠습니다.

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

지금 so서 so so so sostr_buf열여섯 살

C에는 이것에 대한 원시적인 것이 없다.충분한 길이의 버퍼를 malloc(또는 할당)하여 입력에 루프합니다.C++ 의 C++ 와 을 동적 .ostringstream이 솔루션은 보다 일반적인 솔루션이지만 단일 케이스에 대해서만 복잡함을 더할 필요는 없습니다.

아연X의 솔루션은 대장 구분자를 포함하도록 조정되었습니다.

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);
}

관심 있는 분들을 위해 여기에 C++ 버전을 추가하겠습니다.

#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.
}

합니다.buffercount로로 합니다.std::ostream out할 수 ).std::cout에 가 됩니다. 모든 행에는 다음이 포함됩니다.bytes_per_line바이트, 각 바이트는 대문자2자리 16진수로 표시됩니다.바이트 사이에는 공백이 있습니다.그리고 줄 끝 또는 버퍼 끝에 새 줄이 인쇄됩니다. ifbytes_per_line으로 되어 있으면.0 은 .뉴라인직접 해보세요.

간단한 사용을 위해 입력 문자열(이진수 데이터)을 인코딩하는 함수를 만들었습니다.

/* 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;
}

사용방법:

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;

Yannuth의 답변에 기초하지만 단순합니다.

기, of의 dest[]의 2배임을 암시하고 있다len그 할당은 발신자에 의해 관리됩니다.

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];
    }
}

이 질문에는 이미 답이 있다는 것을 알지만, 제 해결책이 누군가에게 도움이 될 수 있을 것 같습니다.

이 경우 키를 나타내는 바이트 배열이 있었고, 한 줄로 출력하기 위해 이 바이트 배열을 16진수 값의 char 배열로 변환해야 했습니다.다음과 같은 함수로 코드를 추출했습니다.

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;
}

이제 기능을 다음과 같이 사용할 수 있습니다.

Serial.print("Public key: ");
Serial.println(keyToStr(m_publicKey));

Serial오브젝트는 Arduino 라이브러리의 일부이며m_publicKey다음과 같은 선언을 가진 우리 반의 구성원이다.uint8_t m_publicKey[32].

얼마나 복잡한 솔루션인가!
Malloc, 전력질주, 캐스팅 오 마이 갓. (OZ 인용)
어디에도 렘이 하나도 없어요아뿔싸

이런 거 어때요?

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);

}

언급URL : https://stackoverflow.com/questions/6357031/how-do-you-convert-a-byte-array-to-a-hexadecimal-string-in-c