Programmation C++/Les pointeurs

Programmation C++

• Avant-propos
• Introduction
• Compilation
• Un premier programme
• Les commentaires
• Le préprocesseur
• Les types de base et les déclarations
  • Exercices
• Les opérations de base
• Les entrées-sorties
• Les pointeurs
  • Exercices
• Les références
• Les tableaux
  • Exercices
  • Exercices sur les tableaux statiques
  • Exercice : Tris des tableaux à une dimension
  • Solution : Tris des tableaux à une dimension
• Les structures de contrôle
  • Exercices
  • Exercices if...else et switch
• Les fonctions
  • Exercices
• Les structures
  • Exercices
• Les classes
  • Exercices
  • Exercices de développement
• Les espaces de noms
• Les exceptions
• Les templates
  • Exercices
• Conventions d'appel
• Les fichiers
• La librairie standard
• Expressions rationnelles
• Interfaces graphiques
• Bibliographie et liens

Annexes

• Dessiner des formes : les bibliothèques graphiques

Anciennes pages

• Opérateurs
• Héritage
• Polymorphisme

Les pointeurs

Un pointeur désigne une variable contenant une adresse mémoire. Il est utilisé lorsque l'on veut manipuler les données stockées à cette adresse. C'est donc un moyen indirect de construire et de manipuler des données très souvent complexes.

Déclaration

type * identificateur;
La variable identificateur est un pointeur vers une variable de type type.

L'opérateur &

Il permet d'obtenir un pointeur vers une variable.
&identificateur permet d'obtenir un pointeur vers la variable identificateur. Il renvoit en réalité une adresse mémoire, l'adresse où est stocké physiquement la variable identificateur. C'est donc une variable pointeur.

L'opérateur *

* variable<br\> C'est l'opérateur de déréférencement. Il permet d'obtenir et donc de manipuler les données pointées par la variable variable *pointeur permet d'obtenir la valeur de la variable pointée par pointeur.

Exemple de programme

 #include <iostream>
 using namespace std;
 
 int main()
 {
     int a, b, c;
     int *x, *y;
 
     a = 98;
     b = 108;
 
     x = &a;
     c = *x + 5;
 
     y = &b;
     *y = a + 10;
 
     cout << "La variable b vaut : " << b << endl;
     cout << "La variable c vaut : " << c << endl;
 
     return 0;
 }

Exécution :
La variable b vaut 108
La variable c vaut 103

Explications :

• Dans ce programme, on déclare 3 variables a, b et c. On déclare ensuite 2 pointeurs vers des entiers x et y.
• a est initialisé à 98 et b à 78.
• x=&a; permet de mettre dans x l'adresse de a. x est désormais un pointeur vers a.
• *x est la valeur de la variable pointée par x, c'est-à-dire la valeur de a, et vaut donc 98.

c=*x+5; permet donc de tranférer 98+5 donc 103 dans la variable c.

• y=&b permet de mettre dans y l'adressee la variable b. y est désormais un pointeur vers b.
  

a+10 vaut 98+10 donc 108.

• *y=a+10; permet de tranférer dans la variable pointée par y la valeur de a+10, c'est-à-dire 108. On transfère donc 108 dans b.
• on affiche ensuite les valeurs de b et c c'est à dire respectivement 108 et 103.

Opérations arithmétiques sur les pointeurs

Hormis l'opérateur de déréférencement, les pointeurs peuvent être utilisés avec l'opérateur d'addition ( + ). L'addition d'un pointeur avec une valeur entière permet d'avancer ou reculer le pointeur du nombre d'éléments indiqué.

Exemple 1

 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 "nteur"

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

 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 << *ptr << endl;     // affiche "2"
 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 << *ptr << endl;     // affiche "7"
 cout << *(ptr-1) << endl; // affiche "5"

Dans l'exemple 2, la différence d'adresse est de 20 octets (5 * sizeof(int)). 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 (sizeof *ptr).