KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::enable_shared_from_this: bestaand eigendom van een object delen

std::enable_shared_from_this laat een object een shared_ptr verkrijgen met hetzelfde controleblok als de huidige eigenaar.

Versie: C++23

Syntax

template<class T>
class enable_shared_from_this {
public:
    std::shared_ptr<T> shared_from_this();
    std::shared_ptr<const T> shared_from_this() const;
    std::weak_ptr<T> weak_from_this() noexcept;
    std::weak_ptr<const T> weak_from_this() const noexcept;
};

Een klasse T die openbaar en ondubbelzinnig afleidt van std::enable_shared_from_this<T> uit <memory> krijgt shared_from_this() en weak_from_this(). Wanneer de eerste geschikte std::shared_ptr eigenaar wordt, initialiseert die een verborgen zwakke koppeling; later maakt shared_from_this() een eigenaar van hetzelfde object en controleblok.

shared_from_this() aanroepen voordat een compatibele shared_ptr het object beheert, construeert uit een lege weak_ptr en werpt std::bad_weak_ptr. weak_from_this() is noexcept en kan een lege zwakke pointer teruggeven, zodat eigendom zonder voorafgaande levensduurverlenging kan worden getest.

Maak geen std::shared_ptr<T>(this): dat schept een onafhankelijk controleblok en risico op dubbel verwijderen. Een object op de stack, private of dubbelzinnige overerving of een tweede onafhankelijke eigenaar legt de vereiste koppeling niet. Gebruik bij voorkeur std::make_shared<T> en deel daarna shared_from_this().

Voorbeelden

#include <iostream>
#include <memory>

struct Node : std::enable_shared_from_this<Node> {
    explicit Node(int value) : value(value) {}
    int value;
};

int main() {
    auto first = std::make_shared<Node>(7);
    auto second = first->shared_from_this();
    std::cout << (first.get() == second.get()) << ' '
              << first.use_count() << ' ' << second->value << '\n';
}

Resultaat

1 2 7

std::enable_shared_from_this → 1 2 7

Bronnen