Quel pointeur est utilisé avec shared_ptr ?

weak_ptr.

#include <memory>
#include <iostream>

int main() {
    auto shared = std::make_shared<int>(10); // Créer un shared_ptr
    std::weak_ptr<int> weak = shared;      // Créer un weak_ptr à partir du shared_ptr

    if (auto locked = weak.lock()) {       // Essayer d'obtenir un shared_ptr à partir du weak_ptr
        std::cout << "Valeur : " << *locked << std::endl;
    } else {
        std::cout << "Objet supprimé." << std::endl;
    }

    shared.reset(); // L'objet pointé par shared_ptr est supprimé

    if (auto locked = weak.lock()) {       // Deuxième tentative, l'objet est déjà supprimé
        std::cout << "Valeur : " << *locked << std::endl;
    } else {
        std::cout << "Objet supprimé." << std::endl;
    }

    return 0;
}

weak_ptr utilisé avec shared_ptr sert à résoudre les problèmes de références cycliques et à prévenir le "memory hang" lorsque deux ou plusieurs objets gérés par shared_ptr se réfèrent mutuellement, et que les compteurs de références n'atteignent jamais zéro.

Voici les principales propriétés de weak_ptr :

• Ne augmente pas le compteur de références : weak_ptr maintient une référence "faible" à l'objet géré par shared_ptr, sans augmenter son compteur de références fortes.
• Vérification de la vie de l'objet : Avec la méthode lock(), on peut tenter d'obtenir un shared_ptr à partir du weak_ptr. Si l'objet est encore vivant, lock() renverra un shared_ptr valide ; sinon, un shared_ptr vide.
• Pas d'accès direct : weak_ptr ne fournit pas d'accès direct au contenu de l'objet via les opérateurs * ou ->. L'accès est possible uniquement après un appel réussi à lock().

L'utilisation de weak_ptr est une méthode standard pour rompre les cycles de références dans des structures de données utilisant shared_ptr, comme les graphes ou les listes doublement chaînées.