cómo imprimir bits de memoria en c

Estoy aprendiendo cómo se representan los números en la memoria. Quiero saber cómo imprimir la representación real (binaria o hexadecimal) en la memoria de algunas variables int y float.

Me gustaría ver qué pasa con esos números cuando, por ejemplo, sumrlos o restarlos los desborda.

¿Cómo puedo acceder a la memoria e imprimirla?

Debería asignar un puntero a la variable en cuestión a un char * y tratarlo como una matriz de bytes de longitud sizeof(variable) . Luego puede imprimir cada byte en hexadecimal utilizando el especificador de formato %X para imprimirf.

Puedes definir una función como esta:

 void print_bytes(void *ptr, int size) { unsigned char *p = ptr; int i; for (i=0; i 

Y llámalo así:

 int x = 123456; double y = 3.14; print_bytes(&x, sizeof(x)); print_bytes(&y, sizeof(y)); 

Supongamos que tiene una variable int llamada memoria. Asegúrese de ver cuántos bits es; para muchos procesadores, un int es 32 bits, así como una dirección de memoria. Por lo tanto, necesita recorrer cada bit, así:

 unsigned int memory = 1234; for (int i = 0; i < 32; i++) { printf("%d ", memory >> i & 1); } 

Este método simple OR cada bit con 1 y cambia cada bit por 1.

 #include  #include  void print_bits ( void* buf, size_t size_in_bytes ) { char* ptr = (char*)buf; for (size_t i = 0; i < size_in_bytes; i++) { for (short j = 7; j >= 0; j--) { printf("%d", (ptr[i] >> j) & 1); } printf(" "); } printf("\n"); } int main ( void ) { size_t n; scanf("%d", &n); print_bits(&n, sizeof(n)); return 0; } 

Esto imprime bits del objeto especificado ( n aquí) con el tamaño especificado (en bytes).

… para imprimir la representación real (binario …

Para convertir cualquier variable / objeto en una cadena que codifica la forma binaria utiliza una función auxiliar que convierte la memoria en una cadena “binaria”. Este método también maneja indicadores de función. Utiliza C99 o posterior.

 #include  #include  #include  // .... compound literal ....... #define VAR_TO_STR_BIN(x) obj_to_bin((char [sizeof(x)*CHAR_BIT + 1]){""}, &(x), sizeof (x)) char *obj_to_bin(char *dest, void *object, size_t osize) { const unsigned char *p = (const unsigned char *) object; p += osize; char *s = dest; while (osize-- > 0) { p--; unsigned i = CHAR_BIT; while (i-- > 0) { *s++ = ((*p >> i) & 1) + '0'; } } *s = '\0'; return dest; } int main(void) { int i = 42; double d = 3.1415926535897932384626433832795; printf("Sample\ndouble pi:%s\nint 42:%s\n", VAR_TO_STR_BIN(d), VAR_TO_STR_BIN(i) ); return 0; } 

Salida (Nota: según endian-ness, los resultados pueden variar)

 Sample double pi:0100000000001001001000011111101101010100010001000010110100011000 int 42:00000000000000000000000000101010 

Este enfoque es fácil de adaptar a la forma hexadecimal.

@dbush, @Anton, mezclé tus códigos. ¿Está bien?

 #include  #include  void print_bytes( void *ptr, size_t size ) ; int main( void ) { int x = 123456 ; double y = 3.14 ; print_bytes( &x, sizeof(x) ) ; print_bytes( &y, sizeof(y) ) ; return 0 ; } void print_bytes( void *ptr, size_t size ) { //char *buf = (char*) ptr; unsigned char *p = ptr ; for( size_t i = 0; i < size; i++ ) { printf( "%02hhX ", p[i] ) ; } printf( "\n" ) ; for( size_t i = 0; i < size; i++ ) { for( short j = 7; j >= 0; j-- ) { printf( "%d", ( p[i] >> j ) & 1 ) ; } printf(" "); } printf("\n"); }