Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

weak_ptr (Clase)

Incluye un puntero débilmente 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;
    };

Ty

El tipo controla el puntero débil.

La clase de plantilla describe un objeto que apunta a un recurso que es administrado por uno o más objetos de shared_ptr (Clase) . 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::lockmiembro. 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 N0head; ese nodo contiene un objeto que posee el siguiente nodo, N1de shared_ptr ; ese nodo contiene un objeto que posee el siguiente nodo, N2de shared_ptr ; ese nodo, a su vez, contiene un objeto que posee el nodo principal, N0de 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.

Bb982126.collapse_all(es-es,VS.120).gifConstructores

weak_ptr::weak_ptr

Construye un objeto weak_ptr.

Bb982126.collapse_all(es-es,VS.120).gifMé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 weak_ptr.

weak_ptr::use_count

Cuenta el número de objetos designados de shared_ptr .

Bb982126.collapse_all(es-es,VS.120).gifOperadores

weak_ptr::operator=

Recurso propio Replaces.

Encabezado: <memory>

Espacio de nombres: std

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft