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 vous comprenez la mémoire stack et heap, explorons les outils qui vous 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 en utilisant &.

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és
Peuvent être réassignés	Ne peuvent pas être liés à nouveau
Utilisez `*` pour accéder à la valeur	Accédez à la valeur directement
Peuvent ne pointer vers rien	Toujours valides

Les deux sont essentiels pour passer des objets à des fonctions de manière efficace sans copie, 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 plus de flexibilité lorsque vous avez besoin de réassigner ou de vérifier la présence de null.

Défi

Facile

Construisons un système simple de manipulation de valeurs qui démontre comment les pointeurs et les références fonctionnent différemment lors de la modification de données.

Vous allez créer deux fichiers pour organiser votre code :

ValueOps.h : Définissez 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 : Lisez deux entiers à partir de l'entrée, puis démontrez l'utilisation des pointeurs et des références :
- Affichez les valeurs originales : "Original: <first> <second>"
- Utilisez doubleByPointer sur la première valeur, puis affichez : "After double: <first>"
- Utilisez tripleByReference sur la seconde valeur, puis affichez : "After triple: <second>"
- Utilisez swapValues pour échanger les deux valeurs, puis affichez : "After swap: <first> <second>"

Lors de l'appel de fonctions avec des pointeurs, n'oubliez pas d'utiliser l'opérateur d'adresse (&) pour passer l'adresse de la variable. Les références fonctionnent plus naturellement — il suffit de passer la variable directement.

Incluez votre fichier d'en-tête dans main.cpp en utilisant #include "ValueOps.h".

Aide-mémoire

Un pointeur stocke l'adresse mémoire d'une autre variable. Déclarez-le avec * et obtenez une adresse en utilisant & :

int value = 42;
int* ptr = &value;    // ptr holds the address of value

std::cout << ptr;     // Prints the memory address
std::cout << *ptr;    // Dereference: prints 42

Une référence est un alias pour une variable existante. Déclarez-la avec & :

int value = 42;
int& ref = value;     // ref is an alias for value

ref = 100;            // Changes value to 100
std::cout << value;   // Prints 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 liées à nouveau
Utilisent `*` pour accéder à la valeur	Accèdent à la valeur directement
Peuvent ne pointer vers rien	Toujours valides

Lors de l'appel de fonctions avec des pointeurs, utilisez l'opérateur d'adresse (&) pour passer l'adresse de la variable. Les références fonctionnent directement — il suffit de passer la variable.

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 doublement
    
    // TODO: Utiliser tripleByReference sur la deuxième valeur (passer la variable directement)
    
    // TODO: Afficher après le triplement
    
    // TODO: Utiliser swapValues pour échanger les deux valeurs (passer les adresses en utilisant &)
    
    // TODO: Afficher après l'échange
    
    return 0;
}