Rappelons qu'une adresse est un entier qui représente la position d'un octet en mémoire. Cet entier permet donc en particulier de repérer la position, ou autrement dit l'adresse, d'une plage mémoire (schéma).
En C++, un pointeur se déclare de la manière suivante:
Type * Nom Du Pointeur ;
où Type représente le type de donnée dont le pointeur contiendra l'adresse.
Exemple:
struct Ville {
string Nom;
int CodePostal;
};
Ville * p;
Dans cet exemple, la variable p est un pointeur sur une donnée de type Ville.
Un pointeur permet de créer une variable sans nom, repérée uniquement par l'adresse qu'il contient.
Cette variable est créé par un mécanisme d'allocation dynamique de mémoire, que nous allons décrire à présent.
Les variables générées dynamiquement sont stockées dans une zone spéciale de la mémoire appelée le tas (heap en anglais).
En C++, l'allocation dynamique de mémoire se fait grace à l'opérateur new.
Si p est un pointeur sur un type T, l'instruction:
p = new T ;
va allouer de la place mémoire dans le tas pour une variable de ce type et affecter à p l'adresse de cette variable.
Avec notre exemple précédent:
p = new Ville;
réserverait de la place pour une structure de type Ville et affecterait l'adresse de cette structure à p. Par exemple, si la plage mémoire réservée pour la structure commence à l'adresse 1961, p contiendra cette adresse (schéma).
Une fois que la variable est créé, il est possible d'y accéder via l'opérateur *. Si p est un pointeur, (* p) représente la variable pointée par p.
Avec notre exemple, pour affecter "Strasbourg" au nom de la ville pointé par p on écrirait:
(* p).Nom = "Strasbourg";
Tout se passe donc comme si ( * p) était une variable de type Ville.
Pour accéder à un champ particulier c d'une structure pointée par un pointeur p, on peut également utiliser le raccourci d'écriture p->c à la place de (*p).c. Par exemple:
p->Nom = "Strasbourg";
a le même effet que l'instruction précédente.