convert - escape sequences in c

Convertir un int en un valor hexadecimal de 2 bytes en C

Question

Necesito convertir un int en un valor hexadecimal de 2 bytes para almacenar en una matriz de caracteres, en C. ¿Cómo puedo hacer esto?

Answer 1

Aquí hay una manera cruda de hacerlo. Si no podemos confiar en que la codificación de los valores ascii sea consecutiva, simplemente creamos un mapeo de los valores hexadecimales en char. Probablemente se puede optimizar, ordenar y hacer más bonito. También supone que solo observamos la captura de los últimos 32 bits == 4 caracteres hexadecimales.

#include <stdlib.h>
#include <stdio.h>

#define BUFLEN 5

int main(int argc, char* argv[])
{
  int n, i, cn;
  char c, buf[5];
  char hexmap[17] = {''0'',''1'',''2'',''3'',''4'',''5'',''6'',''7'',''8'',''9'',''A'',''B'',''C'',''D'',''E'',''F'',''.''};

  for(i=0;i<BUFLEN;i++)
    buf[i]=0;

  if(argc<2)
  {
    printf("usage: %s <int>/n", argv[0]);
    return 1;
  }
  n = atoi(argv[1]);
  i = 0;
  printf("n: %d/n", n);

  for(i=0; i<4; i++)
  {
    cn = (n>>4*i) & 0xF;
    c  = (cn>15) ? hexmap[16] : hexmap[cn];
    printf("cn: %d, c: %c/n", cn, c);

    buf[3-i] = (cn>15) ? hexmap[16] : hexmap[cn];
  }
  buf[4] = ''/0''; // null terminate it

  printf("buf: %s/n", buf);
  return 0;
}

Answer 2

Descubrí una manera rápida que probé y funciona.

int value = 11;

array[0] = value >> 8;
array[1] = value & 0xff;

printf("%x%x", array[0], array[1]);

el resultado es:

000B

que es 11 en hexadecimal.

Answer 3

En lugar de sprintf , recomendaría usar snprintf lugar.

#include <stdio.h>

int main()
{
    char output[5];
    snprintf(output,5,"%04x",255);

    printf("%s/n",output);
    return 0;
}

Es mucho más seguro y está disponible en casi todos los compiladores.

Answer 4

Esta función funciona como un amuleto.

void WORD2WBYTE(BYTE WBYTE[2], WORD Value) { 
    BYTE tmpByte[2]; 
    // Converts a value from word to word byte ----
    memcpy(tmpByte, (BYTE*) & Value, 2); 
    WBYTE[1] = tmpByte[0]; 
    WBYTE[0] = tmpByte[1]; 
} 

asumiendo lo siguiente:

typedef unsigned char   BYTE; 
typedef unsigned short  WORD;

Ejemplo de uso:

Queremos lograr esto:

integer = 92
byte array in hex:
a[0] = 0x00;
a[1] = 0x5c;

unsigned char _byteHex[2];
WORD2WBYTE(_byteHex, 92);

Answer 5

La mayoría de estas respuestas son excelentes, solo hay una cosa que agregaría: puede usar sizeof para reservar de forma segura el número correcto de bytes. Cada byte puede tomar hasta dos dígitos hexadecimales (255 -> ff), por lo que son dos caracteres por byte. En este ejemplo, agrego dos caracteres para el prefijo ''0x'' y un carácter para el NUL final.

int bar; 
// ...
char foo[sizeof(bar) * 2 + 3];
sprintf(foo, "0x%x", bar);

Answer 6

Normalmente recomendaría el uso de las soluciones basadas en sprintf recomendadas por otros. Pero cuando escribí una herramienta que tenía que convertir miles de millones de elementos a hexadecimal, el sprintf era demasiado lento. Para esa aplicación utilicé una matriz de 256 elementos, que asigna bytes a cadenas.

Esta es una solución incompleta para convertir 1 byte, no se olvide de agregar la verificación de límites y asegúrese de que la matriz sea estática o global, recrearla para cada verificación eliminará el rendimiento.

static const char hexvals[][3]= {"00", "01", "02", ... "FD", "FE", "FF"};
const char *byteStr = hexvals[number];

Answer 7

Para longitud fija dinámica de hex.

string makeFixedLengthHex(const int i, const int length)
{
    std::ostringstream ostr;
    std::stringstream stream;
    stream << std::hex << i;
    ostr << std::setfill(''0'') << std::setw(length) << stream.str();
    return ostr.str();
}

Pero negativo tienes que manejarlo tú mismo.

Answer 8

Puedes usar esto es simple y fácil de convertir.

typedef union {
    struct hex{
            unsigned  char a;
            unsigned  char b;

    }hex_da;
    short int dec_val;
}hex2dec;

hex2dec value;
value.dec_val=10;

Ahora el valor hex está almacenado en la estructura hex_da, acceda a él para su uso posterior

Answer 9

Si tienes permiso para usar las funciones de la biblioteca:

int x = SOME_INTEGER;
char res[5]; /* two bytes of hex = 4 characters, plus NULL terminator */

if (x <= 0xFFFF)
{
    sprintf(&res[0], "%04x", x);
}

Su número entero puede contener más de cuatro dígitos hexadecimales, por lo tanto, la verificación primero.

Si no tiene permiso para usar las funciones de la biblioteca, divídalo manualmente en nybbles:

#define TO_HEX(i) (i <= 9 ? ''0'' + i : ''A'' - 10 + i)

int x = SOME_INTEGER;
char res[5];

if (x <= 0xFFFF)
{
    res[0] = TO_HEX(((x & 0xF000) >> 12));   
    res[1] = TO_HEX(((x & 0x0F00) >> 8));
    res[2] = TO_HEX(((x & 0x00F0) >> 4));
    res[3] = TO_HEX((x & 0x000F));
    res[4] = ''/0'';
}

Answer 10

Suponiendo que int sean 32 bits;

La forma más fácil: simplemente use sprintf ()

int intval = /*your value*/
char hexval[5];
sprintf(hexval,"%0x",intval);

Ahora usa hexval [0] a través de hexval [3]; si desea usarlo como una cadena terminada en nulo, agregue hexval[4]=0;

Answer 11

Tal vez intente algo como esto:

void IntToHex(int value, char* buffer) {
  int a = value&16;
  int b = (value>>4)&16;
  buffer[0] = (a<10)?''0''+a:''A''-(a-10);
  buffer[1] = (b<10)?''0''+b:''A''-(b-10);
}

Answer 12

Usando la respuesta de Vicky arriba

typedef unsigned    long    ulong;
typedef unsigned    char    uchar;

#define TO_HEX(i)   (i <= 9 ? ''0'' + i : ''A'' - 10 + i)
#define max_strhex  (sizeof(ulong)*2)

public uchar
*mStrhex(uchar *p, ulong w, ulong n)
{
    ulong i = 0xF;                                  // index
    ulong mask  = i << (((sizeof(ulong)*2)-1)*4);   // max mask (32 bit ulong mask = 0xF0000000, 16 bit ulong mask = 0xF000)
    ulong shift = (w*4);                            // set up shift to isolate the highest nibble
    if(!w || w > max_strhex)                        // no bold params
        return p;                                   // do nothing for the rebel
    mask  = mask >> (max_strhex-w)*4;               // setup mask to extract hex nibbles
    for(i = 0; i < w; i++){                         // loop and add w nibbles
        shift = shift - 4;                          // hint: start mask for four bit hex is 0xF000, shift is 32, mask >> 32 is 0x0000, mask >> 28 is 0x000F.
        *p++ = TO_HEX(((n & mask) >> shift));       // isolate digit and make hex
        mask = mask >> 4;                           //
        *p = ''/0'';                                  // be nice to silly people
    }                                               //
    return p;                                       // point to null, allow concatenation
}

Answer 13

char s[5];  // 4 chars + ''/0''
int x = 4660;
sprintf(s, "%04X", x);

Probablemente querrá consultar la documentación de sprintf() . Tenga cuidado de que este código no sea muy seguro. Si x es mayor que 0xFFFF , la cadena final tendrá más de 4 caracteres y no se ajustará. Para hacerlo más seguro, mire snprintf() .

Answer 14

unsigned int hex16 = ((unsigned int) input_int) & 0xFFFF;

input_int es el número que quieres convertir. hex16 tendrá los 2 bytes menos significativos de input_int . Si desea imprimirlo en la consola, use %x como el especificador de formato en lugar de %d y se imprimirá en formato hexadecimal.

Answer 15

void intToHex(int intnumber, char *txt)
{    
    unsigned char _s4=''0'';
    char i=4;
    //intnumber=0xffff;

    do {
        i--;
        _s4 = (unsigned char)  ((intnumber >> i*4 ) & 0x000f);
        if(_s4<10)
            _s4=_s4+48;
        else
            _s4=_s4+55;

        *txt++= _s4;    
    } while(i);     
}
...
char text [5]={0,0,0,0,0};
...

intToHex(65534,text);
USART_Write_Text(text);
....