Pointeurs

     

Pascal et C offrent un type pointeur. Plus exactement, il s'agit d'un constructeur de type, noté *, qui s'applique à un type t quelconque pour construire le type des pointeurs de t, noté t* quand t est un type simple. Quel que soit le type t, une valeur de type pointeur de t est une adresse ou bien la constante 0 (ou NULL,     définie dans stdio.h).

On définit une variable de type int*, c'est-à-dire pointeur de int, par :

 

int *ip;

Cette définition est incomplète car elle n'est pas initialisée. Il y a plusieurs façons d'initialiser un pointeur. La première est d'utiliser la valeur d'un autre pointeur de même type (qui aurait déjà été initialisé...) :

 

int *iq = ...;
int *ip = iq;

La seconde est d'utiliser l'opération &  appliquée à une variable de type t (figure ) :

int i;
int *ip = &i;

  
Figure: Initialisation d'un pointeur par une adresse d'objet

Signalons également le cas particulier des pointeurs de caractères, qui peuvent être initialisés par une chaîne littérale :

const char *cp = "Turing";

Cette définition a pour effet d'allouer quelque part la chaîne "Turing" et de donner pour valeur à cp l'adresse de cette chaîne, laquelle ne sera pas modifiable (même si const n'est pas spécifié).

La troisième est d'allouer de la mémoire explicitement (figure ) :

int *ip = malloc(sizeof(int));

  
Figure: Initialisation d'un pointeur par allocation dynamique

On reviendra sur ces deux dernières façons. Noter que int *ip = ... signifie en fait int* ip = ..., qui est une autre écriture permise et non *ip = ... ; d'ailleurs, si l'initialisation se fait ultérieurement par affectation, on écrirait respectivement :

  ip = iq;
  ip = &i;
  ip = malloc(sizeof(int));

et surtout pas

  *ip = iq;   /* faux */

ce qui serait incorrectement typé (*ip est un entier, iq est un pointeur).

Enfin, on peut initialiser un pointeur à 0, ou de façon équivalente, à NULL :

int *ip = 0;
int *iq = NULL;

Si E est une expression de type pointeur de t, alors *E est une expression correctement typée de type t, qui peut être placée à gauche d'une affectation, comme une variable, ce qui signifie qu'elle doit désigner un objet de type t. Mais l'utilisation de cette variable a de fortes chances de provoquer un << segmentation fault >>.