std::weak_ptr::lock
std::shared_ptr<T> lock() const noexcept; |
(desde C++11) | |
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.
Parámetros
(Ninguno)
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.
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.
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);
}
Salida:
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<>
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.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 2316 | C++11 | No se requería que lock() fuera atómica, pero se requería que fuera noexcept, lo que llevaba a una contradicción.
|
Se especificó que fuera atómica. |
Véase también
| Comprueba si el objeto referenciado ya ha sido eliminado. (función miembro pública) |