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

CKTIS / C++

std::weak_ptr — observar sem prolongar o tempo de vida do objeto

std::weak_ptr<T> observa um objeto gerido por std::shared_ptr sem o manter vivo. O método lock() obtém temporariamente um proprietário partilhado ou um std::shared_ptr vazio se a propriedade já tiver expirado.

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

Sintaxe

#include <memory>
std::weak_ptr<T> observer = owner;
if (auto held = observer.lock()) {
    // Access the object through held.
}

std::weak_ptr<T>, declarado em <memory>, guarda uma referência fraca associada à propriedade gerida por std::shared_ptr. Não aumenta o número de proprietários fortes nem prolonga o tempo de vida do objeto. Crie-o a partir de um std::shared_ptr compatível ou deixe-o vazio.

Não disponibiliza * nem ->. Chame lock() e verifique o std::shared_ptr devolvido. A aquisição da propriedade partilhada é atómica: o método devolve um proprietário partilhado ou um apontador vazio se a propriedade tiver expirado, sem lançar exceções. Mantenha o resultado enquanto acede ao objeto.

expired() significa use_count() == 0; use_count() conta os proprietários fortes, não os observadores. Verificar apenas expired() não garante o tempo de vida: outra thread pode libertar o último proprietário antes de uma chamada posterior a lock(). A atomicidade de lock() não sincroniza o acesso aos dados do objeto.

As referências fracas são úteis para observar e quebrar ciclos de propriedade: uma referência de retorno pode usar std::weak_ptr em vez de outro proprietário forte. reset() esvazia o observador sem destruir o objeto observado. O exemplo usa funcionalidades disponíveis em C++23; o projeto de norma atual fornecido também contém extensões posteriores.

Exemplos

#include <iostream>
#include <memory>

int main() {
    std::weak_ptr<int> observer;
    {
        auto owner = std::make_shared<int>(42);
        observer = owner;
        if (auto held = observer.lock()) {
            std::cout << *held << '\n';
        }
    }
    std::cout << std::boolalpha << observer.expired() << '\n';
    std::cout << static_cast<bool>(observer.lock()) << '\n';
}

Resultado

42
true
false

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