Tutoriel de programmation C sous Linux Partie 21 : Pointeurs de caractères, tableau de pointeurs et pointeur vers pointeur

Le concept de pointeurs est en effet l’un des concepts très importants dans le langage de programmation C. Jusqu’à présent, nous avons discuté de plusieurs aspects des pointeurs en C. En nous appuyant sur cela, dans ce tutoriel, nous allons discuter de quelques autres concepts de pointeurs.

Pointeurs de caractères, tableau de pointeurs et pointeur vers pointeur en C

Commençons par les pointeurs de caractères avec les lignes de code suivantes :

char p[] = "J'aime HowtoForge"  
char *p = "J'aime HowToForge"

La première ligne définit un tableau ‘p’ de taille égale au nombre de caractères entre guillemets. Mais la ligne suivante définit un pointeur ‘p’ qui pointe vers une constante de chaîne.

La différence ici est que le premier ‘p’ étant un tableau, vous pouvez facilement modifier ou changer le contenu du tableau. Mais puisque le second ‘p’ pointe vers une constante de chaîne, vous ne pouvez tout simplement pas changer le contenu de la chaîne.

Par exemple, le morceau de code suivant essaie de modifier une constante de chaîne :

#include   
  
int main()  
{  
   char *p = "J'aime HowToForge";  
   
   p[0] = 'U';  
  
   return 0;  
}

Et voici la sortie produite par ce code sur mon système :

Erreur de segmentation

Cette erreur suggère que l’exécution du programme s’est arrêtée brusquement, et c’est parce que nous avons essayé de changer quelque chose qui est constant.

De plus, gardez à l’esprit que bien que le pointeur ‘p’ puisse être fait pour pointer vers une chaîne différente, vous ne pouvez pas changer l’adresse de base du tableau ‘p’ (si vous vous en souvenez, nous en avons déjà discuté dans l’un de nos tutoriels précédents).

Passons maintenant aux tableaux de pointeurs, tout comme vous avez vu des tableaux d’entiers, de caractères et d’autres types, il peut également y avoir un tableau de pointeurs. Par exemple, le programme suivant définit un tableau ‘arr’ de pointeurs d’entiers et lui assigne des valeurs.

#include   
  
int main()  
{  
 int *arr[3];  
 int a = 0, b = 1, c = 2;  
   
 arr[0] = &a;  
 arr[1] = &b;  
 arr[2] = &c;  
  
 return 0;  
}

Notez que les valeurs assignées au tableau sont des adresses. C’est parce que ‘arr’ est un tableau de pointeurs, et les pointeurs ne stockent rien d’autre que des adresses. Maintenant, si vous voulez accéder aux valeurs conservées à ces adresses, vous devrez utiliser l’opérateur *.

L’exemple suivant (qui n’est rien d’autre qu’une extension de l’exemple précédent) illustre cela :

#include   
  
int main()  
{  
   int *arr[3];  
   int a = 0, b = 1, c = 2;  
   
   arr[0] = &a;  
   arr[1] = &b;  
   arr[2] = &c;  
   
   for(int i=0; i < 3; i++)  
      printf("\n arr[%d] est : %d",i,*(arr[i]));  
  
 return 0;  
}

Voici la sortie :

arr[0] est : 0   
arr[1] est : 1   
arr[2] est : 2 

Tout comme les tableaux de pointeurs d’entiers (comme celui que nous avons discuté ici), vous pouvez avoir des tableaux stockant des pointeurs de caractères et plus encore.

Maintenant, passons aux pointeurs vers des pointeurs. Comme nous l’avons itéré plusieurs fois jusqu’à présent, un pointeur stocke une adresse. Maintenant, jusqu’à présent dans cette série de tutoriels de programmation C en cours, nous n’avons vu qu’un pointeur pointant vers une variable non pointeur, mais le fait est que les pointeurs peuvent également pointer vers d’autres pointeurs.

Cela signifie qu’un pointeur peut stocker une adresse d’un autre pointeur. Par exemple, ce qui suit est un double pointeur ou un pointeur vers pointeur :

int **ptr;

Voici un morceau de code qui utilise un double pointeur :

#include   
  
int main()  
{  
   int *ptr;  
   int p;  
   
   int a = 10;  
   
   ptr = &a;  
   
   p = &ptr;  
   
   printf("\n Le pointeur 'p' pointe vers le pointeur 'ptr' qui pointe en outre vers la valeur : %d", p);  
  
   return 0;  
}

Voici la sortie :

Le pointeur 'p' pointe vers le pointeur 'ptr' qui pointe en outre vers la valeur : 10

Ceci était un exemple de double pointeur. Sur des lignes similaires, vous pouvez avoir un pointeur vers un pointeur vers un pointeur, défini par exemple comme int *ptr. Le nombre maximum de niveaux de ‘pointeur vers pointeur vers……’ est spécifique à l’implémentation (dans certains cas, la limite est de 12 cependant).

Pratiquement, cependant, vous ne rencontrerez probablement que des pointeurs vers des pointeurs jusqu’au niveau trois, car avoir plus de niveaux rend la logique plus complexe à comprendre et à maintenir.

Conclusion

Nous avons discuté ici de trois concepts de pointeurs importants. Vous êtes conseillé d’essayer les exemples et les concepts que nous avons discutés ici sur votre système pour mieux comprendre comment ces choses fonctionnent. En cas de doute ou de question, laissez-nous un commentaire ci-dessous.