weak_ptr Class

Ajusta un puntero débil vinculado.

template<class Ty> 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
  El tipo controla el puntero débil.

Comentarios

La clase de plantilla describe un objeto que apunta a un recurso que es administrado por uno o más objetos de shared_ptr Class.Los objetos de weak_ptr que señalan a un recurso no afectan al recuento de referencias de recursos.Así, cuando se destruye el objeto pasado de shared_ptr que administra a ese recurso liberarán el recurso, incluso si hay objetos de weak_ptr que señalan a ese recurso.Esto es esencial para evitar ciclos de estructuras de datos.

Puntos de un objeto de weak_ptr un recurso si se construyó de un objeto de shared_ptr que posee ese recurso, si se creó de un objeto de weak_ptr que apunta a ese recurso, o si se asignaron ese recurso con weak_ptr::operator=.Un objeto de weak_ptr no proporciona acceso directo al recurso al que señala.El código que es necesario utilizar el recurso lo hace a través de un objeto de shared_ptr que posee ese recurso, creado llamando a la función weak_ptr::lock de miembro.Un objeto de weak_ptr ha expirado cuando han liberado el recurso que señala porque todos los objetos de shared_ptr propietarios del recurso se han destruido.La llamada lock en un objeto de weak_ptr expirada crea un objeto vacío shared_ptr.

Un objeto vacío de weak_ptr no indica a los recursos y no tiene ningún bloque de control.La función lock miembro devuelve un objeto vacío shared_ptr.

Un ciclo se produce cuando dos o más recursos controlados por los objetos de shared_ptr contiene mutuamente hacer referencia a los objetos de shared_ptr.Por ejemplo, una lista vinculada circular con tres elementos tiene un nodo N0 head; ese nodo contiene un objeto que posee el siguiente nodo, N1 de shared_ptr; ese nodo contiene un objeto que posee el siguiente nodo, N2 de shared_ptr; ese nodo, a su vez, contiene un objeto que posee el nodo principal, N0 de shared_ptr, cerrando el ciclo.En esta situación, ninguno de los recuentos de referencia se volverán nunca cero, y los nodos del ciclo no serán liberados.Para eliminar el ciclo, el nodo pasado N2 debe contener un objeto de weak_ptr que señala a N0 en lugar de un objeto de shared_ptr.Puesto que el objeto de weak_ptr no posee N0 no afecta al recuento de referencias de N0 y, cuando la referencia pasada de programa al nodo principal se destruye los nodos de la lista también se destruidos.

Members

Constructores

weak_ptr::weak_ptr

Construye un weak_ptr.

Métodos

weak_ptr::element_type	Tipo del elemento.
weak_ptr::expired	Comprueba si ha expirado la propiedad.
weak_ptr::lock	Obtiene su propiedad exclusivo de un recurso.
weak_ptr::owner_before	Devuelve true si este weak_ptr se ordena antes (o menor que) de puntero proporcionado.
weak_ptr::reset	Recurso propio de versiones.
weak_ptr::swap	Intercambia dos objetos de weak_ptr.
weak_ptr::use_count	Cuenta el número de objetos designados de shared_ptr.

Operadores

weak_ptr::operator=

Recurso propio Replaces.

Requisitos

Encabezado: <memory>

Espacio de nombres: std

Vea también

Referencia

shared_ptr Class

Otros recursos

miembros de <memoria>