comment imprimer des bits de mémoire en c

J’apprends comment les nombres sont représentés en mémoire. Je veux savoir comment imprimer la représentation réelle (binary ou hexadécimale) en mémoire de certaines variables int et float.

J’aimerais voir ce qui se passe avec ces chiffres lorsque l’ajout ou la soustraction provoque un débordement, par exemple.

Comment puis-je accéder à la mémoire et l’imprimer?

Vous devez affecter un pointeur à la variable en question à un caractère char * et le traiter comme un tableau d’octets de longueur sizeof(variable) . Vous pouvez ensuite imprimer chaque octet au format hexadécimal à l’aide du spécificateur de format %X de printf.

Vous pouvez définir une fonction comme celle-ci:

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

Et appelez ça comme ça:

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

Disons que vous avez une variable int appelée memory. Assurez-vous de voir combien de bits il s’agit; pour de nombreux processeurs, un int est 32 bits ainsi qu’une adresse mémoire. Vous devez donc parcourir chaque bit de la manière suivante:

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

Cette méthode simple OU chaque bit avec 1 et décale chaque bit par 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; } 

Ceci imprime des bits de l’object spécifié ( n ici) avec la taille spécifiée (en octets).

… pour imprimer la représentation réelle (binary …

Pour convertir une variable / un object en chaîne qui code la forme binary, utilisez une fonction d’assistance qui convertit la mémoire en chaîne “binary”. Cette méthode gère également les pointeurs de fonction. Utilise C99 ou plus tard.

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

Sortie (Remarque: selon les résultats, les résultats peuvent varier)

 Sample double pi:0100000000001001001000011111101101010100010001000010110100011000 int 42:00000000000000000000000000101010 

Cette approche est facile à adapter à la forme hexadécimale.

@dbush, @Anton, j’ai mélangé vos codes. Ça va?

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