1. Introduction et rappel : adresse d'une variable

En langage C, vous savez qu'on peut accéder à l'adresse mémoire de n'importe quelle variable avec l'opérateur éperluette & :

int main() {
  float x = 1.2; // la variable x est créée à une certaine adresse

  // affiche 1.2000
  printf("Valeur de la variable x  %f\n", x);

  // affiche, en hexadécimal, l'adresse à laquelle la variable i existe en mémoire
  printf("Adresse de la variable x %p\n", &x);
  // Rappel : dans la chaîne de format passée à la fonction printf(),
  // %p permet de formater une adresse en hexa
}
          

Dans ce code, la variable x

• est créée quelque part en mémoire, à une certaine adresse (dans la zone mémoire appelée pile)
• est de type float : elle donc occupe donc 4 octets en mémoire et permet de stocker un nombre flottant.
• a pour valeur 1.2

Et (&x) (lire "adresse de x"):

• est de type adresse d'un float
• a pour valeur l'adresse de la variable x. Cette adresse où la variable va vivre en mémoire est choisie par le système, mais le développeur peut y accéder.

Puisqu'on peut accéder à l'adresse de n'importe quelle variable, pourquoi ne pourrait-on pas stocker cette adresse dans une autre variable ? Eh bien, c'est précisément ce que permet de faire une variable pointeur.

2. Déclarer et initialiser une variable pointeur

Un pointeur est typé par le type de la chose pointée. Un "pointeur" (sans plus de précision) ne veut pas dire grand chose. On parlera par exemple de "pointeur sur un int", ou de "pointeur sur float", etc.

[TYPE_DE_LA_CHOSE_POINTEE] * nom_choisi_pour_ma_variable_pointeur ;
// crée une variable nommée nom_choisi_pour_ma_variable_pointeur,
// de type "pointeur sur TYPE_DE_LA_CHOSE_POINTEE".
// Exemple :
float * p; // p est un pointeur - sur - float
              

Un premier exemple pas à pas...

 /**
  * Pointeur : première approche
  */
 int main() {
   int i = 5;
   int *unPtr; // un pointeur-sur-entier, non intialisé)

   printf("Valeur de i %d\n", i);
   printf("Valeur de unPtr %p\n", unPtr);

   unPtr = &i; // la valeur de unPtr est désormais l'adresse de i
               // <=> "unPtr pointe i"
   printf("Adresse de i %p\n", &i);
   printf("Valeur de p %p\n", unPtr);

   printf("Adresse de unPtr %p\n", &unPtr);
   return 0;
 }
                 

Les variables sont créées en mémoire. Le pointeur unPtr est une variable comme les autres : elle existe quelque part en mémoire.

La variable i (un int) occupe 4 octets.

La variable unPtr (un pointeur) occupe la taille d'une adresse mémoire. Sur un ordinateur récent, c'est 8 octets.

i vaut 5.

La variable unPtr n'a par contre pas été initialisée. Sa valeur dépend, comme d'habitude, des bits qui étaient allumés à cet endroit en mémoire, au moment de la création de la variable. On dit qu'elle est "aléatoire" (par exemple, peut-être, 0x0000ff00).

Ces deux appels de printf affichent donc, par exemple, dans le Terminal :

Valeur de i 5
Valeur de p 0x0000ff00
                    

On affecte à unPtr l'adresse de la variable i.

Dès lors, on dit que unPtr pointe la variable i.

Pour symboliser le fait que unPtr pointe i, on dessine usuellement une flèche allant de la case mémoire de unPtr vers la case mémoire de i.

Vérifions que la variable unPtr stocke bien désormais l'adresse de la variable i, en affichant tout cela dans le Terminal :

                        Adresse de i 0xbffff308
                        Valeur de p 0xbffff308
                     

unPtr est une variable... qui existe quelque part en mémoire. Rien n'empèche donc d'afficher l'adresse de unPtr si ça nous amuse ! Cette ligne affiche donc dans le terminal, dans notre cas :

Adresse de unPtr 0xbffff300
                        

Un second code, un peu plus complet (mais toujours pas bien utile, vous avez raison...) :

 int main() {
   float x = 1.2;
   float * pointeur_sur_un_float; // Création d'une variable pointeur.
   // Le nom de cette variable est pointeur_sur_un_float
   // Le type de cette variable est "pointeur - sur - float".
   // Comme toute variable déclarée, cette variable existera quelque part en mémoire.
   // Pour le moment, on ne l'a pas initialisée : sa valeur est, comme d'habitude, aléatoire.

   pointeur_sur_un_float = &x;  // Affecte l'adresse de x à la variable pointeur_sur_un_float
   // Desormais, la valeur de la variable pointeur_sur_un_float est l'adresse de la variable x.
   // On dit que pointeur_sur_un_float "pointe" x

   // Affichons deux fois l'adresse de x :
   printf("Adresse de la variable x : %p\n", &x);
   printf("Adresse de la variable x : %p\n", pointeur_sur_un_float);

   int i = 1;
   int * p; // p est un pointeur sur un int
   p = &i;  // on affecte l'adresse de i à la variable p
   // Desormais, la valeur de la variable p est l'adresse de la variable i.
   // On dit que p "pointe" i

  double *p1, *p2, x;
  // déclaration de 3 variables.
  // p1 et p2 sont deux pointeurs - sur - double.
  // x est un double.
  return 0;
 }
           

Une analogie pour comprendre

Taille occupéé en mémoire par une variable pointeur ?

Une petite précision maintenant...

Dans la section précédente, on a dit que l'instruction float * ptr; déclare une variable nommée ptr qui est de type pointeur - sur - float.

Cette formulation n'est en fait pas tout à fait précise. Il serait plus adéquat de dire que l'instruction float * ptr; déclare une variable nommée ptr telle que (*ptr) soit de type float (ce qui implique bien sûr que ptr est bien de type pointeur - sur - float).

En effet, cette seconde formulation permet de mieux comprendre ce qui se passe lorsqu'on déclare plusieurs variables sur une même ligne, comme dans l'exemple suivant :

double *p1, x=29.8, y, *p2 = &x;
            

Cette ligne déclare 4 variables : p1, x, y et p2, telles que *p1, x, y et et *p2 sont de type double. Autrement dit : x et y sont deux variables de type double , et p1 et p2 deux variables de type pointeur - sur - double.

Remarque : avec cette ligne, seules les variables x et p2 ont été initialisées : x vaut 29.8 et p2 pointe la variable x. A l'inverse, y et p1 ne sont initialisées : leur valeur est "aléatoire". Ce qui est vraiment très mal, comme expliqué dans la section 4.

3. Opérateur d'indirection * : accéder à la case mémoire pointée

En conséquence...

                   double x = 87.;
                   double *ptr = &x;      // ptr est un pointeur qui pointe la variable x
             

                   &x    <=>    ptr       // ptr vaut l'adresse de x
                   x     <=>    *ptr      // *ptr est la même chose que x
             

Ainsi donc, on peut utiliser une variable pointeur pour manipuler la variable pointée, comme dans les exemples suivants.

L'opérateur d'indirection * pour déréférencer un pointeur.

    /**
     * Déréférencement de pointeur avec *
     */
    int main() {
      int i, j;
      i=9;
      int *p = &i; // un pointeur qui pointe la variable i

      printf("Valeur de i %d. Ou encore : %d\n", i, *p);

      *p = 29 ;
      printf("Nouvelle valeur de i : %d\n", i);

      j = *p + 2;
      printf("Valeur de j %d\n", j);

      p = &j; // p pointe j, maintenant

      *p = *p  * 2;
      printf("Valeur de j %d\n", j);

      printf("Donnez une valeur pour j : \n");
      scanf("%d", p);

      return 0;
    }
                    

i vaut 5.

Le pointeur p pointe i.

j n'est pas initialisée (aléatoire).

Puisque p pointe i, alors *p est la même chose que i.

Cette ligne affiche donc dans le Terminal :

Valeur de i 5. Ou encore : 5
                         

On utilise l'opérateur d'indirection * sur le pointeur pour changer la valeur de la variable pointée, c'est à dire la valeur de i.

Le printf() affiche donc dans le Terminal :

Nouvelle valeur de i : 29
                       

Puisque *p (c'est à dire la variable i) vaut 29, désormais j vaut 31.

Le printf() affiche donc dans le Terminal :

Valeur de j : 31
                       

Désormais, p pointe j.

Le printf() affiche dans le Terminal :

Valeur de j : 62
                       

Puisque p pointe j, ou (c'est un synonyme) p a pour valeur l'adresse de j, on peut utiliser p dans un scanf() pour changer la valeur de j.

Et voici un code exemple un peu plus complet :

int main() {
  int k = 4;
  int * p1 ;  // la variable p1 est un pointeur - sur - entier

  p1 = &k;    // p1 pointe désormais la variable k
  // donc :     *p1 <=> k     et      p1 <=> &k

  printf("Valeur de k %d\n", k); //  affiche 4

  // On peut aussi afficher la valeur de k en utilisant le pointeur :
  printf("Valeur de k, en utilisant le pointeur %d\n", *p1); //  affiche 4 aussi !

  // On peut aussi utiliser le pointeur pour changer la valeur de k :
  *p1 = 89;   // Affecte 89 à la chose pointée par p1... c'est à dire à la variable k
  printf("Valeur de k %d\n", k);    //  affiche 89
  printf("Valeur de k %d\n", *p1);  //  affiche aussi 89

  double x;
  printf("donnez la valeur de x\n");
  scanf("%lf", &x);
  printf("valeur de x %lf\n", x); // bon... affiche la valeur de x, entrée par l'utilisateur

  double *px = &x ; // px est un pointeur qui pointe x
  printf("donnez une nouvelle valeur pour x\n");
  scanf("%lf", px); // puisque px pointe x, alors px <=> &x.
  // Donc cette ligne va mettre dans x la nouvelle valeur donnée par l'utilisateur.

  // On affiche 2 fois la nouvelle valeur de x, 2eme valeur entrée par l'utilisateur
  printf("valeur de x %lf\n", x);
  printf("valeur de x %lf\n", *px);
}
          

Reprenons notre analogie

4. Initialisation d'un pointeur et mot clé NULL

Pour initialiser un pointeur, plusieurs possibilités :

• à l'adresse d'une variable déjà déclarée : int * ptr = &unEntier;
• à une adresse obtenue lors d'une allocation dynamique de la mémoire : int * ptr = calloc(3, sizeof(int)); (cf. la fiche XXXXXXX allocation dynamique à venir)
• dans le cas où on travaille avec du hardware, à l'adresse d'un registre précisé dans la documentation du fabriquant : int * ptr = 0xFF0598AB; // où la documentation indique que ce registre, par exemple, permet d'allumer une diode d'une carte PCI
• enfin, lorsqu'on ne sait pas encore où le pointeur va pointeur, on l'initialisera toujours à la valeur NULL :

                int * unPointeurQuOnSaitPasEncoreOuQuIlPointe = NULL ; // un pointeur valant NULL,
                                                                       // <=> qui ne pointe nul part
              

Pourquoi faut-il initialiser un pointeur à NULL si on ne sait pas encore où le faire pointer ?

                 int main() {
                   int i = 8, j = 4;
                   int * p1 ;  // la variable p1 est un pointeur sur entier.
                   // p1 n'a pas été initalisé => sa valeur est aléatoire.
                   // Donc p1 pointe n'importe où en mémoire !

                   *p1 = 87; // on utilise le pointeur non initialisé => danger !!

                   printf("i %d ; j %d", i, j);
                  }
             

                   int main() {
                     int i = 8, j = 4;
                     int * p1 = NULL;  // on initialise p1 à NULL tant qu'on ne sait pas où le faire pointer

                     // ... de telle sorte qu'on évite le comportement aléatoire :
                     //  si on a le malheur de déréférencer le pointeur p1
                     // avant de le faire "pointer quelque part",
                     // on est sûr qu'une segmentation fault se produit  :
                     *p1 = 87; // => arrêt immédiat et systématique du programme
                               // au lieu d'un comportement aléatoire. Ouf !
                     printf("i %d ; j %d", i, j);
                    }
               

Pour finir :

5. Convention de nommage

Dans notre grande série "utiliser des noms signifiants pour vos variables et fonctions", aujourd'hui, nous conseillons fortement de :

En effet, même si un pointeur est somme toute une variable comme les autres (si ce n'est que sa valeur est une adresse, au lieu d'une bonne vieille valeur entière, d'un float, d'un Koala ou d'autre chose...), l'expérience montre qu'il est fort utile que le nom du pointeur indique au premier coup d'oeuil le fait que c'est un pointeur.

On n'écrira donc PAS, par exemple :

 int main() {
   int i = 8;
   int * j = &i;  // j point i
   *j = 89; // affecte 89 à la chose pointée par j, donc à i.
 }
           

mais plutôt :

int main() {
  int i = 8;
  int * ptr = &i;  // "ptr" dénote bien le fait que la variable est un pointeur
  *ptr = 89; // affecte 89 à la chose pointée par ptr, donc à i.

  // ou encore :
  // int * p = &i;
  // int * p_i = &i;
  // int * p1 = &i;
  // etc.
 }
            

S'entrainer

 /**
  * Une jolie fonction ppale
  */
 int main() {
   int i = 12;
   int j = 13;
   int * p = &i;
   *p = 0;
   p = &j;
   *p = 1;
   j = 56;
   printf("A %d B %d C %d\n", i, j, *p);
 }
    

 /**
  * Bidouillons avec des pointeurs
  */
 int main() {
   double * ptr;
   double x;
   double y;
   *ptr = 3.14;
   x = *ptr;
   printf("A %lf B %lf\n", x, *ptr);
 }