jmc55

Avant de voir les premiers usages des pointeurs, il est indispensable de connaître les règles de leur bon usage. En effet si l’utilisation des variables « classiques » est facile et presque sans piège, l’utilisation des pointeurs comporte des difficultés et des pièges.

Rappelons les notions vues dans les deux premiers articles ( Pointeurs : abstraction subtile ; Pointeur : allocation dynamique ) :

• un pointeur est une variable particulière qui contient l’adresse d’une variable classique ;

• on peut changer la valeur d’un pointeur ce qui le différencie radicalement d’une variable classique ;

• en changeant la valeur du pointeur on change donc la valeur de l’adresse ; on dit que le pointeur « pointe » sur une adresse donnée ;

• on ne peut se contenter de déclarer un pointeur comme pour une variable classique ; il faut aussi lui « réserver une place » c’est à dire demander au compilateur de réserver une adresse pour le pointeur ; on dit que l’on alloue de la mémoire au pointeur ;

• on accède à la valeur contenue à l’adresse indiquée par le pointeur en « dé-référençant » le pointeur ;

On peut résumer tout cela ainsi :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
int * ptr ; // on déclare un pointeur sur un entier nommé ptr
 
ptr = new int ; // on demande au compilateur de nous réserver une zone 
// mémoire pour ce pointeur
// et on précise qu'il s'agit d'une zone mémoire qui contiendra un 
// entier ;
 
*ptr = 6 ; // on affecte 6 dans la case mémoire dont l'adresse est contenue dans le pointeur ptr
 
prt = ptr + 1 ; // on change la valeur du pointeur ptr qui désormais //pointera vers la case mémoire suivante ce qui n'est pas sans risque ;

Avant d’aller plus loin il est nécessaire de bien retenir deux règles de bonne conduite qui vous éviterons bien des déboires.

Première règle.

Il est bon de déclarer NULL un pointeur dès le stade de sa déclaration. On procède ainsi :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

int * ptr = NULL ;

Ceci veut dire que l’on affecte pour le moment la valeur NULL c’est à dire 0 au pointeur. La case mémoire d’adresse 0 n’est jamais utilisée. De cette façon le compilateur sait que si un pointeur contient la valeur 0 il ne peut pas être utilisé par le programme car son contenu est pour le moment dénué de sens. Toute tentative d’utilisation du pointeur se soldera par une erreur de compilation et ceci est une SECURITE. Quand je dis toute tentative d’utilisation il faut comprendre toute tentative de dé-référencement : nous avons vu () que affecter une valeur à la case mémoire « pointée » par le pointeur se dit en bon langage dé-référencer le pointeur.

Pourquoi NULL et pas 0 ?

C’est là aussi une bonne habitude. En lisant le code on repère beaucoup mieux NULL que 0 et ainsi on peut comprendre : « jusqu’à cette ligne le pointeur ptr est invalide ». Invalide veut dire qu’il n’a pas encore reçu une adresse valide (zéro n’est pas une adresse valide) et que donc il faut se garder de toute tentative de dé-référencement.

Deuxième règle.

Toute allocation dynamique doit être suivi d’un test de réussite. Ceci se traduit par les lignes de code suivantes :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
ptr = new int ;
if (ptr!= NULL)
{
*ptr = 8 ; // on peut dé-référencer sans danger le pointeur c'est à dire modifier le contenue de la case //mémoire sur laquelle il pointe ;
}
 
else // il faudra ici prévoir le cas où du fait par exemple de la saturation de mémoire il n'y a plus
// de place et que la réservation d'une nouvelle case mémoire est devenue impossible.

Maintenant que vous avez compris ce qu’est un pointeur et comment le déclarer avec précaution nous allons pouvoir examiner l’intérêt d’une telle démarche de « pointeur ».