Pointeurs et références

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 13 sur 104.

Maintenant que tu comprends la mémoire de pile et la mémoire de tas, explorons les outils qui te permettent de travailler directement avec les emplacements mémoire : les pointeurs et les références.

Un pointeur stocke l’adresse mémoire d’une autre variable. Vous le déclarez avec * et obtenez une adresse à l’aide de &.

int value = 42;
int* ptr = &value;    // ptr contient l'adresse de value

std::cout << ptr;     // Affiche l'adresse mémoire
std::cout << *ptr;    // Déréférencement : affiche 42

Une référence est un alias pour une variable existante. Une fois liée, elle fait toujours référence à cette variable. Vous la déclarez avec &.

int value = 42;
int& ref = value;     // ref est un alias pour value

ref = 100;            // Modifie value à 100
std::cout << value;   // Affiche 100

Différences clés :

Pointeurs	Références
Peuvent être nuls	Doivent être initialisées
Peuvent être réassignés	Ne peuvent pas être réaffectées
Utilisez `*` pour accéder à la valeur	Accédez directement à la valeur
Peuvent ne pointer vers rien	Toujours valides

Les deux sont essentiels pour transmettre efficacement des objets aux fonctions sans les copier et pour travailler avec de la mémoire allouée sur le tas. Les références sont plus sûres et plus simples, tandis que les pointeurs offrent davantage de flexibilité lorsque vous devez les réaffecter ou vérifier s’ils sont nuls.

Défi

Facile

Construisons un système simple de manipulation de valeurs qui montre comment les pointeurs et les références fonctionnent différemment lorsqu’ils modifient des données.

Tu vas créer deux fichiers pour organiser ton code :

ValueOps.h : définir trois fonctions qui modifient des valeurs entières de différentes manières :
- doubleByPointer(int* ptr) : prend un pointeur et double la valeur vers laquelle il pointe
- tripleByReference(int& ref) : prend une référence et triple la valeur
- swapValues(int* a, int* b) : prend deux pointeurs et échange les valeurs vers lesquelles ils pointent
main.cpp : lire deux entiers depuis l’entrée, puis démontrer l’utilisation des pointeurs et des références :
- Afficher les valeurs originales : "Original: <first> <second>"
- Utiliser doubleByPointer sur la première valeur, puis afficher : "After double: <first>"
- Utiliser tripleByReference sur la deuxième valeur, puis afficher : "After triple: <second>"
- Utiliser swapValues pour échanger les deux valeurs, puis afficher : "After swap: <first> <second>"

Lorsque tu appelles des fonctions avec des pointeurs, pense à utiliser l’opérateur d’adresse (&) pour transmettre l’adresse de la variable. Les références fonctionnent de manière plus naturelle : il suffit de transmettre directement la variable.

Inclus ton fichier d’en-tête dans main.cpp en utilisant #include "ValueOps.h".

Essayez vous-même

#include <iostream>
#include "ValueOps.h"
using namespace std;

int main() {
    // Lire deux entiers depuis l'entrée
    int first, second;
    cin >> first;
    cin >> second;
    
    // Afficher les valeurs d'origine
    cout << "Original: " << first << " " << second << endl;
    
    // TODO: Utiliser doubleByPointer sur la première valeur (passer l'adresse en utilisant &)
    
    // TODO: Afficher après le double
    
    // TODO: Utiliser tripleByReference sur la deuxième valeur (passer la variable directement)
    
    // TODO: Afficher après le triple
    
    // TODO: Utiliser swapValues pour échanger les deux valeurs (passer les adresses en utilisant &)
    
    // TODO: Afficher après l'échange
    
    return 0;
}