À propos du stockage des données en mémoire (mise en forme)

taper	Nombre d'octets	Gammes
entier (forme)	4	-2147483648~2147483647
court(entier court)	2	-32768~32767
long (entier long)	4/8	-2^31~(2^31-1)
long long (type double long)	8	-2^63~(2^63-1)
carboniser	1	-2^7~(2^7-1)

La famille int est divisée en non signé et signé. Int est en fait un int signé, (signé) int. Pour les int signés, nous omettons généralement les signés.

Les tableaux ci-dessus sont en fait tous des types signés.

taper	Nombre d'octets	Gammes
entier non signé (entier non signé)	4	0~(2^32-1)
court non signé (entier court non signé)	2	0~(2^16-1)
non signé long (entier long non signé)	4/8	0~(2^32-1)
non signé long long (entier long non signé)	8	0~(2^64-1)
caractère non signé (type de caractère non signé)	1	0~255

La différence entre les types signés et les types non signés est que le type non signé place toute la mémoire des nombres négatifs dans des nombres positifs.

sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

#sizeof est un opérateur qui mesure la longueur d'un type ou d'une variable. %zu est utilisé pour imprimer spécifiquement la valeur du type size_t, qui est la valeur de retour de sizeof.

char représente un caractère, mais l'essence du type char est une valeur de code ASCII, qui est essentiellement un nombre entier, il est donc classé dans la famille des nombres entiers.

Le code ASCII de la lettre majuscule « A » est le nombre décimal 65 et la plage des lettres majuscules est comprise entre 65 et 90.

Le code ASCII de la lettre minuscule « a » est le nombre décimal 97 et la plage de lettres minuscules est comprise entre 97 et 122.

Nombre décimal minuscule = Nombre décimal majuscule + 32

2. Famille à virgule flottante

Les types à virgule flottante peuvent être utilisés à condition que des décimales soient utilisées.

taper	Nombre d'octets	numéro effectif	Plage numérique (valeur absolue)
flotter	4	6	0 et 1,210^(-38)~3,410^38
double	8	15	0 et 2,310^(-308)~1,710^308
longue double	8	15	0 et 2,310^(-308)~1,710^308
longue double	16	19	0 et 3,410^(-4932)~1,110^4932

Différents systèmes de compilation gèrent différemment les types longs doubles, et les octets alloués seront également différents.

importance:

Utilisez ce type d'espace pour ouvrir de l'espace (la taille détermine le champ d'utilisation)
Comment regarder la perspective de l'espace mémoire

3. Types construits (types personnalisés - nous pouvons créer nous-mêmes de nouveaux types)

1.Type de tableau

int arr1[5];   类型： int [5]
int arr2[8];         int [8]
char arr2[5];        char [5]

2. Structure de type structure

Introduction à la structure Introduction à la structure

3. Enum de type énumération

4. Union de type syndical

4. Type vide

void test(void)
{
	printf("hehe\n");
}

int main()
{
	test();
	return 0;
}

Le premier vide signifie que la fonction ne retournera pas de valeur

Le deuxième vide indique que la fonction n'a pas besoin de transmettre de paramètres

5. Type de pointeur

int* p;
char* i;

2. Stockage du façonnage en mémoire

1.Poids

Les valeurs numériques ont différentes représentations : binaire, octale, décimale et hexadécimale.

Rapport décimal dans différentes bases 21

Binaire :0b10101 (0b signifie que la représentation est binaire)

Octal :025 (0 avant 25 indique que la représentation est octale)

Hex :0x15 (0x signifie que la représentation est hexadécimale)

La méthode de stockage numérique de l'ordinateur est binaire et la capacité de int est de 4 octets, soit 32 (2 ^ 8) bits.

Chaque position est représentée par 1 ou 0. En informatique, cela donne :

00000000000000000000000000010101 (32 chiffres au total)

Nous pouvons comprendre ce qu'est le poids par analogie avec le système décimal. Le nombre décimal 123 peut être considéré comme 1*10^2+2*10+3*1=123.

Et 10^2 est le poids de 1, 10 est le poids de 2 et 1 est le poids de 3.

2. Code original, code complémentaire (binaire)

Les ordinateurs utilisent des codes complémentaires lors de la manipulation des nombres.

Le code original, le code complément et le code complément des nombres positifs sont tous identiques.

int a = 21;
	//00000000000000000000000000010101-原码
	//00000000000000000000000000010101-反码
	//00000000000000000000000000010101-补码

Les règles de conversion du code original, du code complémentaire et du code complémentaire des nombres négatifs :

Code original : La séquence binaire écrite directement sous forme de positif et de négatif est le code original

Code complémentaire à un : le bit de signe du code d'origine reste inchangé et les autres bits sont inversés au niveau du bit pour obtenir le code complémentaire à un.

Code complément : le code complément + 1 est le code complément

int b = -21;
	//10000000000000000000000000010101-原码
	//11111111111111111111111111101010-反码
	//11111111111111111111111111101011-补码

Ce que vous pouvez voir, c'est que les signes des nombres positifs et des nombres négatifs se distinguent par le premier bit.

analogie:

Le nombre exprimé par 100000000000000000000000000000001 est -1

0000000000000000000000000000000001 représente le chiffre 1

3.Introduction au grand et petit endian

La façon dont les données sont stockées en mémoire est divisée en ordre d’octets gros-boutiste et ordre d’octets petit-boutiste.

Différents compilateurs utilisent big endian ou little endian

Stockage big-endian :

Stocker le contenu haut de gamme d'une donnée à une adresse basse et placer le contenu bas de gamme à une adresse haute est du big-endian.

int a =0x11 22 33 44 (l'hexadécimal est utilisé ici pour l'expression)

Stockage petit-boutiste :

Stocker le contenu bas-boutiste d'une donnée à une adresse basse et placer le contenu haut-boutiste à une adresse haute est du petit-boutiste.

Bien sûr, je vais le vérifier pour tout le monde :

J'utilise mcvs et vous pouvez voir qu'il est stocké dans l'ordre des octets petit-boutiste.

Le 15 00 00 00 vu sur l'interface mémoire est hexadécimal pour faciliter notre observation. En fait, ce qui est compté dans l'ordinateur est binaire.