[Langage C] Pointeurs élémentaires

1. Qu'est-ce qu'un pointeur ?

Le pointeur est un type de variable utilisé pour stocker l'adresse d'une variable. Il peut pointer vers n'importe quel type de données, y compris les types de données de base (tels que les entiers, les caractères, etc.) et les types de données composites (tels que les tableaux, les structures, etc.). Grâce aux pointeurs, nous pouvons indirectement accéder ou modifier les données stockées à une adresse mémoire spécifique.

1. Un pointeur est le numéro d’une plus petite unité en mémoire, c’est-à-dire l’adresse.
2. Le pointeur mentionné dans le langage parlé normal fait généralement référence à une variable de pointeur, qui est une variable utilisée pour stocker une adresse mémoire.

Résumé : Les pointeurs sont des adresses. Dans le langage parlé, les pointeurs font généralement référence à des variables de pointeur.
Les variables de pointeur sont des variables utilisées pour stocker des adresses.
La question ici est :

• Quelle est la taille d’une petite unité ? (1 octet)
• Comment s'adresser ?

Après un calcul et une pesée minutieux, nous avons constaté qu’il est plus approprié d’attribuer un octet à une adresse correspondante.
Pour une machine 32 bits, en supposant qu'il y ait 32 lignes d'adresse, alors en supposant que chaque ligne d'adresse génère un niveau haut (haute tension) et un niveau bas (basse tension) lors de l'adressage est (1 ou 0) ; alors 32 L'
adresse
générée par la ligne d'adresse sera :

00000000 00000000 00000000
00000000 00000000 00000000 00000000 00000001
…
11111111 11111111 11111111 11111111

Il y a ici 2 puissance 32 adresses.
Chaque adresse identifie un octet, nous pouvons alors donner (2^32Byte == 2^32/1024KB == 2^32/1024/1024MB == 2^32/1024/1024/1024GB == 4GB) L'espace 4G est adressé. De la même manière, la machine 64 bits disposera de 264 adresses.
Ici, nous comprenons :

• Sur une machine 32 bits, l'adresse est une séquence binaire composée de 32 0 ou 1, et l'adresse doit être stockée dans 4 octets d'espace, donc la taille d'une variable de pointeur doit être de 4 octets.
• Sur une machine 64 bits, s'il y a 64 lignes d'adresse, la taille d'une variable de pointeur est de 8 octets pour stocker une adresse.

Résumé :
les variables de pointeur sont utilisées pour stocker des adresses, et les adresses identifient de manière unique une unité de mémoire.

2. Pointeurs et types de pointeurs

Nous savons tous que les variables ont différents types, entier, virgule flottante, etc. Le pointeur a-t-il un type ? Regardons le code ci-dessous.

int num = 10;
p = #

Pour enregistrer &num (l'adresse de num) dans p, nous savons que p est une variable pointeur, alors quel est son type ? Nous donnons à la variable pointeur le type correspondant.

char *pa = NULL;
int *pb = NULL;
short *pc = NULL;
long *pd = NULL;
float *pe = NULL;
double *pf = NULL;

Il n'est pas difficile de voir ici que
le pointeur de type char* est utilisé pour stocker l'adresse de la variable de type char.
Le pointeur de type short* est utilisé pour stocker l'adresse de la variable de type court.
Le pointeur de type int* permet de stocker l'adresse de la variable de type int.
Le pointeur de type long* est utilisé pour stocker l'adresse de la variable de type long.
Le pointeur de type float* est utilisé pour stocker l'adresse de la variable de type float.
Le pointeur de type double* est utilisé pour stocker l'adresse de la variable de type double.


A partir de ces deux images, nous pouvons voir que la taille du pointeur n'a rien à voir avec le type du pointeur et n'est liée qu'au nombre de bits dans la machine. Sur une machine 32 bits, la taille du pointeur occupe 4 octets, et sur une machine 64 bits, il occupe 8 octets.
Quelle est la signification du type de pointeur ? Regardons en bas.

Nous pouvons voir que le type de pointeur détermine la distance (distance) vers laquelle le pointeur avance ou recule. pi est de type int donc pi+1 est déplacé de 4 octets et pc est de type char donc pc n'est déplacé que d'un octet.

3. Pointeur sauvage

Un pointeur sauvage signifie que l'emplacement pointé par le pointeur est inconnu (aléatoire, incorrect et sans restrictions claires)Causes des pointeurs sauvages :
1.Le pointeur n'est pas initialisé

#include <stdio.h>
int main()
{
    
    
	int *p;//局部变量指针未初始化，默认为随机值
	*p = 10;
	return 0;
}

2. Accès hors limites du pointeur

#include <stdio.h>
int main()
{
    
    
	int arr[10] = {
    
    0};
	int *p = arr;
	int i = 0;
	for(i=0; i<=11; i++)
	{
    
    
		*(p++) = i;//当指针指向的范围超出数组arr的范围时，p就是野指针
	}
	return 0;
}

3. Libérez l'espace pointé par le pointeur

#include <stdio.h>
int* test()
{
    
    
	int a = 10;
	return &a;

}
int main()
{
    
    
	int* p = test();
	printf("%d\n", *p);
	return 0;
}

Comment éviter les pointeurs sauvages

1. Initialisation du pointeur (si vous ne savez pas à quelle valeur le pointeur est initialisé, vous pouvez l'initialiser à NULL)
2. Attention, le pointeur sort des limites
3. Le pointeur pointant vers l'espace est libéré et mis à NULL dans le temps.
4. Évitez de renvoyer l'adresse des variables locales
5. Vérifier la validité des pointeurs avant utilisation

4. Arithmétique du pointeur

• L'ajout ou la soustraction d'un nombre entier à un pointeur déplace l'adresse vers l'arrière ou l'avant.
  
• La valeur absolue d'un pointeur moins un pointeur est le nombre d'éléments entre le pointeur et le pointeur,Le principe du pointeur moins le pointeur est que les deux pointeurs pointent vers le même espace.
  

5. Pointeurs et tableaux

On peut voir que le nom du tableau et l’adresse du premier élément du tableau sont les mêmes.
Conclusion : Le nom du tableau représente l'adresse du premier élément du tableau.
Puisque le nom du tableau peut être stocké dans un pointeur sous forme d’adresse, il nous devient possible d’utiliser un pointeur pour y accéder.

Donc p+i calcule en fait l’adresse du tableau arr avec l’index i.
Ensuite, nous pouvons accéder au tableau directement via le pointeur.
Par exemple:

6. Pointeur secondaire

Les variables de pointeur sont également des variables. Les variables ont des adresses. Alors, où est stockée l'adresse de la variable de pointeur ?
La réponse est celle des pointeurs secondaires.

Les opérations sur les pointeurs secondaires sont :

• *ppa déréférence l'adresse dans ppa, donc ce qui est trouvé est pa. *ppa accède en fait à pa.

int b = 20 ;
*ppa = &b;//Équivalent à pa = &b;

• **ppa trouve d'abord pa via *ppa, puis déréférence pa : *pa, puis il trouve a.

**ppa = 30 ;
//Équivalent à *pa = 30 ;
//Équivalent à a = 30 ;

7. Tableau de pointeurs

Un tableau de pointeurs est-il un pointeur ou un tableau ?
Réponse : C'est un tableau. est un tableau qui stocke des pointeurs.
Tableaux Nous connaissons déjà les tableaux d'entiers et les tableaux de caractères.

int arr1[5];
char arr2[6];

À quoi ressemble un tableau de pointeurs ?

int* arr3[5];//是什么？

arr3 est un tableau de cinq éléments, chaque élément est un pointeur entier.