¿Cómo se convierte un byte? array a un hexadecimal string ¿C ª?

Este tutorial fue evaluado por nuestros expertos así aseguramos la veracidad de este escrito.

Solución:

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

para una forma más genérica:

int i;
for (i = 0; i < x; i++)

    if (i > 0) printf(":");
    printf("%02X", buf[i]);

printf("n");

para concatenar a un stringhay algunas maneras en que puede hacer esto… Probablemente mantendría un puntero al final de la string y usa sprintf. también debe realizar un seguimiento del tamaño de la array para asegurarse de que no sea más grande que el espacio asignado:

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

Para completar, también puede hacerlo fácilmente sin llamar a ninguna función de biblioteca pesada (sin snprintf, sin strcat, ni siquiera memcpy). Puede ser útil, por ejemplo, si está programando algún microcontrolador o kernel de sistema operativo donde libc no está disponible.

Nada realmente elegante, puedes encontrar un código similar si lo buscas en Google. Realmente no es mucho más complicado que llamar a snprintf y mucho más rápido.

#include 

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("%sn", str);

Aquí hay otra versión un poco más corta. Simplemente evita la variable de índice intermedio i y la duplicación del último código de caso (pero el carácter de terminación se escribe dos veces).

#include 
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("%sn", str);

A continuación hay otra versión para responder a un comentario que dice que usé un “truco” para saber el tamaño del búfer de entrada. En realidad, no es un truco sino un conocimiento de entrada necesario (necesita saber el tamaño de los datos que está convirtiendo). Aclaré esto extrayendo el código de conversión a una función separada. También agregué un código de verificación de límites para el búfer de destino, que no es realmente necesario si sabemos lo que estamos haciendo.

#include 

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("%sn", str);

Ya existen respuestas similares arriba, agregué esta para explicar cómo funciona exactamente la siguiente línea de código:

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

Es bastante complicado y no es fácil de entender, puse la explicación en los comentarios a continuación:

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".
     *
     * 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" would be written as output[0] = '0', output[1] = 'A' and
     * output[2] = ''.
     *
     * "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("%sn", output);

Al final de todo puedes encontrar las interpretaciones de otros sys admins, tú también eres capaz mostrar el tuyo si dominas el tema.

---

---

Utiliza Nuestro Buscador