¿Almacena una int en una matriz char?

Question

Quiero almacenar un int de 4 bytes en una matriz char ... de modo que las primeras 4 ubicaciones de la matriz char son los 4 bytes del int.

Entonces, quiero tirar de la int de nuevo fuera de la matriz ...

Además, los puntos de bonificación si alguien me puede dar el código para hacer esto en un bucle ... es decir, escribir como 8 enteros en una Matriz de 32 bytes.

int har = 0x01010101; 
char a[4]; 
int har2; 

// write har into char such that: 
// a[0] == 0x01, a[1] == 0x01, a[2] == 0x01, a[3] == 0x01 etc..... 

// then, pull the bytes out of the array such that: 
// har2 == har 

Gracias chicos!

EDIT: Supongamos int son 4 bytes ...

Edit2: Por favor, no se preocupan por orden de bits ... que se preocuparse por orden de bits. Solo quiero diferentes formas de lograr lo anterior en C/C++. Gracias

EDIT3: Si no puede ver, estoy tratando de escribir una clase de serialización en el nivel bajo ... así que estoy buscando diferentes estrategias para serializar algunos tipos de datos comunes.

Answer 1

No es la manera más óptima, pero es endian seguro.

int har = 0x01010101; 
char a[4]; 
a[0] = har & 0xff; 
a[1] = (har>>8) & 0xff; 
a[2] = (har>>16) & 0xff; 
a[3] = (har>>24) & 0xff; 

Answer 2

A menos que usted se preocupa por el orden de bytes y tal, memcpy hará el truco:

memcpy(a, &har, sizeof(har)); 
... 
memcpy(&har2, a, sizeof(har2)); 

Por supuesto, no hay garantía de que sizeof(int)==4 en cualquier implementación particular (y hay implementaciones del mundo real para el cual este es de hecho falso).

Escribir un bucle debería ser trivial desde aquí.

Answer 3

No utilice los sindicatos, Pavel aclara:

Es U.B., debido a que C++ prohíbe acceder a cualquier miembro de un sindicato que no sea el último que fue escrito a. En particular, el compilador es libre de optimizar distancia la asignación a int miembro a cabo completamente con el código anteriormente, dado que su valor no es utilizado posteriormente (que sólo ve el de lectura posterior para el miembro de char[4] , y tiene ninguna obligación de proporciona ningún valor significativo allí). En la práctica, g ++ en particular es conocido por tirar tales trucos, por lo que este no es solo teoría. Por otro lado, usando static_cast<void*> seguido de static_cast<char*> está garantizado al trabajo .

- Pavel Minaev

Answer 4

int main() { 
    typedef union foo { 
     int x; 
     char a[4]; 
    } foo; 

    foo p; 
    p.x = 0x01010101; 
    printf("%x ", p.a[0]); 
    printf("%x ", p.a[1]); 
    printf("%x ", p.a[2]); 
    printf("%x ", p.a[3]); 

    return 0; 
} 

Tenga en cuenta que el a [0] sostiene el LSB y una [3] sostiene el MSB, en una pequeña máquina endian.

Answer 5

#include <stdio.h> 

int main(void) { 
    char a[sizeof(int)]; 
    *((int *) a) = 0x01010101; 
    printf("%d\n", *((int *) a)); 
    return 0; 
} 

tener en cuenta:

Un puntero a un objeto o tipo incompleto se puede convertir en un puntero a una objeto diferente o tipo incompleto. Si el puntero resultante no está alineado correctamente para el tipo apuntado , el comportamiento no está definido.

Answer 6

Nota: El acceso a una unión a través de un elemento que no fue el último asignado es un comportamiento indefinido. (suponiendo una plataforma donde los personajes son 8 bits y enteros son 4 bytes) Una máscara de bits de 0xFF será enmascarar un carácter tan

char arr[4]; 
int a = 5; 

arr[3] = a & 0xff; 
arr[2] = (a & 0xff00) >>8; 
arr[1] = (a & 0xff0000) >>16; 
arr[0] = (a & 0xff000000)>>24; 

haría arr [0] sostener el byte más significativo y la matriz [3] sostener lo menos.

de edición: Para que lo entienda el truco & es poco prudente 'y' donde como & & es lógico 'y'. Gracias a los comentarios sobre el turno olvidado.

Answer 7

También puede utilizar la colocación de nuevo para esto:

void foo (int i) { 
    char * c = new (&i) char[sizeof(i)]; 
} 

Answer 8

 
union value { 
    int i; 
    char bytes[sizof(int)]; 
}; 

value v; 
v.i = 2; 

char* bytes = v.bytes; 

Answer 9

 

    #include <stdint.h> 

    int main(int argc, char* argv[]) { 
     /* 8 ints in a loop */ 
     int i; 
     int* intPtr 
     int intArr[8] = {1, 2, 3, 4, 5, 6, 7, 8}; 
     char* charArr = malloc(32); 

     for (i = 0; i < 8; i++) { 
      intPtr = (int*) &(charArr[i * 4]); 
      /*^  ^^ ^ */ 
      /* point at  | |  |  */ 
      /*  cast as int* |  |  */ 
      /*    Address of |  */ 
      /*   Location in char array */ 

      *intPtr = intArr[i]; /* write int at location pointed to */ 
     } 

     /* Read ints out */ 
     for (i = 0; i < 8; i++) { 
      intPtr = (int*) &(charArr[i * 4]); 
      intArr[i] = *intPtr; 
     } 

     char* myArr = malloc(13); 
     int myInt; 
     uint8_t* p8; /* unsigned 8-bit integer */ 
     uint16_t* p16; /* unsigned 16-bit integer */ 
     uint32_t* p32; /* unsigned 32-bit integer */ 

     /* Using sizes other than 4-byte ints, */ 
     /* set all bits in myArr to 1   */ 
     p8 = (uint8_t*) &(myArr[0]); 
     p16 = (uint16_t*) &(myArr[1]); 
     p32 = (uint32_t*) &(myArr[5]); 
     *p8 = 255; 
     *p16 = 65535; 
     *p32 = 4294967295; 

     /* Get the values back out */ 
     p16 = (uint16_t*) &(myArr[1]); 
     uint16_t my16 = *p16; 

     /* Put the 16 bit int into a regular int */ 
     myInt = (int) my16; 

    } 

Answer 10

char a[10]; 
int i=9; 

a=boost::lexical_cast<char>(i) 

encontraron esta es la mejor manera de convertir carbón en int y viceversa.

alternativa para impulsar :: lexical_cast es sprintf.

char temp[5]; 
temp[0]="h" 
temp[1]="e" 
temp[2]="l" 
temp[3]="l" 
temp[5]='\0' 
sprintf(temp+4,%d",9) 
cout<<temp; 

salida sería: hell9