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
.gif "Bb982026.collapse_all(it-it,VS.110).gif")
Costruttori
Costruisce un oggetto shared_ptr. |
|
Elimina shared_ptr. |
Metodi
Il tipo di elemento. |
|
Ottiene l'indirizzo della risorsa personalizzata. |
|
Restituisce true se questo shared_ptr viene ordinato prima (o minore di) del puntatore fornito. |
|
Risorsa personalizzata Replace. |
|
Scambia due oggetti di shared_ptr. |
|
Test se la risorsa personalizzata è univoca. |
|
Calcola i numeri dei proprietari di risorse. |
Operatori
Verifica se una risorsa personalizzata esiste. |
|
Ottiene il valore definito. |
|
Sostituisce la risorsa personalizzata. |
|
Ottiene un puntatore al valore definito. |
Requisiti
Intestazione: <memory>
Spazio dei nomi: deviazione standard
Vedere anche
Riferimenti
Thread safety della libreria C++ standard