Pointeurs, *, &

16 Pointeurs, *, &

Un pointeur est typé : on distingue les pointeurs sur un int, sur un double, sur un objet de type fraction etc. La définition d'un pointeur se fait comme suit :
Définition d'un pointeur : type * nom;
nom est un pointeur sur type, i.e. pouvant recevoir une adresse désignant un objet de type type. Il faut noter que le symbole * s'applique à nom: ``int *p, i;'' définit un pointeur p sur int et une variable i de type int. L'adresse 0 est utilisée pour signifier qu'un pointeur ne pointe sur rien. Noter qu'un pointeur sur un type T est une variable comme une autre, ayant sa propre adresse qu'il est possible de stocker dans un pointeur de type ``pointeur sur pointeur sur T'' (i.e. ``T * *'') etc. Il y a deux opérations fondamentales :

Étant donnée une variable V, il est possible d'obtenir l'adresse de V avec l'opérateur & : &V représente l'adresse mémoire de V.
Étant donné un pointeur P, il est possible de désigner l'objet pointé par P (i.e. l'objet situé à l'adresse contenue dans P) au moyen de l'opérateur (unaire) * : ``*P'' désigne l'objet pointé par P. Par exemple :
```
int i, *pi, k;
i=3;
pi = &i;       // pi pointe sur i
k = (*pi)+5;   // identique à :   k=i+5
(*pi) = k+2;   // identique à :  i = k+2
(*pi)++;
// ici, i=11, k=8
```

Connaissant l'adresse d'un objet, il est donc possible d'utiliser sa valeur et de la modifier. Cela offre une autre manière de passer des arguments à des fonctions pouvant les modifier: au lieu du passage par référence, il est possible de passer (par valeur) des adresses et de modifier les données contenues à ces adresses via l'opérateur *. La fonction permut de la section 10.2 pourrait s'écrire :

//=========================
void permut(int * pa, int * pb)
{
int aux = (*pa);
(*pa) = (*pb);
(*pb) = aux;
}

L'appel de cette fonction permut doit prendre deux adresses : pour échanger les valeurs des variables i et j, on écrirait ``permut(&i,&j);''. Cette méthode (passage des adresses) est la seule possible en C (le passage par référence n'existe pas). En fait, les mécanismes internes sont similaires.