KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::shared_ptr — gedeeld eigenaarschap

Met std::shared_ptr<T> uit <memory> kunnen meerdere instanties het eigenaarschap van een object delen. Kopieën houden het object in leven; zodra de laatste eigenaar zijn aandeel vrijgeeft, wordt het opgeruimd. std::weak_ptr observeert het object zonder de levensduur te verlengen.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

#include <memory>
std::shared_ptr<T> p = std::make_shared<T>(args...);
std::shared_ptr<T> q = p;
p.reset();

std::shared_ptr<T> uit <memory> staat voor gedeeld eigenaarschap. Kopiëren deelt het eigenaarschap van het object in plaats van het object te kopiëren. reset() geeft het aandeel van één eigenaar vrij; de laatste eigenaar zorgt voor verwijdering van het beheerde object of roept de juiste deleter aan. get() geeft alleen de opgeslagen pointer beschikbaar — het draagt geen eigenaarschap over.

Maak een object met std::make_shared<T>(args...), dat de argumenten doorgeeft aan de constructor. Maak geen onafhankelijke std::shared_ptr van p.get(): daardoor ontstaat een aparte eigenaarsgroep, die dubbele verwijdering kan veroorzaken. Controleer voordat je de pointer derefereert of deze naar een bestaand object wijst.

Cycli van sterke verwijzingen kunnen objecten onbeperkt in leven houden. Doorbreek een cyclus met std::weak_ptr, dat de levensduur van het object niet verlengt. lock() geeft een std::shared_ptr terug die het eigenaarschap deelt als er in de gevolgde eigenaarsgroep nog minstens één eigenaar is. Is de groep verlopen, dan geeft lock() een lege std::shared_ptr terug, zelfs als het object nog in leven is, bijvoorbeeld doordat de deleter niets doet.

Veilig beheer van eigenaarschap synchroniseert de gegevens van het object niet. Verschillende instanties die het eigenaarschap delen, kunnen gelijktijdig worden gebruikt; dezelfde instantie wijzigen vereist synchronisatie, bijvoorbeeld met std::atomic<std::shared_ptr<T>>. Toegang tot het object zelf vereist aparte bescherming als er een data race kan optreden. use_count() is geen synchronisatiemechanisme.

Het voorbeeld laat zien dat q het object in leven houdt nadat p.reset() is aangeroepen en dat de observer verloopt wanneer het blok eindigt. Dit artikel richt zich op C++23; het meegeleverde werkdocument wordt bijgewerkt en kan latere functies bevatten. Een compileroptie in de repository bevestigt niet de productieomgeving.

Voorbeelden

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_shared<int>(42);
    std::weak_ptr<int> observer = p;
    {
        std::shared_ptr<int> q = p;
        p.reset();
        std::cout << *q << '\n';
        std::cout << std::boolalpha << observer.expired() << '\n';
    }
    std::cout << observer.expired() << '\n';
}

Resultaat

42
false
true

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen