11. Pointeurs

Le mémoire central des ordinateurs est découpé logiquement en octets. Chacun de ces octets possède une adresse unique, un nombre entier qui sert à l’identifier. Chaque octet de mémoire peut stocker une donnée du type caractère (char). Pour d'autres types de données plusieurs octets consécutifs doivent être utilisés. Par exemple, pour une donnée du type double on doit utiliser 8 octets. L'adresse de la zone de mémoire correspondant à un objet du type double est par convention l'adresse du premier octet, dans l'ordre des adresses croissantes, de cette zone. Les pointeurs donnent un moyen alternatif d’accéder au mémoire. Ils sont variables qui peuvent contenir seulement des adresses du mémoire. En fait, un pointeur est simplement un entier, mais pour des raisons de sécurité, on prend soin de distanguer pointeurs et entiers, ainsi que les différents types de pointeurs entre eux. Ainsi, un pointeur de flottant en double précision /adresse d’un objet de type double/ et un pointeur de caractère /adresse d’un objet de type char/ sont de types différents.

• Définition d’un pointeur

Définition d’une variable pointeur:

type * variable_pointeur;

Dans cette définition on doit écrire * /étoile/ avant chaque variable pointeur, par exemple:

double * ptr1;
int * p1, *p2;

Dans l’exemple ci-dessus p1 et p2 peuvent prendre seulement des adresses des valeurs du type int. On dit encore que p1 et p2 pointent sur des objets du type int. ptr1 point sur des objets du type double.

• Opérateurs utilisés avec des pointeurs

Les opérateurs unaires & et * peuvent être appliqués à des pointeurs.

L’opérateur & :

&opérande

L’opérande est obligatoirement une variable. L’opérateur & retourne l’adresse de la variable.

L’opérateur * :

* opérande

L’opérande peut être uniquement un pointeur ou une expression dans laquelle il y a des pointeurs.

Exemple: #include < iostream.h > int main() { int * p; int x = 10; p = &x; cout<<" x = " << *p<< endl; // affiche 10 *p = *p +1; // augmente x par 1 cout<<" x = " << x << endl; // affiche 11 return 0; } Attention:
- Si V est une variable, *&V et V ont le même sens;
- L’opérateur * peut signifier aussi la multiplication. Le sens concret est déterminé par le contexte;
- Comme toutes les variables chaque pointeur doit être initialisé avant d’être utilisé. Le pointeur NULL est un pointeur qui ne pointe rien.Il peut être utilisé pour l'initialisation d'un pointeur.
Exemples: float x, y, *px, *px1; px = &x; // px prend l'adresse de x y = *px; // y = x px1 = &*px; // px1 = px y = *&x; // y = x Les opérateurs +, -, ++, - - peuvent aussi être utilisés par des pointeurs. Les opérateurs ++ et – augmentent ou diminuent la valeur du pointeur par le nombre d’octets occupé du type pointé par le pointeur.

Exemple: #include < iostream.h > int main() { double *p, r; r = 3.456; p = &r; // p prend l'adresse de r cout<<*p<< endl; // affiche 3.456 cout<< p<< endl; // affiche l'adresse de r cout<<&p<< endl; // affiche l'adresse du pointeur p cout<<++p<< endl; // affiche l'adresse de r augmenté par 8 cout<<--p<< endl; // affiche l'adresse de r cout<<*p; // affiche 3.456 return 0; } Dans l’exemple au-dessous l’opérateur &ptr affiche l’adresse du pointeur ptr. Chaque variable pointeur est stockée dans le mémoire en 4 octets.

Exemple:
int *ptr, x=5;
ptr =&x ;
cout<<&ptr ;

Les opérateurs + et – sont utilisés par le moyen pareil:: float *ptr, *p, x=3; ptr = &x; ptr = ptr + 1; // l'adresse dans ptr augmente par 4 p = ptr – 1; cout<< ptr << endl; p = ptr - 1; // l'adresse dans p diminue par 4 cout<< p;