Articles en langage C - stockage des données en mémoire

Points d'apprentissage dans ce chapitre

1. Introduction détaillée des types de données
2. Stockage de la mise en forme en mémoire : code original, code inverse, code complément
3. Introduction et jugement de l'ordre des octets gros et petit endian

Le texte commence ! ! !

Les types de données incluent

Introduction clé : type virgule flottante, type énumération, type pointeur, d'autres seront introduits en détail plus loin dans les chapitres.

Famille virgule flottante :

Membres : flottant, double

Remarque : Les nombres à virgule flottante ne peuvent pas être directement jugés égaux par le signe égal, et ESP (précision) doit être défini.

Par exemple, pour déterminer si une variable de type double est égale à 0, elle ne peut pas être directement a==0.

#include<stdio.h>
#include<math.h>
#define ESP 0.000000000000000001
int main()
{
	double a = 0.0000000001;
	if (fabs(a) < ESP)
	{
		printf("a等于0");
	}
	return 0;
}

 Si la décimale d'entrée représente le type double de la valeur littérale, si vous devez saisir la décimale de type flottant, vous devez mettre f après la décimale.

 Solution de contournement pour l'avertissement : float a = 0.2f.

type d'énumération

définition

Les définitions de type d'énumération sont identifiées par le mot clé enum sous la forme :

enum 标识符 
{
      枚举数据表
}；

Avis:

(1) enum est un mot-clé qui identifie le type d'énumération. La définition d'un type d'énumération doit commencer par enum.

(2) Les noms dans la table de données d'énumération sont définis par le programmeur, et ces noms ne sont qu'un symbole. Mais faites attention au nom pour améliorer la lisibilité du programme. Un type d'énumération est une collection, et les éléments de la collection (membres de l'énumération) sont des constantes entières nommées, et les éléments sont séparés par des virgules.

(3) Les valeurs de la table de données d'énumération sont toutes des nombres entiers. La valeur par défaut du premier membre d'énumération est un entier de 0, et la valeur des membres d'énumération suivants est augmentée de 1 jusqu'au membre précédent. Vous pouvez également définir manuellement les valeurs des membres de l'énumération pour personnaliser les nombres entiers dans une certaine plage.

(4) Les constantes d'énumération peuvent être initialisées lorsque le type est défini.

(5) Les types d'énumération peuvent être comparés.

(6) Les constantes d'énumération ne sont pas des chaînes et les chaînes ne peuvent pas être sorties en mode %s.

(7) Le type énumération est une alternative à la directive de prétraitement #define

type de pointeur

Ici, nous introduisons principalement le pointeur nul void*

Rappelez-vous les deux points suivants

1.void* peut accepter des pointeurs de tout type

2. Tout type de pointeur peut accepter void

Stockage en mémoire des formes

Ce qu'il faut savoir, c'est que les données sont stockées en mémoire en complément !

Nous devons d'abord comprendre les connaissances suivantes

Le code original
peut être directement traduit en binaire sous forme de nombres positifs et négatifs.
Complément à un
Le bit de signe du code d'origine reste inchangé, et les autres bits peuvent être obtenus en inversant tour à tour les autres bits.
complément

Complétez +1 pour obtenir le complément.

Un nombre tel que -1

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

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

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

Il est recommandé de se rappeler que le complément de -1 est de 32 unités.
Pourquoi conserver le complément ?

Le processeur n'effectuera que des opérations d'addition ( en fait, l'addition de complément ) et ne peut pas effectuer d'opérations de soustraction, et le code de complément peut très bien résoudre ce problème

Par exemple, 1-1 peut être converti en 1+(-1)

Le complément à 1 est égal au code original : 0000 0000 0000 0000 0000 0000 0000 0001

Le complément de -1 est : 1111 1111 1111 1111 1111 1111 1111 1111
additionnés est 0000 0000 0000 0000 0000 0000 0000 0000

Le résultat est 0, ce qui est la magie du complément à deux ! !

Présentation des grands et des petits

Le mode big-endian (stockage) signifie que les bits de poids faible des données sont stockés à l'adresse haute de la mémoire et que les bits de poids fort des données sont stockés à l'adresse basse de la mémoire.
Le mode Little-endian (stockage) signifie que les bits de poids faible des données sont stockés à l'adresse basse de la mémoire et que les bits de poids fort des données sont stockés à l'adresse haute de la mémoire.

Low-endianness des données : en octets, plus le poids à droite est faible.

L'ordre des octets de poids fort des données : en octets, plus le poids est élevé, plus le poids est proche de la gauche.

Tels que data int a = 0x11 22 33 44 

44 a le poids le plus bas, suivi de 33. C'est comme l'entier 1234, le poids de 1 est de 10 à la troisième puissance et le poids de 2 est de 10 à la deuxième puissance. 1 est le bit de pleine valeur haute et 4 est le bit de poids faible.

Testé avec vs2019, le compilateur place les bits élevés aux adresses hautes et les bits bas aux adresses basses, c'est-à-dire que vs2019 utilise un stockage little-endian.

Ensuite, nous concevons un programme qui ne juge pas la méthode de stockage des données (little endian ou big endian) utilisée dans un certain environnement en regardant la mémoire.

#include<stdio.h>
int check_sys()
{
	union
	{
		int i;
		char c;
	}un;
	un.i = 1;
	return un.c;
}
int main()
{
	int a = check_sys();
	if (a == 1)
	{
		printf("小端");
	}
	else
	{
		printf("大端");
	}
	return 0;
}

Enfin

Si vous avez des questions sur ce chapitre, n'hésitez pas à communiquer avec moi.

S'il y a une erreur dans ce chapitre, merci de le signaler, je vous en suis très reconnaissant.

Si vous le trouvez utile, veuillez aimer et commenter, merci.