Condividi tramite


shared_ptr Class

Avvolge un puntatore intelligente con conteggio intorno a un oggetto dinamico allocato.

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

Parametri

  • Ty
    Il tipo esaminato il puntatore condiviso.

  • Other
    Il tipo esaminato il puntatore dell'argomento.

  • ptr
    Il puntatore da copiare.

  • D
    Il tipo di deleter.

  • A
    Il tipo di allocatore.

  • dtor
    Il deleter.

  • alloc
    L'allocatore.

  • sp
    Il puntatore intelligente da copiare o spostare.

  • wp
    Il puntatore debole da copiare o spostare.

  • ap
    Il puntatore automatico da copiare o spostare.

  • up
    Il puntatore univoco da spostare.

Note

La classe modello descrive un oggetto che utilizza il conteggio dei riferimenti per gestire le risorse.Un oggetto di shared_ptr efficacemente contiene un puntatore alla risorsa a cui appartiene o utilizza un puntatore null.Una risorsa può essere posseduta da più oggetti di shared_ptr ; quando l'ultimo oggetto di shared_ptr proprietario di una risorsa particolare viene eliminato, la risorsa viene liberata.

shared_ptr smette di contenere una risorsa quando viene rilocato o reimpostazione.

Un argomento di template Ty potrebbe essere un tipo incompleto salvo quando indicato per alcune funzioni membro.

Quando un oggetto di shared_ptr<Ty> viene costruito da un puntatore di risorse di tipo G* o da shared_ptr<G>, il tipo di puntatore G* deve essere convertibile in Ty*.Se non è, il codice non verrà compilato.Ad esempio:

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 oggetto di shared_ptr possiede una risorsa:

  • se viene costruito con un puntatore alla risorsa,

  • se è stata creata da un oggetto di shared_ptr proprietario della risorsa,

  • se è stata creata da un oggetto di weak_ptr Class che indica la risorsa, o

  • se la proprietà della risorsa è stata assegnata, con shared_ptr::operator= o chiamando la funzione membro shared_ptr::reset.

shared_ptr oggetti che possieda una condivisione delle risorse un blocco di controllo.Le contiene il blocco di controllo:

  • il numero di shared_ptr oggetti che possieda la risorsa,

  • il numero di weak_ptr oggetti tale punto alla risorsa,

  • il deleter per tale risorsa se disponibile,

  • l'allocatore personalizzato per un blocco di controllo se presente.

Un oggetto di shared_ptr inizializzati utilizzando un puntatore null è un blocco di controllo e non è vuoto.Dopo che un oggetto di shared_ptr rilasciata una risorsa, in non possiede tale risorsa.Dopo che un oggetto di weak_ptr rilasciata una risorsa, più punti alla risorsa.

Quando il numero di shared_ptr oggetti che possieda una risorsa diventa zero, la risorsa viene liberata, o elimina o passando il relativo indirizzo a un deleter, come ad esempio la proprietà della risorsa originariamente creata.Quando il numero di shared_ptr oggetti che possieda una risorsa è zero e il numero di weak_ptr oggetti che puntano a tale risorsa è zero, il blocco di controllo viene liberato, utilizzando allocatore personalizzato per un blocco di controllo se presente.

Un oggetto vuoto di shared_ptr non possiede alcuna risorsa e non ha blocco di controllo.

Un deleter è un oggetto funzione con una funzione membro operator().Il tipo deve essere copia costruttibile e il relativo costruttore di copia e distruttore non deve generare eccezioni.Accetta un parametro, l'oggetto da eliminare.

Alcune funzioni ricevono un elenco di argomenti che definisce le proprietà di shared_ptr<Ty> o dell'oggetto risultante di weak_ptr<Ty>.È possibile specificare tale elenco di argomenti in diversi modi:

nessun argomenti -- l'oggetto risultante è un oggetto vuoto di shared_ptr o un oggetto vuoto di weak_ptr.

ptr -- un puntatore di tipo Other* alla risorsa da gestire.Ty deve essere un tipo completo.Se l'esito negativo di funzione perché il blocco di controllo non può essere allocata) valuta l'espressione delete ptr.

ptr, dtor -- un puntatore di tipo Other* alla risorsa da gestire e un deleter per tale risorsa.Se la funzione ha esito negativo perché il blocco di controllo non può essere allocata), chiama dtor(ptr), che devono essere ben definito.

ptr, dtor, alloc -- un puntatore di tipo Other* alla risorsa da gestire, un deleter per tale risorsa e un allocatore per gestire qualsiasi archiviazione che deve essere allocata e liberata.Se l'esito negativo di funzione perché il blocco di controllo non può essere allocata) chiama dtor(ptr), che devono essere ben definito.

sp -- un oggetto di shared_ptr<Other> proprietario della risorsa da gestire.

wp -- un oggetto di weak_ptr<Other> che indica la risorsa da gestire.

ap -- un oggetto di auto_ptr<Other> che contiene un puntatore alla risorsa da gestire.Se la funzione viene chiamata ap.release(); altrimenti possibile ap invariato.

In tutti i casi, il tipo di puntatore Other* deve essere convertibile in Ty*.

Thread safety

I thread possono leggere e scrivere shared_ptr diverso oggetti contemporaneamente, anche se gli oggetti sono copie di condividere la proprietà.

Membri

Bb982026.collapse_all(it-it,VS.110).gifCostruttori

shared_ptr::shared_ptr

Costruisce un oggetto shared_ptr.

shared_ptr::~shared_ptr

Elimina shared_ptr.

Bb982026.collapse_all(it-it,VS.110).gifMetodi

shared_ptr::element_type

Il tipo di elemento.

shared_ptr::get

Ottiene l'indirizzo della risorsa personalizzata.

shared_ptr::owner_before

Restituisce true se questo shared_ptr viene ordinato prima (o minore di) del puntatore fornito.

shared_ptr::reset

Risorsa personalizzata Replace.

shared_ptr::swap

Scambia due oggetti di shared_ptr.

shared_ptr::unique

Test se la risorsa personalizzata è univoca.

shared_ptr::use_count

Calcola i numeri dei proprietari di risorse.

Bb982026.collapse_all(it-it,VS.110).gifOperatori

shared_ptr::operator boolean-type

Verifica se una risorsa personalizzata esiste.

shared_ptr::operator*

Ottiene il valore definito.

shared_ptr::operator=

Sostituisce la risorsa personalizzata.

shared_ptr::operator->

Ottiene un puntatore al valore definito.

Requisiti

Intestazione: <memory>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

weak_ptr Class

Thread safety della libreria C++ standard

Altre risorse

<memoria> membri