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

CKTIS / C++

std::shared_ptr — propriedade partilhada

std::shared_ptr<T> de <memory> permite partilhar a propriedade de um objeto. As cópias mantêm-no vivo e a libertação do último proprietário desencadeia a limpeza. std::weak_ptr observa o objeto sem prolongar o seu tempo de vida.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

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

std::shared_ptr<T> de <memory> representa propriedade partilhada. Ao copiá-lo, partilha-se a propriedade do objeto em vez de o copiar. reset() liberta a parte de um proprietário; o último proprietário desencadeia a eliminação do objeto gerido ou a chamada ao deleter adequado. get() apenas expõe o apontador armazenado — não transfere a propriedade.

Crie um objeto com std::make_shared<T>(args...), que encaminha os argumentos para o seu construtor. Não crie um std::shared_ptr independente a partir de p.get(): isso cria um grupo de proprietários separado e pode causar uma dupla eliminação. Antes de o desreferenciar, certifique-se de que o apontador armazenado aponta para um objeto vivo.

Ciclos de referências fortes podem manter objetos vivos indefinidamente. Quebre um ciclo com std::weak_ptr, que não prolonga o tempo de vida do objeto. lock() devolve um std::shared_ptr que partilha a propriedade se ainda houver pelo menos um proprietário no grupo observado. Se o grupo tiver expirado, lock() devolve um std::shared_ptr vazio, mesmo que o objeto continue vivo, por exemplo, porque o deleter não faz nada.

A gestão segura da propriedade não sincroniza os dados do objeto. Instâncias diferentes que partilham a propriedade podem ser usadas em simultâneo; modificar a mesma instância requer sincronização, por exemplo, com std::atomic<std::shared_ptr<T>>. O acesso ao próprio objeto necessita de proteção separada se puder ocorrer uma corrida de dados. use_count() não é um mecanismo de sincronização.

O exemplo mostra que q mantém o objeto vivo após p.reset() e que o observador expira quando o bloco termina. Esta entrada tem como referência C++23; o projeto de trabalho fornecido é atualizado e pode incluir funcionalidades posteriores. Uma opção do compilador no repositório não certifica o ambiente de execução de produção.

Exemplos

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

Resultado

42
false
true

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes