std::weak_ptr<T>:: lock

Crea un nuevo std::shared_ptr que comparte la propiedad del objeto gestionado. Si no hay ningún objeto gestionado, es decir, * this está vacío, entonces el shared_ptr devuelto también está vacío.

Efectivamente retorna expired ( ) ? shared_ptr < T > ( ) : shared_ptr < T > ( * this ) , ejecutado atómicamente.

Valor de retorno

Un shared_ptr que comparte la propiedad del objeto poseído si std::weak_ptr::expired devuelve false . De lo contrario, devuelve un shared_ptr construido por defecto de tipo T .

Notas

Tanto esta función como el constructor de std::shared_ptr pueden utilizarse para adquirir la propiedad temporal del objeto administrado referenciado por un std::weak_ptr . La diferencia es que el constructor de std::shared_ptr lanza una excepción cuando su argumento std::weak_ptr está vacío, mientras que std::weak_ptr<T>::lock() construye un std::shared_ptr<T> vacío.

Ejemplo

#include <iostream>
#include <memory>
void observe(std::weak_ptr<int> weak)
{
    if (auto p = weak.lock())
        std::cout << "\tobserve() is able to lock weak_ptr<>, value=" << *p << '\n';
    else
        std::cout << "\tobserve() is unable to lock weak_ptr<>\n";
}
int main()
{
    std::weak_ptr<int> weak;
    std::cout << "weak_ptr<> is not yet initialized\n";
    observe(weak);
    {
        auto shared = std::make_shared<int>(42);
        weak = shared;
        std::cout << "weak_ptr<> is initialized with shared_ptr\n";
        observe(weak);
    }
    std::cout << "shared_ptr<> has been destructed due to scope exit\n";
    observe(weak);
}

weak_ptr<> is not yet initialized
        observe() is unable to lock weak_ptr<>
weak_ptr<> is initialized with shared_ptr
        observe() is able to lock weak_ptr<>, value=42
shared_ptr<> has been destructed due to scope exit
        observe() is unable to lock weak_ptr<>

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también