Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::enable_shared_from_this: partilhar a propriedade existente de um objeto

std::enable_shared_from_this permite que um objeto obtenha um shared_ptr com o mesmo bloco de controlo do proprietário atual.

Versão: C++23

Sintaxe

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

Uma classe T que deriva pública e inequivocamente de std::enable_shared_from_this<T> em <memory> recebe shared_from_this() e weak_from_this(). Quando o primeiro std::shared_ptr adequado toma posse, inicializa uma ligação fraca oculta; depois, shared_from_this() cria um proprietário do mesmo objeto e bloco de controlo.

Chamar shared_from_this() antes de um shared_ptr compatível gerir o objeto constrói a partir de um weak_ptr vazio e lança std::bad_weak_ptr. weak_from_this() é noexcept e pode devolver um ponteiro fraco vazio, permitindo testar a propriedade sem prolongar primeiro o tempo de vida.

Não cries std::shared_ptr<T>(this): isso produz um bloco de controlo independente e risco de dupla eliminação. Colocar o objeto na stack, usar herança privada ou ambígua ou criar um segundo proprietário independente não estabelece a ligação. Prefere std::make_shared<T> e só depois expõe shared_from_this().

Exemplos

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

Resultado

1 2 7

std::enable_shared_from_this → 1 2 7

Fontes