Stockage d'errata-données en langage C

Stockage en forme en mémoire

Pour les nombres positifs: code d'origine = code inverse = code complémentaire

Pour les nombres négatifs: le bit le plus élevé est 1 (représentant un nombre négatif), le code d'origine -> le code inverse (le bit le plus élevé reste inchangé et les bits restants sont inversés), le code inverse -> le complément (le dernier bit du code inversé plus 1 = code complémentaire)

Regardez d'abord le code suivant

#include<stdio.h>

int main(int argv,char *argc[])
{
	char a = -1;
	unsigned char b = -1;
	printf("%d,%d\n",a,b);

    return 0;
}

Le résultat d'impression est: -1, 255

Les entiers existent sous la forme de compléments dans les ordinateurs .

Pour char a = -1:

Code d'origine: 1000 0000 0000 0000 0000 0000 0000 0001

Code inverse: 1111 1111 1111 1111 1111 1111 1111 1110

Complément: 1111 1111 1111 1111 1111 1111 1111 1111

Pour char, retirez les huit bits inférieurs 1 111 1111, et les données sont imprimées en% d, qui doit être mis à niveau à 32 bits. Pour les données signées, les données complétées sont déterminées en fonction du bit de signe supérieur

Code complété ( selon le type de données --- car a ) 1111 1111 1111 1111 1111 1111 1111 1111 ----------> Le code d'origine après la fin ( selon le type d'impression: si% d , le bit le plus significatif est complété selon le type, si% u, le complément d'origine est le même ) 1000 0000 0000 0000 0000 0000 0000 0000 0001 ---------------> Print -1 (stocké est le complément, le code original est imprimé)

Pour le caractère non signé b = -1:

Code d'origine: 1000 0000 0000 0000 0000 0000 0000 0001

Code inverse: 1111 1111 1111 1111 1111 1111 1111 1110

Complément: 1111 1111 1111 1111 1111 1111 1111 1111

Pour les caractères non signés, retirez les huit bits de poids faible 1 111 1111 et imprimez les données dans% d, qui doivent être mises à niveau vers 32 bits. Pour les caractères non signés , les bits de poids fort sont remplis avec 0

Le complément du complément 000 0000 0000 0000 0000 0000 1111 1111 (pour non signé, c'est un nombre positif et le complément de son complément d'origine est le même) ------------ ---> Imprimer 255 (stocké le code complémentaire, imprimer le code d'origine)

Regardez le code suivant

#include<stdio.h>

int main(int argv,char *argc[])
{
	char a = -128;

	printf("%u\n",a);

    return 0;
}

Résultat d'impression: 4294967168

Pour char a = -128:

Code d'origine : 1000 0000 0000 0000 0000 0000 1000 0000

Code inverse: 1111 1111 1111 1111 1111 1111 0111 1111

Complément: 1111 1111 1111 1111 1111 1111 1000 0000

Retirez les huit chiffres inférieurs 1000 0000% u est un nombre positif non signé à imprimer

Le complément est augmenté à 32 bits (car a est un type signé, il doit donc être complété en fonction du type de bit le plus élevé): 1111 1111 1111 1111 1111 1111 1000 0000 (selon% u) ----> sortie 4294967168

 

Stockage de type virgule flottante en mémoire

Pour les entiers mentionnés précédemment, la taille peut être affichée dans limits.h, tandis que la plage de tailles de données à virgule flottante peut être affichée dans float.h

Regardez d'abord le code suivant:

#include<stdio.h>
#include <arpa/inet.h>


int main(int argv,char *argc[])
{
	int a = 5;
	float *p = (float*)&a;

	printf("a =%d\n",a);
	printf("*p =%f\n",*p);

	*p = 5.0;
	printf("a =%d\n",a);
	printf("*p =%f\n",*p);



    return 0;

}

Résultat de sortie:

Le stockage des données a changé lors de la contrainte d'un entier à un nombre à virgule flottante

Alors, comment les données en virgule flottante sont-elles stockées?

Exemple: nombre à virgule flottante simple précision 5,5  

       Représentation binaire: 101.1 ---------- 5 (101) .5 (0.5 * 2 = 1.0 est exactement 1 pour plus de détails: https://jingyan.baidu.com/article/eb9f7b6dc692e9c79264e878.html )

      101,1 = （-1） * 0 * 1,011 * 2 ^ 2

      s = 0 M = 1.011 (seul .011 est réellement stocké) E = 2

       

         

      Pour un nombre à virgule flottante simple précision S: 1 bit E: 8 bits M: 23 bits        

                                     S = 0 M = 1.011 (seul .011 est réellement stocké) E = 2 (2 + 127) Valeur stockée: 129 Valeur réelle: 2

                                     0 1000 0001011 0000000000000 ..... (Après la conversion, entrez le nombre binaire après la virgule décimale et ajoutez 0 aux chiffres restants)

           

   Après avoir lu ceci, tout le monde doit savoir pourquoi les résultats ci-dessus sont affichés.

  int a = 5   

Original = inverse = complément: 0000 0000  0000 0000 0000 0000 0000 0101 quand on * p utilise% f pour lire ce complément     

E est tout 0, ce qui signifie un très petit nombre proche de 0, donc * p = 0,000000

    Lorsqu'il est stocké dans le type à virgule flottante 2 + 127

5,0 = 101,0 = (-1) * 0 * 1,01 * 2 ^ 2 = 0 1000 0001 0100 0000 0000 0000 0000 000 

Lorsque nous lisons en% d, cela devient 0100 0000 1010 0000 0000 0000 0000 0000 0000 = 1084227584