weak_ptr (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Contiene un puntero débilmente vinculado.

class weak_ptr {  
   public:  
   typedef Ty element_type;  
   weak_ptr();
   weak_ptr(const weak_ptr&);
   template <class Other>  
   weak_ptr(const weak_ptr<Other>&);
   template <class Other>  
   weak_ptr(const shared_ptr<Other>&);
   weak_ptr& operator=(const weak_ptr&);
   template <class Other>  
   weak_ptr& operator=(const weak_ptr<Other>&);
   template <class Other>  
   weak_ptr& operator=(shared_ptr<Other>&);
   void swap(weak_ptr&);
   void reset();
   long use_count() const;
   bool expired() const;
   shared_ptr<Ty>  
   lock() const;
   };  

Parámetros

Ty
Tipo controlado por el puntero débil.

La clase de plantilla describe un objeto que señala a un recurso administrado por uno o varios shared_ptr (clase) objetos. Los objetos weak_ptr que apuntan a un recurso no afectan al recuento de referencias del recurso. Por lo tanto, cuando se destruye el último objeto shared_ptr que administra dicho recurso, este se libera, aunque haya objetos weak_ptr apuntando a él. Esto es esencial para evitar ciclos en estructuras de datos.

A weak_ptr objeto señala a un recurso si se construyó desde un shared_ptr objeto que posee ese recurso, si se construyó a partir un weak_ptr objeto que apunta a ese recurso, o si se ha asignado ese recurso con operador =. Un objeto weak_ptr no proporciona acceso directo al recurso al que apunta. Código que se debe usar el recurso se hace a través un shared_ptr objeto que posee ese recurso, creado mediante una llamada a la función miembro bloqueo. 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 weak_ptr vacío 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, ninguno de los recuentos de referencia será cero en ningún momento y no se liberarán los nodos del ciclo. 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.

Constructores

weak_ptr::weak_ptrConstruye un objeto weak_ptr.

Métodos

weak_ptr::ELEMENT_TYPETipo del elemento.
weak_ptr::ExpiredComprueba si la propiedad ha caducado.
weak_ptr::lockObtiene la propiedad exclusiva de un recurso.
weak_ptr::owner_beforeDevuelve true si este weak_ptr está ordenado antes (o es menor que) que el puntero proporcionado.
weak_ptr::ResetLibera el recurso poseído.
weak_ptr::swapIntercambia dos objetos weak_ptr.
weak_ptr::use_countCuenta el número de objetos shared_ptr designados.

Operadores

weak_ptr::operator =Reemplaza el recurso poseído.

Encabezado:<>>

Espacio de nombres: std

Tipo del elemento.

typedef Ty element_type;  

Comentarios

El tipo es un sinónimo del parámetro de plantilla Ty.

Ejemplo

// std_tr1__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  

Comprueba si la propiedad ha caducado.

bool expired() const;

Comentarios

La función miembro devuelve true si *this ha expirado, de lo contrario, false.

Ejemplo

// std_tr1__memory__weak_ptr_expired.cpp   
// compile with: /EHsc   
#include <memory>   
#include <iostream>   
  
struct deleter   
    {   
    void operator()(int *p)   
        {   
        delete p;   
        }   
    };   
  
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  

Obtiene la propiedad exclusiva de un recurso.

shared_ptr<Ty> lock() const;

Comentarios

La función miembro devuelve un objeto shared_ptr vacío si *this ha expirado; de lo contrario devuelve un shared_ptr (clase) <Ty> objeto que posee el recurso que *this señala.

Ejemplo

// std_tr1__memory__weak_ptr_lock.cpp   
// compile with: /EHsc   
#include <memory>   
#include <iostream>   
  
struct deleter   
    {   
    void operator()(int *p)   
        {   
        delete p;   
        }   
    };   
  
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  

Reemplaza el recurso poseído.

weak_ptr& operator=(const weak_ptr& wp);

template <class Other>  
weak_ptr& operator=(const weak_ptr<Other>& wp);

template <class Other>  
weak_ptr& operator=(const shared_ptr<Other>& sp);

Parámetros

Other
Tipo controlado por el puntero de argumento compartidos o débil.

wp
Puntero débil para copiar.

sp
El puntero compartido para copiar.

Comentarios

Todos los operadores liberan el recurso actualmente señalado *this y asignar la propiedad del recurso denominado por la secuencia de operandos a *this. Si un operador presentan errores dejan *this sin cambios.

Ejemplo

// std_tr1__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  

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);

template <class Other>  
bool owner_before(const weak_ptr<Other>& ptr);

Parámetros

ptr
Un lvalue referencia como un shared_ptr o weak_ptr.

Comentarios

La función de miembro de la plantilla devuelve true si *this es ordered before``ptr.

Libera el recurso poseído.

void reset();

Comentarios

La función miembro libera el recurso que señala *this y convierte *this a un objeto weak_ptr vacío.

Ejemplo

// std_tr1__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  

Intercambia dos objetos weak_ptr.

void swap(weak_ptr& wp);

Parámetros

wp
Puntero débil intercambiar con.

Comentarios

La función miembro deja el recurso al que apuntaba originalmente *this posteriormente señala wpy el recurso al que apuntaba originalmente wp posteriormente señalada por *this. La función no modifica los recuentos de referencia para los dos recursos y no se produce ninguna excepción.

Ejemplo

// std_tr1__memory__weak_ptr_swap.cpp   
// compile with: /EHsc   
#include <memory>   
#include <iostream>   
  
struct deleter   
    {   
    void operator()(int *p)   
        {   
        delete p;   
        }   
    };   
  
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  

Cuenta el número de objetos shared_ptr designados.

long use_count() const;

Comentarios

La función miembro devuelve el número de shared_ptr objetos que poseen el recurso señalado por *this.

Ejemplo

// std_tr1__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  

Construye un objeto weak_ptr.

weak_ptr();

weak_ptr(const weak_ptr& wp);

template <class Other>  
weak_ptr(const weak_ptr<Other>& wp);

template <class Other>  
weak_ptr(const shared_ptr<Other>& sp);

Parámetros

Other
Tipo controlado por el puntero de argumento compartidos o débil.

wp
Puntero débil para copiar.

sp
El puntero compartido para copiar.

Comentarios

Los constructores construcción un objeto que apunta al recurso denominado por la secuencia de operandos.

Ejemplo

// std_tr1__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  

shared_ptr (clase)

Mostrar: