Comme beaucoup d'autres langages, le C++ a des pointeurs.
Tu sais déjà que les références et les pointeurs se ressemblent, mais considère-les comme un niveau plus proche du fonctionnement interne de ton ordinateur.
Les pointeurs sont des variables qui contiennent des adresses d'objets.
Ils servent à interagir directement avec les objets, ce qui permet l'allocation dynamique de mémoire et une manipulation efficace des données en C++.
Si les pointeurs sont nouveaux pour toi, ils peuvent sembler un peu mystérieux, mais une fois que tu t'y es habitué, ils sont tout à fait simples.
Ils sont une partie cruciale du C++, alors prends le temps de bien les comprendre.
La version minimale de ce concept est aussi appelée dumb pointer ou pointeur brut.
Avec le C++ moderne, il existe aussi des pointeurs intelligents, mais le type de base n'est pas intelligent du tout et tu dois gérer tout le travail manuellement.
Avant d'entrer dans les détails, il vaut la peine de comprendre à quoi servent les pointeurs.
Les pointeurs permettent de partager l'adresse d'un objet avec d'autres parties de notre programme, ce qui est utile pour deux raisons majeures :
- Comme les références, les pointeurs évitent les copies et aident à réduire l'empreinte en ressources de ton programme.
- Contrairement aux références, les pointeurs peuvent être réaffectés à d'autres objets.
- Les pointeurs peuvent aussi pointer vers une valeur nulle, pour indiquer qu'ils ne pointent actuellement vers aucun objet.
Syntaxe générale
En C++, déclarer un pointeur consiste à préciser le type de données vers lequel il pointe, puis un astérisque (*) et le nom du pointeur.
Quand on déclare un pointeur, il n'est pas initialisé automatiquement.
Sans affectation explicite, un pointeur contient généralement une valeur indéterminée, souvent appelée « adresse poubelle ».
Même si certains compilateurs initialisent les pointeurs à nullptr, ce comportement n'est pas garanti pour tous les compilateurs ; il est donc essentiel de ne pas s'y fier.
La bonne pratique est d'initialiser explicitement les pointeurs bruts et de vérifier qu'ils ne sont pas nuls avant de les utiliser, afin d'éviter d'éventuels problèmes.
int* ptr{nullptr}; // Declares a pointer and makes sure it is not invalid
Pour affecter l'adresse d'une variable à un pointeur, on utilise l'opérateur d'adresse (&).
On déréférence un pointeur à l'aide de l'opérateur d'indirection (*).
std::string opponent{"Solomon Lane"};
// 'ethan' points to the address of the string opponent
std::string* ethan{&opponent};
// Instead of ethan's, the opponent's name address is given to the passPort
std::string passportName{*ethan};
Attention : le déréférencement doit se faire explicitement, alors qu'une référence fonctionne simplement comme un alias.
Arithmétique des pointeurs
L'arithmétique des pointeurs permet d'effectuer des opérations arithmétiques sur des pointeurs, ce qui est particulièrement utile lorsqu'on travaille avec des tableaux.
Ajouter un entier à un pointeur le fait pointer vers un autre élément.
// Stargate Coordinate Code
int gateCode[] = {462, 753, 218, 611, 977};
// 'ptr' points to the first element of 'gateCode'
int* ptr{&gateCode[0]};
// Accesses the third Stargate address through pointer arithmetic
int dialedAddress{*(ptr + 2)};
// Chevron encoded! Dialing Stargate address:
openStarGate(dialedAddress);
L'arithmétique des pointeurs en C++ peut facilement mener à un comportement indéfini si elle n'est pas manipulée avec précaution.
Un comportement indéfini peut se manifester par des résultats de programme inattendus, des plantages, voire des failles de sécurité.
Un exemple tristement célèbre des conséquences d'un comportement indéfini est la explosion de la fusée Ariane 5 en 1996, où une exception logicielle provoquée par la conversion d'un nombre à virgule flottante de 64 bits en un entier signé de 16 bits a entraîné une défaillance catastrophique.
Accéder aux variables membres
En C++, l'opérateur -> sert à accéder aux membres d'un objet à travers un pointeur vers cet objet.
C'est une notation raccourcie qui simplifie l'accès aux membres des objets pointés par un pointeur.
Par exemple, si ptr est un pointeur vers un objet qui a une variable membre x, au lieu d'écrire (*ptr).x, tu peux utiliser directement ptr->x.
Cet opérateur améliore la lisibilité du code et réduit la verbosité lorsqu'on travaille avec des pointeurs vers des objets.
Voici un petit exemple, avec une struct Superhero qui possède une variable membre superpower.
La fonction principale crée un pointeur dianaPrince vers un objet Superhero (qui représente Wonder Woman).
L'opérateur -> sert à accéder à la variable membre superpower, ce qui met en valeur le célèbre « Lasso of Truth » de Wonder Woman.
struct Superhero {
std::string superpower;
};
Superhero wonder_woman{};
Superhero* dianaPrince = &wonder_woman;
dianaPrince->superpower = "Lasso of Truth";
// Using the -> operator to access member variable superpower:
std::cout << "Wonder Woman, possesses the mighty " << dianaPrince->superpower;
Pointeurs et références
Les pointeurs et les références permettent tous deux un accès indirect aux objets, mais ils diffèrent par leurs capacités et par les questions de sûreté qu'ils posent.
Les pointeurs offrent la souplesse de changer l'objet ciblé et peuvent recevoir la valeur nulle.
Cependant, cette souplesse introduit des risques, comme déréférencer un pointeur nul ou créer des pointeurs suspendus.
Les références, en revanche, ne peuvent pas être nulles et sont liées à des objets valides dès leur création, ce qui évite ces risques.
Comme elles sont plus sûres, il faut préférer les références aux pointeurs, sauf si les fonctionnalités supplémentaires offertes par les pointeurs sont nécessaires.
Exercice d'apprentissage
