« Programmation C++/Les pointeurs » : différence entre les versions

Aller à la navigation Aller à la recherche
=== Exemple 1 ===
 
<source lang="cpp">
char* ptr="Pointeur"; // ptr pointe le premier caractère de la chaîne de caractères
 
cout << ptr << endl; // affiche "Pointeur"
 
ptr = ptr+3;
cout << ptr << endl; // affiche "nteur"
 
cout << ++ptr << endl; // affiche "teur"
cout << --++ptr << endl; // affiche "nteurteur"
cout << ++--ptr << endl; // affiche "teurnteur"
</source>
 
 
Comme l'exemple précédent le montre, il est également possible d'utiliser les opérateurs d'incrémentation et de décrémentation.
=== Exemple 2 ===
 
<source lang="cpp">
int premiers[] = { 2, 3, 5, 7, 11, 13, 17 };
int* ptr = premiers; // pointe le premier élément du tableau
 
cout << hex << ptr << endl; // affiche l'adresse pointée (par exemple 01C23004)
cout << couthex << *ptr << endl; // affiche "2"l'adresse pointée (par exemple 01C23004)
cout << *(ptr+5) << endl; // affiche "132"
cout << *(ptr+5) << endl; // affiche "13"
 
ptr=&premiers[3]; // pointe le 4ème élément (index 3)
cout << hex << ptr << endl; // affiche l'adresse pointée (par exemple 01C23018)
cout << couthex << *ptr << endl; // affiche "7"l'adresse pointée (par exemple 01C23018)
cout << *(ptr-1) << endl; // affiche "57"
cout << *(ptr-1) << endl; // affiche "5"
</source>
 
Dans l'exemple 2, la différence d'adresse est de 20 octets (<code>5 * sizeof(int)</code>).
Cela montre que l'adresse contenue dans le pointeur est toujours incrémentée ou décrémentée d'un multiple de la taille d'un élément (<code>sizeof *ptr</code>).
 
==== Opération utilisant deux pointeurs ====
La seule opération valable (ayant un sens) utilisant deux pointeurs de même type est la soustraction ( <code>-</code> ) donnant le nombre d'éléments entre les deux adresses.
Elle n'a de sens que si les deux pointeurs pointent dans le même tableau d'éléments.
 
Exemple :
<source lang="cpp">
char str[]="Message où rechercher des caractères.";
char *p1 = strchr(str,'a'); // recherche le caractère 'a' dans str
char *p2p1 = strchr(str,'èa'); // recherche le caractère 'èa' dans str
char *p1p2 = strchr(str,'aè'); // recherche le caractère 'aè' dans str
cout << "Nombre de caractères de 'a' à 'è' = " << (p2-p1) << endl;
// affiche : Nombre de caractères de 'a' à 'è' = 28
 
cout << "Nombre de caractères de 'a' à 'è' = " << (p2-p1) << endl;
=== Pointeur constant et pointeur vers valeur constante ===
// affiche : Nombre de caractères de 'a' à 'è' = 28
</source>
 
=== Pointeur constant et pointeur vers valeur constante ===
Il ne faut pas confondre un pointeur constant (qui ne peut pointer ailleurs) avec un pointeur vers une valeur constante (l'adresse contenue dans le pointeur peut être modifiée mais pas la valeur pointée).
 
Dans les 2 cas le mot clé <code>const</code> est utilisé, mais à 2 endroits différents dans le type de la variable.
 
==== Pointeur vers une valeur constante ====
Le mot-clé <code>const</code> placé avant le type du pointeur permet d'empêcher la modification de la valeur pointée.
 
Exemple:
<source lang="cpp">
const char* msg = "essai constant";
 
*msg = 'E'; // <- Interdit, la valeur pointée ne peut être modifiée
 
msg = "Test"; // OK -> le pointeur contient l'adresse de "Test"
</source>
 
==== Pointeur constant ====
Le mot-clé <code>const</code> placé entre le type du pointeur et la variable permet d'empêcher la modification du pointeur lui-même (l'adresse).
 
*msg = 'E'; // OK -> "Essai constant"
 
==== Pointeur constant vers une valeur constante ====
Le mot-clé <code>const</code> apparaissant aux 2 endroits empêche à la fois la modification du pointeur lui-même et celle de la valeur pointée.
 
*msg = 'E'; // <- Interdit, la valeur pointée ne peut être modifiée
 
==== Position du mot clé <code>const</code> ====
Une méthode simple existe pour déterminer si c'est la valeur pointée ou le pointeur lui-même qui est constant. Elle est apparue il y a plus de 10 ans et a été promue par Dan Sacks, sans succès malheureusement. Cette méthode se résume en une seule phrase :
"<code>const</code> s'applique toujours à ce qui le précède".

Menu de navigation