Introduction aux pointeurs en C++ - Déclaration et interêts

Les pointeurs en C++

Création de pointeurs

Les pointeurs sont déclarés comme n'importe quelle autre variable, sauf qu'un astérisque (*) est placé entre le type de données et le nom du pointeur.

Syntaxe de déclaration

int* a {};        // pointeur sur un entier (initialisé à 0)
int *a {};        // même chose (l'astérisque peut être collé au type ou au nom)
int *a {}, *b {}, *c {};  // plusieurs pointeurs dans la même instruction

L'initialisateur {} initialise les variables pointeur avec l'équivalent pointeur de zéro, qui est une adresse spéciale qui ne pointe vers rien. Cette valeur s'écrit nullptr.

Exemple 1 : Initialisation à nullptr

int* a {nullptr};  // pointeur qui ne pointe vers rien

Taille des pointeurs

Quel que soit le type ou la taille des données auxquelles un pointeur fait référence, la taille de la variable pointeur elle-même sera toujours la même pour une plate-forme donnée.

Exemple 2 : Taille des pointeurs

#include <iostream>

using namespace std;

int main(void){
    cout << sizeof(double)  << " > "  << sizeof(char16_t)  << std::endl;
    cout << sizeof(double*) << " == " << sizeof(char16_t*) << std::endl;
    
    return 0;
}

8 > 2
8 == 8

La taille des pointeurs dépend uniquement de la quantité de mémoire adressable de votre plate-forme cible (généralement 8 octets sur un système 64 bits).

L'opérateur d'adressage (&)

Exemple 3 : Stocker l'adresse d'une variable

long nombre {12345L};
long* pnombre {&nombre};  // pnombre contient l'adresse de nombre

&nombre produit l'adresse de nombre, donc pnombre a cette adresse comme valeur initiale.

Exemple 4 : Réaffectation d'un pointeur

long note {1454L}; 
long* pnombre {&note};    // pnombre pointe maintenant vers note

L'opérateur & peut être appliqué à une variable de n'importe quel type, mais vous ne pouvez stocker l'adresse que dans un pointeur du type approprié.

Exemples 5 et 6 : Utilisation de auto avec les pointeurs

auto pnombre {&nombre};   // type déduit : long*
auto* pnombre {&nombre};  // plus explicite : auto* indique un pointeur

L'opérateur d'indirection (déréférencement) (*)

Exemple 7 : Déréférencement d'un pointeur

#include <iostream>

using namespace std;

int main(void){
    int nombre {10};
    int* pnombre = &nombre;
    
    cout << "Adresse de nombre : " << pnombre << endl;
    cout << "Valeur de nombre : " << *pnombre << endl;
    
    return 0;
}

Adresse de nombre : 0x16f99f398
Valeur de nombre : 10

Cet exemple démontre que l'utilisation d'un pointeur déréférencé est identique à l'utilisation de la variable vers laquelle il pointe. Vous pouvez utiliser *pnombre dans une expression comme vous utiliseriez nombre.

Pointeur vers un pointeur

Syntaxe

int** r = &pnombre;  // pointeur vers pnombre

Exemple 8 : Utilisation d'un pointeur de pointeur

#include <iostream>

using namespace std;

int main(void){
    int nombre {10};
    int* pnombre = &nombre;
    int** r = &pnombre;  // r pointe vers pnombre

    cout << "Adresse de pnombre : " << r << endl;
    cout << "Adresse de nombre : " << *r << endl;
    cout << "Valeur de nombre : " << **r << endl;
    
    return 0;
}

Adresse de pnombre : 0x16d6c7390
Adresse de nombre : 0x16d6c7398
Valeur de nombre : 10

Explication :

• r contient l'adresse de pnombre.
• *r donne l'adresse de nombre (contenu de pnombre).
• **r donne la valeur de nombre (10).

Pourquoi utiliser des pointeurs ?

Une question qui vient généralement à l'esprit : "Pourquoi utiliser des pointeurs ?" Voici les principales raisons :

Allocation dynamique avec new et delete

L'opérateur new

int* pnombre = new int;  // allocation dynamique d'un entier

new prend comme argument un type de données et renvoie un pointeur vers la mémoire allouée, si la mémoire disponible est suffisante.

L'opérateur delete

delete pnombre;  // libère la mémoire allouée

Si vous oubliez de supprimer la mémoire allouée avec new, le programme aura des fuites de mémoire (memory leaks).

Pointeurs suspendus (dangling pointers)

Le déréférencement d'un pointeur suspendu peut créer un désastre. La bonne pratique est de réinitialiser le pointeur après suppression :

delete pnombre;    // libérer la mémoire
pnombre = nullptr; // réinitialiser le pointeur

Désormais, pnombre ne pointe plus vers rien. L'utilisation d'un pointeur contenant nullptr pour accéder à des données mettra fin au programme, ce qui est préférable à un comportement imprévisible.

int a = 42;
int* ptr = &a;
int** pptr = &ptr;