std::weak_ptr

Bien que std::shared_ptr soit extrêmement utile, l'utilisation exclusive de la propriété partagée peut entraîner un problème connu sous le nom de référence cyclique (ou cyclic dependency).

Si deux objets ou plus contiennent chacun un shared_ptr qui pointe vers l'autre, un cycle fermé se crée. Dans cette situation, le compteur de références d'aucun des deux objets ne descendra jamais à zéro, empêchant la désallocation et provoquant une fuite de mémoire (memory leak).

Qu'est-ce que std::weak_ptr ?

Pour casser les cycles de propriété, la bibliothèque standard propose std::weak_ptr. Il s'agit d'un pointeur intelligent qui observe un objet géré par un shared_ptr, mais sans incrémenter le reference count.

Il ne possède pas directement la ressource, il n'empêche donc pas sa destruction.

#include <memory>

std::shared_ptr<int> shared = std::make_shared<int>(42);
std::weak_ptr<int> weak = shared; // Non incrementa il contatore!

Vérifier et accéder à la ressource

Comme un weak_ptr ne possède pas la ressource, celle-ci peut être désallouée à tout moment (lorsque tous les shared_ptr associés sortent de la portée).

Pour utiliser la ressource observée, nous devons d'abord :

1. Vérifier si elle est toujours valide à l'aide de expired().
2. Convertir temporairement le weak_ptr en un shared_ptr via la méthode lock(). Si la ressource est toujours active, lock() renvoie un shared_ptr valide, sinon elle renvoie un pointeur nul (nullptr).

if (!weak.expired()) {
    // lock() crea uno shared_ptr temporaneo per garantire l'accesso sicuro
    if (std::shared_ptr<int> sharedAccess = weak.lock()) {
        std::cout << *sharedAccess << std::endl;
    }
} else {
    std::cout << "Risorsa deallocata!" << std::endl;
}

À vous de jouer