1. Opération sur les adresses : arithmétique de pointeurs

On peut écrire deux types d'opératiosn avec des pointeurs :

• des opérations arithmétiques
• et des expressions booléennes

Commençons par l'arithmétique. L'arithmétique de pointeur, en C, c'est la possibilité d'effectuer des calculs sur des adresses mémoire - donc sur des pointeurs.

Reprenons notre analogie.

Et en ce qui concerne les opérations booléennes sur les pointeurs :

Voyons tout cela sur un exemple :

int main() {
   int i = 8;
   int * ptr = &i ;  // ptr pointe i
   printf("Valeur de ptr (adresse de i) : %p\n", ptr);
   printf("Valeur de ptr+1 (adresse suivant la variable i) : %p\n\n",  ptr+1  );


   // RAPPEL: pour un tableau de N éléments:
   // La 1ère case du tableau est à l'indice entier 0
   // La dernière case du tableau est à l'indice entier (N-1)
   // RAPPEL : un double occupe 8 octets en mémoire
   double tab[10];

   if(tab == & tab[0]) {
     printf("La valeur de la variable tableau tab est bien la même que l'adresse de la première case\n");
   }
   printf("Adresse de la première case du tableau : %p\n", tab);

   double * pa = & tab[0];
   printf("Valeur du pointeur qui pointe la 1ère case du tableau : %p\n\n", pa);

   double * pb = (pa + 1);   // ARITHMETIQUE DE POINTEUR : adresse + entier => adresse
   // Comme pa est de type (double *), et qu'un double occupe 8 octets,
   //  alors ajouter pa+1 (cases) ajoute en fait (1*8) octets à l'adresse pa.
   // Autrement dit : pb pointe la case 2ème case (d'indice 1) du tableau !

   printf("Valeur du pointeur pb : %p\n\n", pb);
   printf("Vérifions que c'est bien l'adresse de la 2ème case du tableau : %p\n\n", & tab[1]);

   if(pb > pa) {
     printf("La case mémoire pointée par pb est bien plus loin que celle pointée par pa\n\n");
   }

   // vérifions encore...
   printf("Valeur de pa+7, adresse de la 8ème case du tableau : %p\n", pa+7);
   printf("(On vérifie que (pa+7) ajoute bien 7*8 == 56 octets à l'adresse pa.)\n\n");


   double *pc = & tab[5];
   printf("Valeur de pc, c'est à dire adresse de la 6ème case du tableau : %p\n", pc);

   int nbCases = pc-pa; // // ARITHMETIQUE DE POINTEUR : adresse - adresse => entier
   // Les deux adresse p5 et p0 sont toutes deux de type (double *) => ca marche
   // La soustraction des deux adresses de même type est comptée en nombre de cases
   //   (ici : nombre de paquet de 8 octets, puisque les pointeurs sont de type double *)

   printf("Nombre de cases séparant les adresses pointées par pc et par pa : %d\n", nbCases);
}
       

Lorsqu'on exécute ce programme, en supposant que la variable i est placée à l'adresse 0x7fff58330a8c et le tableau tab à l'adresse 0x7fff4ff8eaa0, alors on obtient dans le Terminal :

Valeur de ptr (adresse de i) : 0x7fff58330a8c
Valeur de ptr+1 (adresse suivant la variable i) : 0x7fff58330a90

La valeur de la variable tableau tab est bien la même que l'adresse de la première case
Adresse de la première case du tableau : 0x7fff4ff8eaa0
Valeur du pointeur qui pointe la 1ère case du tableau : 0x7fff4ff8eaa0

Valeur du pointeur pb : 0x7fff4ff8eaa8
Vérifions que c'est bien l'adresse de la 2ème case du tableau : 0x7fff4ff8eaa8

La case mémoire pointée par pb est bien plus loin que celle pointée par pa

Valeur de pa+7, adresse de la 8ème case du tableau : 0x7fff4ff8ead8
(On vérifie que (pa+7) ajoute bien 7*8 == 56 octets (ou 0x38 en hexa) à l'adresse pa).

Valeur de pc, c'est à dire adresse de la 6ème case du tableau : 0x7fff58330ac8
Nombre de cases séparant les adresses pointées par pc et par pa : 5
       

On observe bien, dans cet exemple, que l'arithmétique de pointeur travaille en "nombre de cases" :

• 4 octets si les adresses manipulées sont de type int *
• 8 octets si les adresses manipulées sont de type double *
• 1 octet si les adresses manipulées sont de type char *
• etc.

On retrouvera cette propriété, bien utile, dans la fiche suivante "pointeurs et tableaux".

2. Quelques compléments sur les types des pointeurs

On évitera, par exemple, d'affecter à un pointeur - sur - float l'adresse d'une variable entière, ou encore d'affecter une valeur entière à un pointeur (un entier n'est pas une adresse !).

Si on écrit le code :

int main() {
   int i = 8;
   float * ptr = &i;  // oups !
   int * p = 78;      // oups !
   double * p_y;
   p_y = ptr ;        // oups !
   if(p_y == p) {
     printf("p_y et p pointent la même adresse\n");
   }
}
         

ttt.c:3:13: warning: incompatible pointer types initializing 'float *' with an expression of type 'int *' [-Wincompatible-pointer-types]
      float * ptr = &i;  // oups !
                  ^     ~~
ttt.c:4:11: warning: incompatible integer to pointer conversion initializing 'int *' with an expression of type 'int' [-Wint-conversion]
      int * p = 78;      // oups !
              ^
ttt.c:6:9: warning: incompatible pointer types assigning to 'double *' from 'float *' [-Wincompatible-pointer-types]
      p_y = ptr ;        // oups !
          ^
ttt.c:7:12: warning: comparison of distinct pointer types ('double *' and 'int *') [-Wcompare-distinct-pointer-types]
      if(p_y == p) {
             ^
        

Ces warnings du compilateur "incompatible pointer type" sont très importants. Il ne faut pas les ignorer. Pensez aux équations aux dimensions en Physique. En physique, dans une équation, la dimension de ce qui est à droite et à gauche doivent être les mêmes, sans quoi c'est que vous faites n'importe quoi ! Eh bien, c'est la même chose lorsqu'on programme en C avec des pointeurs.

En savoir plus : "tricher" sur le type des adresses

int main() {
  int i = 8;  // i est un int, donc occupe 4 octets en mémoire

  // Trichons un peu, et faisons comme si, à l'adresse de i, nous avions
  // non pas une variable de type int, mais un simple octet...
  char * ptr = &i;// ptr pointe i...
                  // Mais en considérant cette adresse comme étant celle d'un octet
                  // (un char) et non pas d'un entier !
  *ptr = 0x00;    // On affecte 0 au 1er octet de la variable i
  ptr ++;         // ou ptr = ptr+1 (arithmétique de pointeur)
                  // Désormais, ptr pointe le 2nd octet de la variable i,
                  // considéré comme un char
  *ptr = 0x00;    // On affecte 0 au 2eme octet de la variable i
  ptr ++;         // ptr pointe le 3eme octet de la variable i, considéré comme char
  *ptr = 0xFF;    // On affecte 255 au 3eme octet de la variable i
  ptr ++;         // ptr pointe le 3eme octet de la variable i, considéré comme char
  *ptr = 0x01;    // On affecte 1 au 4eme octet de la variable i

  // autrement dit, on a manipulé i comme une suite de 4 octets
  // pour "allumer" un à un les bits de chacun de ces octets !
  printf("i ? %d\n", i); // affiche la nouvelle valeur de i
 }
          

En savoir plus : le type void * et les pointeurs génériques

int main() {
  int i = 8;

  void * p = &i;
  // p est un pointeur de type "void".
  // Sa valeur est l'adresse de la variable i.
  // Ce code ne provoque pas de warning de compilation :
  // on peut affecter un pointeur - sur - void l'adresse de n'importe quel type de variable.
  // ... mais, par contre, le pointeur p ne "sait pas" qu'il pointe un entier
 }
          

int main() {
  int i = 8;

  void * p = &i;
  // p est un pointeur de type "void".
  // Sa valeur est l'adresse de la variable i
  // ... mais p ne sait pas qu'il pointe un entier

  *p = 10298 ;        // ERREUR de compilation.
                      // Car comment savoir sur combien d'octets affecter
                      // la valeur 10298 ?
  void * p2 = p + 9 ; // ERREUR de compilation (... en général ...
                      // mais certains compilateurs sont peut regardant ...)
                      // Car combien d'octets faudrait-il ajouter à l'adresse p ?
 }
          

void * memcpy(void *restrict dst, const void *restrict src, size_t n);
DESCRIPTION
   The memcpy() function copies n bytes from memory area src to memory area dst.
   (etc.)
          

S'entrainer

      #include <stdio.h>

      int main() {
          char c = 'a';
          char * p1 = &c;

          int i = 12;
          int * p2 = &i;

          double tab[4] ;
          double * p3 = tab;

          printf("valeur de l'adresse stockée dans p1 %p\n", p1);
          printf("valeur de l'adresse stockée dans p2 %p\n", p2);
          printf("valeur de l'adresse stockée dans p3 %p\n", p3);

          p1 = p1 + 1 ;
          p2 = p2 + 2 ;
          p3 = p3 + 3 ;

          printf("Nouvelle valeur de l'adresse stockée dans p1 %p\n", p1);
          printf("Nouvelle valeur de l'adresse stockée dans p2 %p\n", p2);
          printf("Nouvelle valeur de l'adresse stockée dans p3 %p\n", p2);

          *p1 = 'b';
          *p2 = 89;
          *p3 = 2.71828;

          printf("tab[3] = %lf\n", tab[3]);

          return 0;
      }
    

valeur de l'adresse stockée dans p1 0x7fff5465fa9b
valeur de l'adresse stockée dans p2 0x7fff5465fa8c
valeur de l'adresse stockée dans p3 0x7fff5465faa0
    

        Nouvelle valeur de l'adresse stockée dans p1 0x7fff5465fa9c
        Nouvelle valeur de l'adresse stockée dans p2 0x7fff5465fa94
        Nouvelle valeur de l'adresse stockée dans p3 0x7fff5465fa94

        Nouvelle valeur de l'adresse stockée dans p1 0x7fff5465fa9c
        Nouvelle valeur de l'adresse stockée dans p2 0x7fff5465fa8e
        Nouvelle valeur de l'adresse stockée dans p3 0x7fff5465faa3