Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::enable_shared_from_this: condividere la proprietà esistente di un oggetto

std::enable_shared_from_this permette a un oggetto di ottenere uno shared_ptr con lo stesso control block del proprietario corrente.

Versione: C++23

Sintassi

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;
};

Una classe T che deriva pubblicamente e senza ambiguità da std::enable_shared_from_this<T> in <memory> ottiene shared_from_this() e weak_from_this(). Quando il primo std::shared_ptr adatto prende possesso, inizializza un collegamento debole nascosto; poi shared_from_this() crea un proprietario dello stesso oggetto e control block.

Chiamare shared_from_this() prima che un shared_ptr compatibile gestisca l’oggetto costruisce da un weak_ptr vuoto e lancia std::bad_weak_ptr. weak_from_this() è noexcept e può restituire un puntatore debole vuoto, consentendo di verificare la proprietà senza prolungare prima la vita.

Non creare std::shared_ptr<T>(this): genera un control block indipendente e rischia una doppia eliminazione. Mettere l’oggetto sullo stack, usare ereditarietà privata o ambigua oppure un secondo proprietario indipendente non stabilisce il legame. Preferisci std::make_shared<T>, poi esponi shared_from_this().

Esempi

#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';
}

Risultato

1 2 7

std::enable_shared_from_this → 1 2 7

Fonti