std::zwakke_ptr

Hoewel std::shared_ptr uiterst nuttig is, kan het uitsluitend vertrouwen op gedeeld eigendom leiden tot een probleem dat bekend staat als een circulaire referentie (of cyclische afhankelijkheid).

Als twee of meer objecten elk een shared_ptr bevatten die naar de ander wijst, ontstaat er een gesloten lus. In deze situatie zal de referentietelling van geen van beide objecten ooit nul bereiken, waardoor de toewijzing wordt voorkomen en een geheugenlek ontstaat.

Wat is std::weak_ptr

Om eigendomscycli te doorbreken, biedt de standaardbibliotheek std::weak_ptr. Dit is een slimme aanwijzer die een object observeert dat wordt beheerd door een shared_ptr, maar zonder het aantal referenties te verhogen.

Het is niet rechtstreeks eigenaar van de hulpbron en voorkomt dus niet de vernietiging ervan.

#include <memory>

std::shared_ptr<int> shared = std::make_shared<int>(42);
std::weak_ptr<int> weak = shared; // Does not increment reference count!

De bron verifiëren en openen

Omdat een weak_ptr niet de eigenaar van de bron is, kan de toewijzing van de bron op elk moment ongedaan worden gemaakt (wanneer alle gekoppelde shared_ptr instanties buiten het bereik vallen).

Om de waargenomen bron te gebruiken, moeten we:

1. Controleer of het nog geldig is met expired().
2. Converteer de weak_ptr tijdelijk naar een shared_ptr met behulp van de lock() methode. Als de bron nog steeds actief is, retourneert lock() een geldige shared_ptr, anders retourneert het een nulaanwijzer (nullptr).

if (!weak.expired()) {
    // lock() creates a temporary shared_ptr to ensure safe access
    if (std::shared_ptr<int> sharedAccess = weak.lock()) {
        std::cout << *sharedAccess << std::endl;
    }
} else {
    std::cout << "Resource deallocated!" << std::endl;
}

Probeer het zelf