Pointeurs intelligents en C++

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

Les pointeurs intelligents sont des classes enveloppes qui gèrent automatiquement la mémoire du tas pour vous. Ils éliminent le besoin d’appels manuels à delete en libérant la mémoire lorsque le pointeur sort de sa portée.

Incluez l'en-tête <memory> pour utiliser des pointeurs intelligents.

unique_ptr - propriété exclusive. Un seul pointeur peut posséder la ressource à la fois.

#include <memory>

std::unique_ptr<Player> player = std::make_unique<Player>("Hero");
player->attack();  // S'utilise comme un pointeur classique

// Impossible de copier, mais on peut transférer la propriété
std::unique_ptr<Player> player2 = std::move(player);
// player est maintenant nullptr

shared_ptr - propriété partagée. Plusieurs pointeurs peuvent posséder la même ressource. La mémoire est libérée lorsque le dernier propriétaire est détruit.

std::shared_ptr<Player> p1 = std::make_shared<Player>("Hero");
std::shared_ptr<Player> p2 = p1;  // Les deux possèdent la ressource

std::cout << p1.use_count();  // Affiche 2

weak_ptr - observateur non propriétaire d’un shared_ptr. Utile pour rompre les références circulaires.

std::shared_ptr<Player> shared = std::make_shared<Player>("Hero");
std::weak_ptr<Player> weak = shared;

if (auto locked = weak.lock()) {  // Convertir en shared_ptr
    locked->attack();
}

Utilisez unique_ptr par défaut pour une propriété unique. Utilisez shared_ptr lorsque plusieurs objets doivent partager une ressource. Utilisez weak_ptr pour observer sans prolonger la durée de vie.

Préférez make_unique et make_shared à l'utilisation directe de new.

Défi

Facile

Construisons un système de partage de documents qui démontre les différents modèles de propriété des pointeurs intelligents. Tu verras comment unique_ptr impose une propriété exclusive, comment shared_ptr permet plusieurs propriétaires et comment weak_ptr peut observer sans affecter la durée de vie.

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

Document.h : définir une classe Document qui représente un document partageable. Elle doit avoir :
- Un attribut privé title (chaîne de caractères)
- Un constructeur qui prend un titre et affiche "Document created: <title>"
- Un destructeur qui affiche "Document deleted: <title>"
- Une méthode getTitle() qui renvoie le titre
main.cpp : démontrer les trois types de pointeurs intelligents en lisant un titre de document saisi, puis :
- Créer un unique_ptr vers un Document avec le titre saisi
- Afficher "Unique owner: <title>"
- Transférer la propriété à un autre unique_ptr à l’aide de std::move
- Afficher "Ownership transferred"
- Créer un shared_ptr vers un nouveau Document dont le titre est "SharedDoc"
- Créer un deuxième shared_ptr pointant vers le même document
- Afficher "Shared owners: <count>" à l’aide de use_count()
- Créer un weak_ptr à partir de l’un des pointeurs partagés
- Utiliser lock() pour accéder au document via le pointeur faible et afficher "Weak access: <title>"

N’oublie pas d’inclure <memory> pour les pointeurs intelligents. Utilise std::make_unique et std::make_shared pour créer tes pointeurs intelligents. Les messages du destructeur t’aideront à voir quand chaque document est automatiquement nettoyé à la fin du programme.

Inclue ton fichier d’en-tête dans main.cpp à l’aide de #include "Document.h".

Essayez vous-même

#include <iostream>
#include <memory>
#include <string>
#include "Document.h"

using namespace std;

int main() {
    string inputTitle;
    cin >> inputTitle;

    // TODO: Créer un unique_ptr vers un Document avec inputTitle
    // en utilisant std::make_unique

    // TODO: Afficher "Unique owner: <title>"

    // TODO: Transférer la propriété à un autre unique_ptr en utilisant std::move

    // TODO: Afficher "Ownership transferred"

    // TODO: Créer un shared_ptr vers un nouveau Document avec le titre "SharedDoc"
    // en utilisant std::make_shared

    // TODO: Créer un second shared_ptr pointant vers le même document

    // TODO: Afficher "Shared owners: <count>" en utilisant use_count()

    // TODO: Créer un weak_ptr à partir de l'un des shared pointers

    // TODO: Utiliser lock() pour accéder au document via le weak_ptr
    // et afficher "Weak access: <title>"

    return 0;
}