std::weak_ptr::lock

Crea un nuevo std::shared_ptr que comparte la posesión 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 devuelve expired() ? shared_ptr<T>() : shared_ptr<T>(*this), ejecutado atómicamente.

[editar] Parámetros

(Ninguno)

[editar] Valor de retorno

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

[editar] Notas

Tanto esta función como el constructor de std::shared_ptr se pueden usar para adquirir la posesión temporal del objeto gestionado al que hace referencia 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.

[editar] Ejemplo

#include <iostream>
#include <memory>
 
void observe(std::weak_ptr<int> weak) 
{
    if (auto observe = weak.lock()) {
        std::cout << "\tobserve() es capaz de bloquear a weak_ptr<>, valor=" << *observe << "\n";
    } else {
        std::cout << "\tobserve() no es capaz de bloquear a weak_ptr<>\n";
    }
}
 
int main()
{
    std::weak_ptr<int> weak;
    std::cout << "weak_ptr<> todavía no se inicializa\n";
    observe(weak);
 
    {
        auto shared = std::make_shared<int>(42);
        weak = shared;
        std::cout << "weak_ptr<> inicializado con shared_ptr.\n";
        observe(weak);
    }
 
    std::cout << "shared_ptr<> se ha destruido debido a que salió de ámbito.\n";
    observe(weak);
}

weak_ptr<> todavía no se inicializa
        observe() no es capaz de bloquear a weak_ptr<>
weak_ptr<> inicializado con shared_ptr.
        observe() es capaz de bloquear a weak_ptr<>, valor=42
shared_ptr<> se ha destruido debido a que salió de ámbito.
        observe() no es capaz de bloquear a weak_ptr<>

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Véase también