Dans cet article, je résume les dimensions des pointeurs en quatre caractères chinois : « Deux soi et trois autres » ! Cela ne se lit pas aisément et ne rime pas du tout, qu'est-ce que c'est que ça ? Ces « Deux soi et trois autres », développés, sont : adresse de soi, valeur de soi, valeur de l'autre, adresse de l'autre et type de l'autre.

Je pense que nous pouvons parler des pointeurs à partir de ces 5 dimensions. Mais avant cela, j'ai écrit un programme qui inclut toutes les dimensions « Deux soi et trois autres » des pointeurs, puis j'expliquerai la signification de chaque dimension une par une. Voyez si c'est le cas.

Dans la plupart des scénarios où les pointeurs sont utilisés, ces 5 dimensions devraient suffire à vous aider à comprendre. Cependant, dans certains scénarios particuliers d'utilisation des pointeurs, la méthode des 5 dimensions peut ne pas vous aider.

Avertissement : article long. Si vous devenez impatient, vous pouvez ajouter cet article à vos favoris et poursuivre la lecture quand vous aurez le temps.

1. Code du programme

1.1. Code

Le résultat d'exécution est le suivant :

Dans mes articles, lorsque je parle de choses que je comprends, j’aime utiliser des programmes très simples pour illustrer. Alors, les experts qui pensent qu’un point doit être illustré par un programme impénétrable, ou qui méprisent les programmes de bas niveau, veuillez m’ignorer ^_^.

2.2. variable int para

Dans le programme :

int para = 1;
printf("变量para自己的地址是:  0X%x\n", &para);
printf("变量para自己的值是:  0X%x\n", para);

Le programme définit la variable para, qui a sa propre valeur de données et sa propre adresse de stockage ; celles-ci sont faciles à comprendre. D’après la sortie, la valeur de données propre à la variable para est, en hexadécimal, "0X1", et son adresse, en hexadécimal, est "0X22feb4". En d’autres termes, en mémoire, l’espace de stockage commençant à l’adresse "0X22feb4" comporte 4 octets stockant une valeur de données "0X1". Sur ma machine, une variable int occupe 4 octets ; sur la vôtre, cela peut être différent.

Tout le monde comprend la variable int para. Ensuite, je vais dessiner un schéma pour montrer comment la variable para est stockée en mémoire, comme suit :

Ensuite, parlons du concept de « Deux Soi et Trois Autres ».

2. Deux Soi et Trois Autres

« Deux Soi et Trois Autres », une fois développé, correspond à : adresse propre, valeur propre, valeur d’autrui, adresse d’autrui et type d’autrui.

2.1. Adresse propre

2.1.1 Le concept d’« adresse propre »

« Adresse propre » est l’abréviation de « sa propre adresse ». En tant que variable, le pointeur pInt, comme la variable int para, a aussi besoin d’un espace de stockage en mémoire, et cet espace de stockage a aussi une adresse de début ; autrement dit, la variable pointeur pInt a aussi sa propre adresse. Comme mentionné ci-dessus, l’adresse de la variable para est "0X22feb4". Alors, quelle est l’adresse de la variable pointeur pInt ?

2.1.2 Obtention de l'« adresse propre »

Nous avons tous appris que « & » est un opérateur d'adresse. Dans le programme :

printf("指针变量pInt自己的地址是:  0X%x\n", &pInt);

Il obtient l'adresse de la variable pointeur pInt via « & ». D'après la sortie, l'adresse de la variable pointeur pInt est « 0X22feb8 ». Sur ma machine, la variable pointeur pInt occupe aussi 4 bytes, donc la variable pointeur pInt est stockée dans l'espace de 4 bytes commençant à l'adresse « 0X22feb8 ».

2.1.3 Notation dans le code pour l'« adresse propre »

Dans le code, une façon courante de représenter l'« adresse propre » de la variable pointeur pInt est :

&pInt;

Affinons maintenant ce schéma en ajoutant l'« adresse propre » de la variable pointeur pInt pour montrer comment la variable pointeur pInt est stockée en mémoire.

L'« adresse propre », c'est tout simplement cela. Vous voyez, rien de particulièrement difficile, n'est-ce pas ?

2.2 Valeur propre

2.2.1 Le concept de « valeur propre »

« Valeur propre » est l'abréviation de « sa propre valeur de données ». En tant que variable, le pointeur pInt, comme la variable para, possède aussi sa propre valeur de données.

2.2.2 Obtention de la « valeur propre »

Comme mentionné ci-dessus, la valeur de données propre à la variable para est « 1 ». Alors, quelle est la valeur de données propre à la variable pointeur pInt ? Dans le programme :

pInt = ¶
printf("指针变量pInt自己的值是:  0X%x\n", pInt);

À l'aide de l'opérateur « & », j'ai affecté la valeur d'adresse de la variable para à la variable pointeur pInt, et j'ai utilisé printf pour afficher la valeur de données de la variable pointeur pInt. D'après la sortie, la valeur de données propre de la variable pointeur pInt est « 0X22feb4 ». Notons aussi que l'adresse de la variable para est également « 0X22feb4 », donc,

pInt = ¶

L'essence de cette instruction est de donner l'adresse de la variable para à la valeur propre de la variable pointeur pInt, liant ainsi la variable pointeur pInt et la variable para ensemble.

Comme mentionné dans « adresse propre », la valeur de données du pointeur pInt est stockée dans les 4 bytes de mémoire commençant à l'adresse « 0X22feb8 ». Autrement dit, les 4 bytes de mémoire commençant à l'adresse « 0X22feb8 » sont utilisés pour stocker une valeur de données « 0X22feb4 ».

2.2.3 Notation de code pour la « valeur propre »

Dans le code, les façons courantes de représenter la « valeur propre » de la variable pointeur pInt sont :

pInt;

Il existe aussi cette notation de code :

pInt + N;
pInt - N;

Cette notation signifie ajouter un nombre N à la « valeur propre » de pInt ou soustraire un nombre N de celle-ci ; cela sera mentionné lorsque la propriété « autre-type » sera abordée. Il existe aussi cette notation :

pIntA - pIntB;

Cette notation indique que deux variables pointeur utilisent leurs « valeurs propres » pour effectuer une soustraction.

2.2.4 Schéma

Maintenant, continuez à affiner le schéma ci-dessus en ajoutant la valeur propre de la variable pointeur pInt.

Ainsi, d'une manière générale, pour la variable pointeur pInt, la « valeur propre » est sa propre valeur de données ; pour les autres variables de type int, c'est leur adresse.

2.3 Autre adresse

2.3.1 Le concept d'« adresse d'autrui »

Le concept d'« adresse d'autrui » signifie « l'adresse d'un autre ». En fait, lorsque « valeur propre » a été mentionnée ci-dessus, le concept d'« adresse d'autrui » avait déjà été évoqué, mais de manière peu évidente.

2.3.2 Obtention de l'« adresse d'autrui »

La variable entière para est stockée dans les 4 octets à partir de l'adresse mémoire « 0X22feb4 ». Dans le programme, j'ai utilisé

pInt = ¶

pour donner l'adresse de la variable para à la variable pointeur pInt, liant ainsi la variable pointeur pInt et la variable para ensemble. Plus fondamentalement, cela attribue « l'adresse d'un autre » à la « valeur propre » de la variable pointeur pInt. Ici, l'« autre » dans « l'adresse d'un autre » fait référence à la variable para, et l'« adresse » dans « l'adresse d'un autre » fait référence à l'adresse de la variable para. Remarquez : « adresse d'autrui » et « valeur propre » sont identiques en valeur de données. Alors, avez-vous une meilleure intuition ?

De nombreux manuels disent « un pointeur est une variable d'adresse qui stocke l'adresse d'une autre variable ». Pour le dire franchement, ils disent que la valeur de données de la dimension « adresse d'autrui » est égale à la valeur de données de la dimension « valeur propre » ; les manuels ne le formulent simplement pas aussi clairement.

2.3.3 Schéma

Affinons encore ce schéma, cette fois en ajoutant le concept d'« adresse d'autrui ».

2.4 Valeur d'autrui

2.4.1 Le concept de « valeur d'autrui »

« Valeur d'autrui » signifie « la valeur de données d'un autre ».

2.4.2 Obtention de la « valeur d'autrui »

Dans le programme, j'ai utilisé

pInt = ¶

pour donner l'adresse de la variable para à la "valeur propre" de la variable pointeur pInt, liant ainsi la variable pointeur pInt et la variable para ensemble. À ce moment, l'"autre" dans la "valeur de données d'un autre" fait référence à la variable para, et la "valeur de données" dans la "valeur de données d'un autre" fait référence à la valeur de données "1" de la variable para. Dans le programme, j'ai utilisé

printf("指针变量pInt的他值是:  0X%x\n", *pInt);

: Et ceci ? C'est en fait *(pInt + 1).

2.4.3 Syntaxe de code pour l'"autre valeur"

Ces motifs de code que vous voyez souvent dans le code, comme le motif *pInt, que signifient-ils ? En fait, ils calculent l'"autre valeur" de la variable pointeur pInt !

Qu'en est-il de ces motifs : *(pInt + 1), *pInt + 1, pInt

*(pInt + 1) : Si vous considérez pInt + 1 comme un autre pointeur, par exemple,

int *pTemp = pInt + 1；

alors *(pInt + 1) calcule essentiellement l'"autre valeur" de la variable pointeur pTemp ;

*pInt + 1 : Cela ajoute 1 à l'"autre valeur" de pInt ;

pInt

2.4.4 Schéma

Continuez à améliorer le schéma ci-dessus, cette fois en ajoutant le concept d'"autre valeur" :

2.5 Autre type

2.5.1 Le concept d'« autre type »

« Autre type » est l'abréviation de « le type de l'autre ». Dans le programme, on voit que, lors de la déclaration de la variable pointeur pInt, cela s'écrit comme ceci :

int *pInt = NULL;

Le « int » devant la variable pointeur pInt ne signifie pas que la « valeur propre » de pInt est une valeur de données de type int ; il signifie plutôt que la « valeur de l'autre » de pInt est une valeur de données de type int. Ici, la « valeur de l'autre » de pInt est la valeur de données « 0X1 » de la variable para, donc le « int » devant pInt indique que la valeur de données « 0X1 » est de type « int ».

En bref, le type spécifié lors de la déclaration d'un pointeur sert à modifier la « valeur de l'autre », et non la « valeur propre ».

Maintenant, regardez à nouveau, lors de la déclaration de la variable para :

int para = 1;

Le « int » devant la variable para signifie que le type de para est un type entier. À ce stade, « int » pour para est un « type propre », c'est-à-dire « son propre type ». Seul le type dans une déclaration de pointeur est un « autre type », le type de l'entité pointée.

Puisque l'« autre type » sert à modifier la « valeur de l'autre », quelle est l'importance d'ajouter cet « autre type » lors de la déclaration d'un pointeur ? Continuez à lire !

Dans le programme, l'extrait de code suivant :

int arr_int[2] = {1, 2};    
pInt = arr_int;
printf("arr_int第一个元素arr_int[0]的地址是:  0X%x\n", pInt);
printf("arr_int第二个元素arr_int[1]的地址是:  0X%x\n", pInt + 1);

J'affecte l'adresse d'un tableau d'entiers arr_int à la variable pointeur pInt. Ensuite, l'« adresse propre » de pInt ne change pas, elle est toujours 0X22feb8, mais sa « valeur propre » change.

Tout à l'heure, la « valeur propre » de pInt était « 0X22feb4 », qui est l'adresse de la variable para. Maintenant, elle devient « 0X22feac », qui est l'adresse du premier élément du tableau arr_int. C'est-à-dire que l'« adresse propre » de pInt ne change pas, mais sa « valeur propre » peut être modifiée.

Maintenant, regardons la différence entre « pInt » et « pInt + 1 ». Il s'agit d'effectuer de l'arithmétique avec la « valeur propre » de pInt. D'après le résultat d'exécution, la « valeur propre » de pInt à ce moment est « 0X22feac », et la « valeur propre » de pInt + 1 est « 0X22feb0 ». Avez-vous remarqué ? Elles diffèrent exactement de 4 octets, et une donnée de type « int » occupe aussi justement 4 octets.

Vous pourriez penser que puisque pInt + 1 ajoute 1 à la « valeur propre », cela devrait être « 0X22feac + 1 » = « 0X22fead ». Pourquoi n'en est-il pas ainsi ? C'est le tour joué par l'« autre type » de la variable pointeur pInt.

La signification d'« autre type », en clair, est : « Hé mon vieux pInt, ta valeur de l'autre est une valeur de données de type int. À l'avenir, lorsque tu utilises ta propre valeur +1, +2, ou -1, -2, n'ajoute pas bêtement 1 octet, 2 octets, ni ne soustrais 1 octet, 2 octets. Le type int occupe 4 octets, donc tu dois prendre 4 octets comme une unité et ajouter 1*4 octets, 2*4 octets, ou soustraire 1*4 octets, 2*4 octets, compris ? Oh, au fait, N dans pInt + N peut être positif ou négatif. »

Bien sûr, si les données de type « int » sur votre machine occupent 8 octets, alors pInt + 1 ajoute 8 octets à la « valeur propre », pInt + 2 ajoute 8 * 2 = 16 octets à la « valeur propre ». Voilà l'idée.

J'ai donné un autre exemple dans le programme pour illustrer cet « autre type ». Le programme est le suivant :

double *pDouble = NULL;
double arr_double[2] = {1.1, 2.2};
pDouble = arr_double;
printf("arr_double第一个元素arr_double[0]的地址是:  0X%x\n", pDouble);
printf("arr_double第二个元素arr_double[1]的地址是:  0X%x\n", pDouble + 1);

Cette fois, déclarez une variable pointeur pDouble. Son « autre type » est « double », sa « valeur propre » est l'adresse du tableau arr_double, et sa « valeur de l'autre » est la valeur de donnée « 1.1 » de l'élément arr_double

3. Résumé

Il est temps de résumer.

Je déclare une variable pointeur :

type *pType = NULL;

pType a 5 dimensions, à savoir :

pType = (adresse propre, valeur propre, adresse de l'autre, valeur de l'autre, autre type);

3.1 Adresse propre : c'est-à-dire « sa propre adresse »

En tant que variable, la variable pointeur pType a aussi sa propre adresse. La syntaxe de code courante est « &pType ».

L'adresse propre n'est pas fréquemment utilisée dans les programmes ordinaires. Si elle est utilisée, cela implique un « pointeur vers pointeur », qui est un autre sujet et ne sera pas abordé dans cet article ;

3.2 Valeur propre : c'est-à-dire « sa propre valeur de données »

En tant que variable, la variable pointeur pType possède également sa propre valeur de données. La syntaxe de code est « pType ».

Vous pouvez également effectuer des additions et des soustractions sur la valeur propre. Les syntaxes de code courantes incluent « pType + N », « pType - N », « pType2 - pType1 », etc.

3.3 Adresse d'autrui : c'est-à-dire « l'adresse d'un autre »

La valeur propre de la variable pointeur pType, en plus de représenter sa propre valeur de données, représente également l'adresse d'une variable de type « type » liée à pType. D'une manière générale, la « valeur propre » et l'« adresse d'autrui » de la variable pointeur pType ont la même valeur de données.

Une façon courante de lier une variable de type « type » à pType est : pType = &variable;

3.4 Valeur d'autrui : c'est-à-dire « la valeur de données d'un autre »

Une fois qu'une variable de type « type » est liée à pType, la variable pointeur pType peut obtenir la valeur de la variable de type type, c'est-à-dire la « valeur d'autrui », au moyen d'une syntaxe de code. Les syntaxes de code courantes incluent « *pType », « pType-> », etc.

Et ces modèles de code : « *(pType + N) », « *(pType - N) », « pType[N] » obtiennent aussi la « valeur d'autrui », mais cela nécessite une explication particulière :

Vous pouvez considérer pType + N comme :

type *pTemp = pType + N;

« *(pType + N) » calcule en fait la « valeur d'autrui » de la variable pointeur pTemp.

Ensuite, « *(pType - N) » vous sera facile à comprendre ;

« pType[N] » est en fait « *(pType + N) ». Mémorisez-le, c'est tout.

3.5 Autre-type : c.-à-d., « le type d'un autre »

Lors de la déclaration de la variable pointeur pType, le « type » qui précède ne sert pas à modifier la « valeur propre » de pType, mais à modifier l'« autre valeur ». Autrement dit, « type » ne signifie pas que la « valeur propre » de pType est une valeur de données de type « type », mais plutôt que l'« autre valeur » de pType est une valeur de données de type « type ».

Le rôle du « type autre » dans le code est principalement que, lors du calcul de « pType + N » ou « pType - N », pType doit ajouter ou soustraire (N * sizeof(type)) octets.

Les pointeurs donnent toujours le vertige, probablement parce que vous avez le vertige sur une ou plusieurs de ces 5 dimensions. Comprenez bien ces 5 dimensions, et les pointeurs ne sont qu'un tigre de papier.

4. Exercices expliqués

Après avoir terminé les 5 dimensions, comment ne pas avoir quelques exercices pratiques ? Voici quelques exercices, tous liés aux pointeurs, qui donnent tous le vertige aux débutants au point d'abandonner. J'utilise ces 5 dimensions pour interpréter ces problèmes. Voyez si c'est un peu plus facile !

4.1 Somme des éléments d'un tableau

4.1.1 Programme

Le premier exemple est un programme très courant : trouver la somme des éléments d'un tableau. Le programme est le suivant :

Le programme est très simple. Il affiche d'abord tous les éléments du tableau, puis calcule la somme de tous les éléments. Le résultat de l'exécution est le suivant :

4.1.2 Interprétation avec « deux propres, trois autres »

4.1.2.1 Affichage des éléments du tableau

Lors de l'affichage des éléments du tableau, le code est le suivant :

pArr = arr;
printf("%d ", pArr[index]);

Cette ligne de code est équivalente à

pArr = arr;
printf("%d ", *( pArr + index));

Ici, la « valeur propre » et le « type autre » sont utilisés pour l'addition, et la « valeur autre » sert à obtenir les éléments du tableau.

« Valeur propre » : le code affecte d'abord la valeur de donnée du nom de tableau arr à la « valeur propre » de pArr. Et quelle est la valeur de donnée du nom de tableau arr ? C'est l'adresse de l'élément arr

;

int *pTemp = pArr + index;

;

« Autre type » : l'autre type de pArr est « int ». Pour pArr + index, combien d'octets sont ajoutés à la valeur propre de pArr ? Puisque l'autre type de pArr est int, alors pArr + index signifie la valeur propre de pArr plus index * sizeof(int) octets, n'est-ce pas !

pArr : peut s'écrire pArr + 0, c'est-à-dire ajouter 0 * 4 = 0 octets. À ce moment, la valeur propre de pTemp est l'adresse de arr

pArr + 1 : ajouter 1 * 4 = 4 octets. À ce moment, la valeur propre de pTemp est l'adresse de arr

pArr + 2 : ajouter 2 * 4 = 8 octets. À ce moment, la valeur propre de pTemp est l'adresse de arr

De cette façon, pArr + index parcourt les adresses de tous les éléments du tableau.

Vous constaterez que la valeur propre de pTemp ne cesse de changer ; la valeur propre et l'adresse propre de pArr restent inchangées.

« Autre valeur » : puisque pArr + index peut parcourir les adresses de tous les éléments du tableau, alors utiliser *(pArr + index), c'est-à-dire *pTemp, permet d'obtenir l'autre valeur de pTemp, et ainsi de parcourir les valeurs de tous les éléments du tableau !

4.1.2.2 Somme des éléments du tableau

Le code utilisé pour additionner les éléments du tableau est le suivant :

sum = sum + *(pArr + index);

D'après mon analyse de l'affichage des éléments du tableau faite tout à l'heure, vous devriez tous bien comprendre comment pArr fonctionne dans ce code !

pArr + index utilise toujours la valeur propre de pArr pour l'addition, obtenant la valeur propre d'un pointeur temporaire pTemp. Cette valeur propre de pTemp est l'adresse de chaque élément du tableau ;

Ensuite, utilisez *(pArr + inedx), c'est-à-dire *pTemp, pour obtenir l'autre valeur du pointeur temporaire pTemp, qui est la valeur de chaque élément.

Enfin, additionnez chaque autre valeur de pTemp pour calculer la somme des éléments du tableau.

4.1.2.3 Résumé

Essayez de comprendre les expressions de code courantes telles que pArr, pArr + index, *(pArr + index), pArr[index], *pArr + index du point de vue de « deux possède et trois autres » !

4.2 Tableau de pointeurs

Un tableau de pointeurs est quelque chose qui combine les pointeurs et les tableaux. Pour les amis débutants, il peut être relativement difficile à comprendre. Les tableaux de pointeurs constituent un sujet relativement vaste. Pour les concepts associés, veuillez vous référer aux manuels généraux de langage C. Ici, nous utilisons uniquement le concept de « deux possède et trois autres » pour expliquer les concepts liés aux pointeurs dans le programme.

4.2.1 Programme

Pour les tableaux de pointeurs, j'ai donné un exemple comme suit :

Le résultat d'exécution est le suivant :

4.2.2 Interprétation avec "deux propres et trois autres"

4.2.2.1 Afficher toutes les chaînes

Regardez d'abord la définition du tableau de pointeurs :

char *arr[3] = {"abc", "def", "ghi"};

Chaque élément de ce tableau semble être une chaîne, mais en substance, c'est comme ceci :

char *pChar1 = "abc", *pChar2 = "def", *pChar3 = "ghi";
char *arr[3] = {pChar1, pChar2, pChar3};

Chaque élément du tableau arr est en réalité un pointeur dont le "type autre" est "char".

arr

printf("%s ", arr[0]);

En substance :

printf("%s ", pChar1);

Utilisez la valeur propre (ou l'adresse autre) de pChar1 pour afficher 'b' et 'c' un par un en partant de l'adresse du caractère 'a'.

pChar2 et pChar3 peuvent être compris de la même manière.

4.2.2.2 Afficher chaque caractère de la première chaîne "abc"

Le code est le suivant :

char *pArr = arr[0];
printf("%c ", *(pArr + index) );

Assigner arr

pArr + index consiste à ajouter index * sizeof(char) octets à la valeur de pArr elle-même, ce qui donne une variable pointeur temporaire pTemp :

char *pTemp = pArr + index;

La valeur de ce pointeur pTemp elle-même (ou l'autre adresse) sera successivement les adresses des caractères 'a', 'b', 'c' ; autrement dit, l'autre valeur de pTemp sera aussi successivement les caractères 'a', 'b', 'c'. De cette façon, le pointeur pTemp parcourra tour à tour chaque caractère de la chaîne "abc".

4.3 Liste chaînée

Les listes chaînées utilisent le plus fréquemment des pointeurs. Les opérations telles que l'insertion de nœuds et la suppression de nœuds rencontreront toujours du code comme le suivant :

p2 = p1->next;
p1->next = p3->next;
...... 

C'est quoi ce truc ? Tellement vertigineux ! Ce pointeur next, ce pointeur next, qui sautent d'avant en arrière. Mince, j'ai la tête en bouillie. Haha, voici la méthode d'analyse des pointeurs en 5 dimensions ! Cependant, en ce qui concerne les listes chaînées, je pense que je ferais mieux d'écrire un autre article pour les expliquer. Après avoir fini d'expliquer les listes chaînées, je reviendrai sur ces pointeurs next. Laissez-moi vous dire, l'essence des listes chaînées est exactement comme ça. Une fois que vous avez compris, les listes chaînées sont encore plus un tigre de papier que les pointeurs.

Auteur : Stone Family's Fish

Source : https://zhuanlan.zhihu.com/p/27974028