Les pointeurs Le langage C permet de manipuler des adresses d objets ou de fonctions par le biais de pointeurs. Pour ce faire on peut désigner des variables dites de type pointeur, destinées à contenir des adresses mémoires. Les pointeurs sont fortement typés, par exemple nous ne pouvons pas placer des caractères dans l adresse mémoire pointée par un pointeur de type entier. L utilisation de l opérateur cast peut toutefois autoriser certaines conversions. Il nous est possible effectuer, dans une certaine mesure, des opérations arithmétiques sur les pointeurs : incrémentation, décrémentation, soustraction. Ces opérations vont plus loin qu un simple calcul d adresse, elles prennent en compte la taille des objets pointés. Nous verrons également qu il y a une étroite relation entre la notion de tableau et celle de pointeur. 1. La notion de pointeur La déclaration suivante : int *adr ; Précise que adr est une variable de type pointeur sur des objets de type int. 1.1. Attribuer une valeur à une variable de type pointeur Etant donné que la variable adr n a pas encore été initialisées, alors sa valeur est pour l instant indéfinie. Pour attribuer une valeur à adr, il faut la faire pointer sur un entier précis. Pour faire cela il existe différentes méthodes : Méthode 1 : int n ; adr = &n ; ou int tab[3] ; adr = &tab[0] ; 1
Méthode 3 : #include <stdlib.h> Adr = (int) malloc( sizeof(int) ); La première méthode consiste à affecter à adr l adresse réservée à la variable n ou à l élément d indice 0 du tableau d entiers tab[0]. La seconde méthode consiste à allouer dynamiquement un emplacement mémoire d une taille égale au type qui y sera stocké. 1.2. L opérateur * Cet opérateur sert à accéder à la valeur de l objet pointé. Si adr est un pointeur alors *adr est l objet pointé par adr. Exemple : int * adr; int n = 20; ad = &n; /*ad pointe sur l'entier n qui contient la valeur 20 */ printf("%d", *ad); /*affiche la valeur de 20 */ *ad = 30; printf("%d", *ad); /*affiche la valeur de 30 */ printf("%d", n); /* affiche la valeur de 30 aussi */ L avant dernière instruction est équivalente à : n = 30; L intérêt d une telle utilisation peut s avérer utile, comme dans le cas suivant :... if (n>p) adr = &n; else adr = &p;... *adr = 30; /* place la valeur de 30 dans n ou dans p suivant le cas */ Si l emplacement adr avait été alloué dynamiquement alors l on pourrait affecter une valeur à l adresse mémoire réservée de la même façon : adr = malloc(sizeof(int)) ; *adr = 30; 1.3. Exemples de déclarations de pointeurs Déclaration de pointeurs sur des objets de type de base ou de type structure, ou défini par typedef. 2
unsigned int n, *ptr, q, *adr; struct point { char nom; int x, y; }; - adr et ptr sont des pointeurs sur des éléments de type unsigned int - Il est nécéssaire de répéter le symbole * dans chaque déclarateur de pointeur. - ps est un pointeur sur des structures de type struct point. - s est une structure de type struct point. struct point *ps, s; typedef int vecteur[3]; vecteur *pv; - vecteur est synonyme de int[3] - pv est un pointeur sur des tableaux de 3 int pointeur de pointeur float x, *pf, **ppf; - x est un float et pf est un pointeur sur un float - **ppf est un float - *ppf est un pointeur sur un float - ppf est un pointeur sur un pointeur sur un float int (**chose)[10]; - (* *chose)[10] est un int - (* *chose) est un tableau de 10 int - *chose est un pointeur sur un tableau de 10 int - chose est un pointeur de pointeur sur un tableau de 10 int Attention à bien mettre les parenthèses ici. Sans les parenthèses l interprétation est différente comme nous pouvons le voir dans la suite. int *pt[10]; - *pt[10] est un int - pt[10] est un pointeur sur un int - pt est un tableau de 10 pointeurs sur un int int **ppt[10]; - **ppt[10] est un int - *ppt[10] est un pointeur sur un int - ppt[10] est un pointeur sur un pointeur sur un int - ppt est un tableau de 10 pointeurs sur un pointeur sur un int int *f(float x); - *f(float x) est un int - f(float x) est un pointeur sur un int - f est une fonction recevant un float et retournant un pointeur sur un int 2. Les propriétés des pointeurs 2.1. Opérations entre pointeurs Addition ou soustraction d un entier à un pointeur : Si nous déclarons un pointeur comme ci-dessous : int * adr; 3
alors l expression adr + 1 va retourner un pointeur sur un int et sa valeur est l adresse de l entier suivant l entier pointé par adr. On pourra relever que la différence entre l adresse de pn et pn+1 est de 4. Cette valeur correspond au nombre d octets d un int. pn + 1 ne modifie pas le contenu de pn. Par contre l appel à pn++ va faire pointer pn vers l adresse (pn+1) et dans ce cas le contenu de pn vas changer. De la même façon : pn+3 permet de pointer sur un int qui se troive trois adresses plus loin que celle contenue dans pn. Donc attention à l emploi de cette opération!! /!\ pn++!= (pn+1) Soustraction entre deux pointeurs : Il est possible de soustraire les valeurs de deux pointeurs de même type. Comme nous l avons vu précédemment, en additionnant un entier n à un pointeur pn cela nous positionne sur la nième adresse devant pn. Soit par exemple les pointeurs suivants : int *pn, *pm; pm = pn + 4; printf("%d", pn - pm); /* va afficher 4 */ pm pn va retourner 4 qui correspond au nombres d adresses mémoires contenant un int entre pm et pn. De même dans le cas suivant : int t[10]; int *pn = &t[3]; int *pm = &t[8]; pm - pn /* va retourner 5 */ Il y a bien 5 éléments de type int séparant t[3] et t[8]. 4
2.2. Lien entre pointeurs et tableaux Tableau à une dimension : Soit un tableau tab de int et un pointeur pn sur un int déclarés comme suit : int tab[10], *pn; Pour accéder au nième élément du tableau, on fait appel à tab[n]. Maintenant faisons pointer pn sur le premier élément du tableau tab : pn = &tab[0]; /* ou pn = &tab; ce qui est équivalent */ Pour accéder au nième élément du tableau, il suffit d écrire : tab[n] ou *(pn + n) Exemple : int *pn, tab[5]={4,2,7,0,6}; printf("%d\n", tab[3]); /* affiche 0 */ pn = &tab; printf("%d\n", *(pn+3)); /* affiche 0 aussi */ Ainsi, déclarer un tableau revient à déclarer un pointeur sur un int. Comme nous venons de voir pour accéder au nième élément du tableau : - soit nous faisons appel au pointeur pn : *(pn+3) - soit nous utilisons les indices du tableau : tab[n] - soit nous utilisons directement le tableau comme un pointeur : *(tab+3) Donc t[i] est équivalent à *(t+i). De même *(pn+i) équivaut à pn[i] même si pn est de type pointeur il nous est possible d accéder au i ème élément de même type avec l emploi des indices, tout comme pour les tableaux. Tableau à deux dimensions : L expression t[i][j] s interprète comme (t[i])[j], ce qui peut se traduire par : T[j] <-> *(T+j) <-> *( *(t+i) +j) Pour résumer, nous avons : &t[0] <-> t &t[i] <-> t+i t[1] <-> *(t+1) t[i] <-> *(t+i) t[i][0] <-> *t[i] <-> **(t+i) t[i][j] <-> (t[i])[j] <-> ( *(t+i))[j] <-> *( *(t+i) + j) 5
3. Le pointeur NULL et le pointeur générique void * Le pointeur NULL : Le symbole NULL du langage C permet d initialiser un pointeur qui ne pointe sur rien. Cette valeur NULL peut être affectée à tout pointeur quel que soit sont type. Ce symbole est défini dans les librairies stdio.h, stdlib.h. int *pn = NULL ; En utilisant le pointeur NULL, cela nous permet alors de comparer si deux pointeurs sont égaux (opérateur ==) ou non égaux (!=) entre eux. Par contre les comparaisons d inégalité (<,>,>=, >=) ne sont pas autorisés avec les pointeurs sauf si l on manipule des tableaux. Dès que l on déclare une variable de type pointeur, il est préférable de l initialiser à NULL, surtout dans le cas oùu l on ne connait pas sa valeur initiale au début du programme. Au moment d utiliser un pointeur, il est préférable de tester si sa valeur est bien non nulle : if(pn!= NULL) *pn =... Equivalent à : if(pn) *pn =... Cela s avèrera utile pour la gestion des listes chaînées. Le pointeur générique : Nous avons vu jusqu à maintenant qu un pointeur pointe sur un objet typé. Or il est possible de déclarer un pointeur sans type. Comme pour les déclarations de fonction, il nous est possible de déclarer des fonctions sans type. Particulièrement lorsqu elles ne renvoient aucun résultat. Il nous est donc aussi possible de déclarer des pointeurs sans type particulier. Dans ce cas ce sera l adresse contenu dans le pointeur qui aura un sens. Ceci est particulièrement utile lorsque : - Une fonction doit traiter des objets de différents types, alors qu elle a reçu l adresse de l objet en argument. - L on souhaite seulement échanger les valeurs de deux pointeurs. Un pointeur de type générique se déclare comme suit : void * pn; void *pn, *pm, n; /* incorrect, n ne peut être de type void*/ pn++; /* interdit */ pn = pn + 5; /* l'expression p + 5 est interdite */ int i = pm - pn; /* l'expression pm -pn est interdite */ int *pi; if (pn!= pi) /* correct */ if (pn == pi) /* correct */ 6
4. Le cast d un pointeur Exemple : char * pc ; int * pi ; pi= (int *) pc ; ou pc = (char *) pi ; 7