shared_ptr Class

Ajusta un puntero inteligente referencia- contado alrededor de un objeto dinámicamente asignado.

template<class Ty>
   class shared_ptr {
public:
    typedef Ty element_type;

    shared_ptr();
    shared_ptr(nullptr_t); 
    shared_ptr(const shared_ptr& sp);
    shared_ptr(shared_ptr&& sp);
    template<class Other>
        explicit shared_ptr(Other * ptr);
    template<class Other, class D>
        shared_ptr(Other * ptr, D dtor);
    template<class D>
        shared_ptr(nullptr_t, D dtor);
    template<class Other, class D, class A>
        shared_ptr(Other *ptr, D dtor, A alloc);
    template<class D, class A>
        shared_ptr(nullptr_t, D dtor, A alloc);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp);
    template<class Other>
        shared_ptr(const shared_ptr<Other>&& sp);
    template<class Other>
        explicit shared_ptr(const weak_ptr<Other>& wp);
    template<class Other>
        shared_ptr(auto_ptr<Other>& ap);
    template<class Other, class D>
        shared_ptr(unique_ptr<Other, D>&& up);
    template<class Other>
        shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
    ~shared_ptr();
    shared_ptr& operator=(const shared_ptr& sp);
    template<class Other> 
        shared_ptr& operator=(const shared_ptr<Other>& sp);
    shared_ptr& operator=(shared_ptr&& sp);
    template<class Other> 
        shared_ptr& operator=(shared_ptr<Other>&& sp);
    template<class Other> 
        shared_ptr& operator=(auto_ptr< Other >&& ap);
    template <class Other, class D> 
        shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
    template <class Other, class D>
        shared_ptr& operator=(unique_ptr<Other, D>&& up);
    void swap(shared_ptr& sp);
    void reset();
    template<class Other>
        void reset(Other *ptr);
    template<class Other, class D>
        void reset(Other *ptr, D dtor);
    template<class Other, class D, class A>
        void reset(Other *ptr, D dtor, A alloc);
    Ty *get() const;
    Ty& operator*() const;
    Ty *operator->() const;
    long use_count() const;
    bool unique() const;
    operator bool() const;

    template<class Other>
        bool owner_before(shared_ptr<Other> const& ptr) const;
    template<class Other>
        bool owner_before(weak_ptr<Other> const& ptr) const;
    template<class D, class Ty> 
        D* get_deleter(shared_ptr<Ty> const& ptr);
};

Parámetros

• Ty
  El tipo controla el puntero compartido.

• Other
  El tipo controla el puntero de argumento.

• ptr
  El puntero a copiar.

• D
  El tipo de deleter.

• A
  El tipo del asignador.

• dtor
  El deleter.

• alloc
  El asignador.

• sp
  El puntero inteligente a copiar o que se va a mover.

• wp
  El puntero débil a copiar o que se va a mover.

• ap
  El puntero auto a copiar o que se va a mover.

• up
  El puntero único que se va a mover.

Comentarios

La clase de plantilla describe un objeto que utiliza el recuento de referencias para administrar los recursos.Un objeto de shared_ptr mantiene eficazmente un puntero al recurso que posee o contiene un puntero nulo.Un recurso puede ser propiedad de más de un objeto de shared_ptr; cuando se destruye el objeto pasado de shared_ptr que posee un recurso determinado, se libera el recurso.

shared_ptr detiene el propietario de un recurso cuando se reasigna o reinicie.

El argumento Ty de la plantilla podría ser funciones incompletas de un miembro de tipo si no se especifica lo contrario con certeza.

Cuando un objeto de shared_ptr<Ty> se construye de un puntero de recursos de G* cualquiera de shared_ptr<G>, el tipo de puntero G* debe poder convertirse a Ty*.Si no es así, el código no se compilará.Por ejemplo:

class F {};
class G : public F {};

shared_ptr<G> sp0(new G);   // okay, template parameter G and argument G*
shared_ptr<G> sp1(sp0);     // okay, template parameter G and argument shared_ptr<G>
shared_ptr<F> sp2(new G);   // okay, G* convertible to F*
shared_ptr<F> sp3(sp0);     // okay, template parameter F and argument shared_ptr<G>
shared_ptr<F> sp4(sp2);     // okay, template parameter F and argument shared_ptr<F>
shared_ptr<int> sp4(new G); // error, G* not convertible to int*
shared_ptr<int> sp5(sp2);   // error, template parameter int and argument shared_ptr<F>

Un objeto de shared_ptr posee un recurso:

• si se creó con un puntero a ese recurso,

• si se creó de un objeto de shared_ptr que posee ese recurso,

• si se creó de un objeto de weak_ptr Class que apunta a ese recurso, o

• si la propiedad de ese recurso le se asignó, con shared_ptr::operator= o llamando a la función shared_ptr::reset de miembro.

Los objetos de shared_ptr que poseer una acción de recursos al bloque de control.El bloque de control contiene:

• el número de objetos de shared_ptr que poseen el recurso,

• el número de objetos de weak_ptr que señalan al recurso,

• el deleter para ese recurso si existe,

• el asignador personalizado para el bloque de control si tiene.

Un objeto de shared_ptr que se inicializa mediante un puntero NULL tiene un bloque de control y no está vacío.Después de versiones de un objeto de shared_ptr un recurso, posee ya no ese recurso.Después de versiones de un objeto de weak_ptr un recurso, elija no más ese recurso.

Cuando el número de objetos de shared_ptr propietarios de un recurso se convierte en cero, el recurso es liberado, y o pasando su dirección un deleter, dependiendo de cómo la propiedad del recurso se creó originalmente.Cuando el número de objetos de shared_ptr propietarios de un recurso es cero, y el número de objetos de weak_ptr que apuntan a ese recurso es cero, el bloque de control se libera, utilizando el asignador personalizado para el bloque de control si tiene.

Un objeto vacío de shared_ptr no posee a los recursos y no tiene ningún bloque de control.

Un deleter es un objeto de función que tiene una función operator() miembro.El tipo debe ser copia construible, y el constructor y el destructor de copia no deben producir excepciones.Acepta un parámetro, el objeto que se va a eliminar.

Algunas funciones toman una lista de argumentos que define propiedades de shared_ptr<Ty> u objeto resultante de weak_ptr<Ty>.Puede especificar esta lista de argumentos de varias maneras:

argumentos -- el objeto resultante es un objeto vacío de shared_ptr o un objeto vacío de weak_ptr.

ptr -- un puntero de Other* escrito el recurso que se va a controlar.Ty debe ser un tipo completo.Si se produce un error en la función (porque el bloque de control no puede ser asignado) se evalúan la expresión delete ptr.

ptr, dtor -- un puntero de Other* escrito en el recurso que se administrarán y un deleter para ese recurso.Si la función (porque el bloque de control no puede ser asignado), llame dtor(ptr), que deben estar bien definida.

ptr, dtor, alloc -- un puntero de Other* escrito en el recurso que se administrarán, un deleter para ese recurso, y un asignador para administrar cualquier almacén que debe estar asignado y liberar.Si se produce un error en la función (porque el bloque de control no puede ser asignado) se denominan dtor(ptr), que deben estar bien definida.

sp -- un objeto de shared_ptr<Other> que posee el recurso que se va a controlar.

wp -- un objeto de weak_ptr<Other> que señala al recurso que se va a controlar.

ap -- un objeto de auto_ptr<Other> que contiene un puntero al recurso que se va a controlar.Si la función tiene éxito llama ap.release(); si no permite ap sin cambios.

En todos los casos, el tipo de puntero Other* debe poder convertirse a Ty*.

Seguridad para subprocesos

Varios subprocesos pueden diferentes objetos de shared_ptr de lectura y escritura al mismo tiempo, incluso cuando los objetos son copias que comparten su propiedad.

Members

Constructores

shared_ptr::shared_ptr	Construye un shared_ptr.
shared_ptr::~shared_ptr	Destruye shared_ptr.

Métodos

shared_ptr::element_type	El tipo de un elemento.
shared_ptr::get	Obtiene la dirección de recursos propio.
shared_ptr::owner_before	Devuelve true si este shared_ptr se ordena antes (o menor que) de puntero proporcionado.
shared_ptr::reset	Recurso propio Replace.
shared_ptr::swap	Intercambia dos objetos de shared_ptr.
shared_ptr::unique	Comprueba si el recurso propio es único.
shared_ptr::use_count	Cuenta los números de propietarios de recurso.

Operadores

shared_ptr::operator boolean-type	Comprueba si existe un recurso propio.
shared_ptr::operator*	Obtiene el valor indicado.
shared_ptr::operator=	Reemplaza el recurso propio.
shared_ptr::operator->	Obtiene un puntero al valor indicado.

Requisitos

Encabezado: <memory>

Espacio de nombres: std

Vea también

Referencia

weak_ptr Class

Seguridad para subprocesos de la biblioteca estándar de C++

Otros recursos

miembros de <memoria>