Opérateur de déréférencement

L'opérateur de déréférencement ou d'indirection est un opérateur unaire (c'est-à-dire avec un seul opérande) que l'on trouve dans les langages qui incluent des pointeurs, tels que les langages C et C++, où il est désigné par le symbole * (astérisque). Il nécessite pour opérande un pointeur et renvoie la valeur stockée à l'adresse contenue dans le pointeur. On dit pour cela que l'on "déréférence" le pointeur.

Par exemple, le code C suivant :

 int x = 21;
 int *p; // * est utilisée pour la déclaration:
     // p est un pointeur sur un entier,
     // *p est un entier
 p = &x; // & renvoie l'adresse de x
 // maintenant *p == 21, puisque p == &x et que *p == x
 *p = 42; // équivaut à écrire x = 42, car p == &x
 // donc *p == 42 et x == 42 car p est un pointeur qui contient l'adresse de x,
 // modifier *p revient à modifier x

affecte 42 à la variable x à l'aide de l'opérateur de déréférencement et d'un pointeur sur la variable x .

Composition

L'opérateur unaire *, tel que défini en C et C ++, peut être utilisé dans le cas de pointeur multiple, où plusieurs déréférencements sont requis. Les pointeurs peuvent bien sûr référencer d'autres pointeurs et, dans de tels cas, plusieurs utilisations de l'opérateur de déréférencement sont nécessaires.

L'argument argv de la fonction main en C (et C ++), qui est donné dans le prototype sous la forme char **argv, est un exemple simple de pointeur multiple. Le nom de l'exécutable du programme appelé, ainsi que tous les arguments de ligne de commande suivants, sont stockés sous forme de chaînes de caractères indépendantes. Un tableau de pointeurs sur char contient des pointeurs sur le premier caractère de chacune de ces chaînes et ce tableau de pointeurs est transmis à la fonction main tant qu'argument argv. La variable argv est en fait un pointeur sur un pointeur sur char, et représente un tableau de pointeurs sur char. L'autre paramètre de la fonction main, argc, est un int représentant la taille du tableau (c’est-à-dire le nombre de pointeurs sur char jusqu’au pointeur NULL, qui délimite le tableau de pointeurs).

Autre syntaxe

En C, l'adresse d'une structure (ou d'une union) s est désignée par &s . L'adresse de l'opérateur & est l'inverse de l'opérateur de déréférencement *, donc *&s est équivalent à s . L'adresse d'une structure (ou de l' union) s peut être attribué à un pointeur p :

 p = &s; // l'adresse de s a été assignée à p; p == &s;
 // *p == s

La valeur d'un membre a d'une structure s est notée s.a . Considérons le pointeur p sur s (c'est-à-dire p == &s ), s.a est équivalent à (*p).a, ainsi qu'à la syntaxe p->a qui est un sucre syntaxique pour accéder aux membres d'une structure (ou d'une union) via un pointeur:

 p = &s; // p == &s;
 // s.a == (*p).a
 // s.a == p->a
 // (*p).a == p->a

L'opérateur -> peut être chaîné. Par exemple, dans une liste chaînée, on peut se référer à n->next->next pour le deuxième nœud suivant (en supposant que n->next n'est pas NULL).

Voir également

• Erreur de segmentation