Clase weak_ptr
Contiene un puntero débilmente vinculado.
Sintaxis
template<class T> class weak_ptr;
Parámetros
T
Tipo controlado por el puntero débil.
Comentarios
La plantilla de clase describe un objeto que apunta a un recurso administrado por uno o varios objetos shared_ptr. Los objetos weak_ptr que apuntan a un recurso no afectan al recuento de referencias del recurso. Cuando se destruye el último objeto shared_ptr que administra dicho recurso, este se libera, aunque haya objetos weak_ptr apuntando a él. Este comportamiento es esencial para evitar ciclos en estructuras de datos.
Un objeto weak_ptr apunta a un recurso si se construyó a partir de un objeto shared_ptr que posee ese recurso, si se construyó a partir de un objeto weak_ptr que apunta a ese recurso o si se le asignó ese recurso con operator=. Un objeto weak_ptr no proporciona acceso directo al recurso al que apunta. El código que debe usar el recurso lo hace a través de un objeto shared_ptr que posee ese recurso, creado mediante una llamada a la función miembro lock. Un objeto weak_ptr expira cuando se libera el recurso al que apunta porque todos los objetos shared_ptr que poseen el recurso se han destruido. Llamar a lock en un objeto weak_ptr que ha expirado crea un objeto shared_ptr vacío.
Un objeto vacío weak_ptr no apunta a ningún recurso y no tiene ningún bloque de control. Su función miembro lock devuelve un objeto shared_ptr vacío.
Un ciclo se produce cuando dos o más recursos controlados por objetos shared_ptr contienen objetos shared_ptr que se hacen referencia mutuamente. Por ejemplo, una lista vinculada circular con tres elementos tiene un nodo principal N0; ese nodo contiene un objeto shared_ptr que posee el siguiente nodo, N1; ese nodo contiene un objeto shared_ptr que posee el siguiente nodo, N2; ese nodo, a su vez, contiene un objeto shared_ptr que posee el nodo principal, N0, que cierra el ciclo. En esta situación, los recuentos de referencia nunca serán cero y los nodos del ciclo no se liberarán. Para eliminar el ciclo, el último nodo N2 debe contener un objeto weak_ptr que apunte a N0 en lugar de un objeto shared_ptr. Puesto que el objeto weak_ptr no posee N0, no afecta al recuento de referencias de N0, y cuando se destruya la última referencia al nodo principal del programa, también se destruirán los nodos de la lista.
Miembros
| Nombre | Descripción |
|---|---|
| Constructores | |
weak_ptr |
Construye un objeto weak_ptr. |
| Destructores | |
~weak_ptr |
Destruye un objeto weak_ptr. |
| Typedefs | |
element_type |
El tipo del elemento. |
| Funciones miembro | |
expired |
Comprueba si la propiedad ha caducado. |
lock |
Obtiene la propiedad exclusiva de un recurso. |
owner_before |
Devuelve true si este weak_ptr está ordenado antes (o es menor que) que el puntero proporcionado. |
reset |
Libera el recurso poseído. |
swap |
Intercambia dos objetos weak_ptr. |
use_count |
Número máximo de objetos shared_ptr |
| Operadores | |
operator= |
Reemplaza el recurso poseído. |
element_type
El tipo del elemento.
typedef T element_type; // through C++17
using element_type = remove_extent_t<T>; // C++20
Comentarios
El tipo es un sinónimo del parámetro de plantilla T.
Ejemplo
// std__memory__weak_ptr_element_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp0(new int(5));
std::weak_ptr<int> wp0(sp0);
std::weak_ptr<int>::element_type val = *wp0.lock();
std::cout << "*wp0.lock() == " << val << std::endl;
return (0);
}
*wp0.lock() == 5
expired
Comprueba si la propiedad ha expirado, es decir, se ha eliminado el objeto al que se hace referencia.
bool expired() const noexcept;
Comentarios
La función miembro devuelve true si *this expiró, de lo contrario, false.
Ejemplo
// std__memory__weak_ptr_expired.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::weak_ptr<int> wp;
{
std::shared_ptr<int> sp(new int(10));
wp = sp;
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
}
// check expired after sp is destroyed
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "(bool)wp.lock() == " << std::boolalpha
<< (bool)wp.lock() << std::endl;
return (0);
}
wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false
lock
Obtiene un objeto shared_ptr que comparte la propiedad de un recurso.
shared_ptr<T> lock() const noexcept;
Comentarios
La función miembro devuelve un objeto vacío shared_ptr si *this ha expirado; de lo contrario, devuelve un shared_ptr<T> objeto propietario del recurso al que *this apunta. Devuelve un valor equivalente a la ejecución atómica de expired() ? shared_ptr<T>() : shared_ptr<T>(*this).
Ejemplo
// std__memory__weak_ptr_lock.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::weak_ptr<int> wp;
{
std::shared_ptr<int> sp(new int(10));
wp = sp;
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
}
// check expired after sp is destroyed
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
std::cout << "(bool)wp.lock() == " << std::boolalpha
<< (bool)wp.lock() << std::endl;
return (0);
}
wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false
operator=
Reemplaza el recurso poseído.
weak_ptr& operator=(const weak_ptr& ptr) noexcept;
template <class Other>
weak_ptr& operator=(const weak_ptr<Other>& ptr) noexcept;
template <class Other>
weak_ptr& operator=(const shared_ptr<Other>& ptr) noexcept;
Parámetros
Other
Tipo controlado por el argumento compartido o puntero débil.
ptr
Puntero débil o puntero compartido que se va a copiar.
Comentarios
Todos los operadores liberan el recurso al que apunta actualmente *this y asignan la propiedad del recurso denominado ptr a *this- Si un operador produce errores, deja a *this sin cambios. Cada operador tiene un efecto equivalente a weak_ptr(ptr).swap(*this).
Ejemplo
// std__memory__weak_ptr_operator_as.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp0(new int(5));
std::weak_ptr<int> wp0(sp0);
std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;
std::shared_ptr<int> sp1(new int(10));
wp0 = sp1;
std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;
std::weak_ptr<int> wp1;
wp1 = wp0;
std::cout << "*wp1.lock() == " << *wp1.lock() << std::endl;
return (0);
}
*wp0.lock() == 5
*wp0.lock() == 10
*wp1.lock() == 10
owner_before
Devuelve true si este weak_ptr está ordenado antes (o es menor que) que el puntero proporcionado.
template <class Other>
bool owner_before(const shared_ptr<Other>& ptr) const noexcept;
template <class Other>
bool owner_before(const weak_ptr<Other>& ptr) const noexcept;
Parámetros
ptr
Una referencia lvalue a un shared_ptr o un weak_ptr.
Comentarios
La función miembro de plantilla devuelve true si *this es ordenado antes que ptr.
reset
Reemplaza el recurso propio.
void reset() noexcept;
Comentarios
La función miembro libera el recurso al que apunta *this y convierte *this en un objeto weak_ptr vacío.
Ejemplo
// std__memory__weak_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp(new int(5));
std::weak_ptr<int> wp(sp);
std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
wp.reset();
std::cout << "wp.expired() == " << std::boolalpha
<< wp.expired() << std::endl;
return (0);
}
*wp.lock() == 5
wp.expired() == false
wp.expired() == true
swap
Intercambia dos objetos weak_ptr.
void swap(weak_ptr& wp) noexcept;
También incluye la especialización:
template<class T>
void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
Parámetros
wp
El puntero débil que se va a intercambiar.
Comentarios
Después de un swap, el recurso al que apuntaba originalmente *this es apuntado por wp, y el recurso al que apuntaba originalmente wp es apuntado por *this. La función no modifica los recuentos de referencia para los dos recursos y no inicia ninguna excepción. El efecto de la especialización de plantilla es el equivalente de a.swap(b).
Ejemplo
// std__memory__weak_ptr_swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp1(new int(5));
std::shared_ptr<int> sp2(new int(10));
std::cout << "*sp1 == " << *sp1 << std::endl;
sp1.swap(sp2);
std::cout << "*sp1 == " << *sp1 << std::endl;
swap(sp1, sp2);
std::cout << "*sp1 == " << *sp1 << std::endl;
std::cout << std::endl;
std::weak_ptr<int> wp1(sp1);
std::weak_ptr<int> wp2(sp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
wp1.swap(wp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
swap(wp1, wp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
return (0);
}
*sp1 == 5
*sp1 == 10
*sp1 == 5
*wp1 == 5
*wp1 == 10
*wp1 == 5
use_count
Cuenta el número de objetos shared_ptr que poseen el recurso compartido.
long use_count() const noexcept;
Comentarios
La función miembro devuelve el número de objetos shared_ptr que poseen el recurso al que apuntaba *this.
Ejemplo
// std__memory__weak_ptr_use_count.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp1(new int(5));
std::weak_ptr<int> wp(sp1);
std::cout << "wp.use_count() == "
<< wp.use_count() << std::endl;
std::shared_ptr<int> sp2(sp1);
std::cout << "wp.use_count() == "
<< wp.use_count() << std::endl;
return (0);
}
wp.use_count() == 1
wp.use_count() == 2
weak_ptr
Construye un objeto weak_ptr.
constexpr weak_ptr() noexcept;
weak_ptr(const weak_ptr& wp) noexcept;
weak_ptr(weak_ptr&& wp) noexcept;
template <class Other>
weak_ptr(const weak_ptr<Other>& wp) noexcept;
template <class Other>
weak_ptr(weak_ptr<Other>&& sp) noexcept;
template <class Other>
weak_ptr(const shared_ptr<Other>& sp) noexcept;
Parámetros
Other
El tipo controlado por el puntero compartido o débil de argumento. Estos constructores no participan en la resolución de sobrecarga a menos que Other* sea compatible con element_type*.
wp
El puntero débil que se va a copiar.
sp
El puntero compartido que se va a copiar.
Comentarios
El constructor predeterminado crea un objeto weak_ptr vacío. Los constructores que toman un argumento crean un objeto vacío weak_ptr si el puntero del argumento está vacío. De lo contrario, construyen un objeto weak_ptr que apunta al recurso denominado por el argumento. No se cambia el recuento de referencias del objeto compartido.
Ejemplo
// std__memory__weak_ptr_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::weak_ptr<int> wp0;
std::cout << "wp0.expired() == " << std::boolalpha
<< wp0.expired() << std::endl;
std::shared_ptr<int> sp1(new int(5));
std::weak_ptr<int> wp1(sp1);
std::cout << "*wp1.lock() == "
<< *wp1.lock() << std::endl;
std::weak_ptr<int> wp2(wp1);
std::cout << "*wp2.lock() == "
<< *wp2.lock() << std::endl;
return (0);
}
wp0.expired() == true
*wp1.lock() == 5
*wp2.lock() == 5
~weak_ptr
Destruye un objeto weak_ptr.
~weak_ptr();
Comentarios
El destructor destruye weak_ptr, pero no tiene ningún efecto en el recuento de referencias del objeto en el que apunta su puntero almacenado.
Consulte también
Referencia de archivos de encabezado
<memory>
Clase shared_ptr
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de