Classe shared_ptr
Utilizza un puntatore intelligente con conteggio dei riferimento come wrapper di un oggetto allocato in modo dinamico.
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 controllato dal puntatore condiviso.Other
Il tipo controllato dal puntatore argomento.ptr
Il puntatore da copiare.D
Il tipo del deleter.A
Il tipo dell'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 auto 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 shared_ptr contiene efficacemente un puntatore a una risorsa che contiene un puntatore null. Una risorsa può essere posseduta da più oggetti shared_ptr; quando l'ultimo oggetto shared_ptr proprietario di una risorsa particolare viene eliminato, la risorsa viene liberata.
Un shared_ptr smette di contenere una risorsa quando viene riassegnato o reimpostato.
Un argomento di template Ty potrebbe essere un tipo incompleto salvo quando indicato per alcune funzioni membro.
Quando viene costruito un oggetto shared_ptr<Ty> da un puntatore di risorse di tipo G* o shared_ptr<G>, il tipo di puntatore G* deve essere convertibile in Ty*. In caso contrario, il codice non verrà compilato. Di seguito è riportato un esempio.
class F {};
class G : public F {};
#include <memory>
using namespace std;
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> sp5(new G); // error, G* not convertible to int*
shared_ptr<int> sp6(sp2); // error, template parameter int and argument shared_ptr<F>
Un oggetto shared_ptr possiede una risorsa:
se viene costruito con un puntatore alla risorsa,
se è stato creato da un oggetto shared_ptr proprietario della risorsa,
se è stato creato da un oggetto Classe weak_ptr che punta alla risorsa, o
se la proprietà di tale risorsa è stata assegnata ad esso, con shared_ptr::operator= o chiamando la funzione membro shared_ptr::reset.
Gli oggetti shared_ptr che possiedono una risorsa condividono un blocco di controllo. Il blocco di controllo contiene:
il numero di oggetti shared_ptr che possiedono la risorsa,
il numero di oggetti weak_ptr che puntano alla risorsa,
il deleter per tale risorsa se disponibile,
l'allocatore personalizzato per un blocco di controllo se presente.
Un oggetto shared_ptr inizializzato tramite un puntatore null possiede un blocco di controllo e non è vuoto. Dopo che un oggetto shared_ptr rilasciata una risorsa, non possiede più tale risorsa. Dopo che un oggetto weak_ptr rilasciata una risorsa, non punta più alla tale risorsa.
Quando il numero di oggetti shared_ptr che possiedono una risorsa diventa zero, la risorsa viene liberata, eliminandola o passando il relativo indirizzo a un deleter, in base a come la proprietà della risorsa è stata inizialmente creata. Quando il numero di oggetti shared_ptr cui possieda una risorsa è zero e il numero di oggetti weak_ptr che puntano a tale risorsa è zero, il blocco di controllo viene liberato, utilizzando l'allocatore personalizzato per un blocco di controllo se presente.
Un oggetto vuoto 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 costruibile per copia e i relativi costruttore copia e distruttore copia non devono generare eccezioni. Accetta un parametro, l'oggetto da eliminare.
Alcune funzioni ricevono un elenco di argomenti che definisce le proprietà dell'oggetto shared_ptr<Ty> risultante o dell'oggetto weak_ptr<Ty>. È possibile specificare tale elenco di argomenti in diversi modi:
nessun argomento -- l'oggetto risultante è un oggetto shared_ptr vuoto o un oggetto weak_ptr vuoto.
ptr -- un puntatore di tipo Other* alla risorsa da gestire. L'oggetto Ty deve essere un tipo completo. Se la funzione ha esito negativo (perché il blocco di controllo non può essere allocato) 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 allocato), chiama dtor(ptr), che deve 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 la funzione ha esito negativo (perché il blocco di controllo non può essere allocato) chiama dtor(ptr), che deve essere ben definito.
sp -- un oggetto shared_ptr<Other> proprietario della risorsa da gestire.
wp -- un oggetto weak_ptr<Other> che punta alla risorsa da gestire.
ap -- un oggetto auto_ptr<Other> che contiene un puntatore alla risorsa da gestire. Se la funzione viene ha esito positivo chiama ap.release(); altrimenti lascia ap invariato.
In tutti i casi, il tipo di puntatore Other* deve essere convertibile in Ty*.
Thread safety
Multipli thread possono leggere e scrivere diversi oggetti shared_ptr contemporaneamente, anche se gli oggetti sono copie che ne condividono la proprietà.
Membri
Costruttori
Costruisce un oggetto shared_ptr. |
|
Distruzione di shared_ptr. |
Metodi
Il tipo di un elemento. |
|
Ottiene l'indirizzo della risorsa posseduta. |
|
Restituisce true se shared_ptr è ordinato prima (o minore di) del puntatore fornito. |
|
Sostituzione di una risorsa. |
|
Scambia due oggetti shared_ptr. |
|
Verifica se la risorsa posseduta è univoca. |
|
Conta il numero dei proprietari delle risorse. |
Operatori
Verifica se una risorsa posseduta esiste. |
|
Ottiene il valore definito. |
|
Sostituisce la risorsa posseduta. |
|
Ottiene un puntatore al valore definito. |
Requisiti
Header: <memory>
Spazio dei nomi: std
Vedere anche
Riferimenti
Sicurezza dei thread nella libreria standard C++