shared_ptr Class

Artikel
03/26/2013

Bindet einen Verweis-gezählten intelligenten Zeiger um ein dynamisch zugeordnete - Objekt.

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

Parameter

Ty
Der Typ gesteuert vom freigegebenen Zeiger.
Other
Der Typ des Argumentzeiger gesteuert.
ptr
Der Zeiger zu kopieren.
D
Der Typ des Deleters.
A
Der Typ der Belegungsfunktion verwendet.
dtor
Der Deleter.
alloc
Die Belegungsfunktion verwendet.
sp
Der zu kopieren oder wechseln zu können intelligenten Zeiger.
wp
Der schwache zu kopieren oder wechseln zu können Zeiger.
ap
Der automatische zu kopieren oder wechseln zu können Zeiger.
up
Der eindeutige Zeiger zu verschiebende.

Hinweise

Die Vorlagenklasse beschreibt ein Objekt, das Referenzzähler verwendet, um Ressourcen zu verwalten.Ein - Objekt shared_ptr effektiv enthält einen Zeiger auf die Ressource an, der er einen NULL-Zeiger besitzt oder enthält.Eine Ressource kann über mehr als ein shared_ptr-Objekt besitzen; Wenn das letzte shared_ptr-Objekt, das eine bestimmte Ressource besitzt, zerstört wird, wird die Ressource freigegeben.

shared_ptr wird beendet, eine Ressource besitzen, wenn oder zurückgesetzt neu zugewiesen wird.

Das Vorlagenargument Ty kann ein unvollständiger Typ, außer wie für bestimmte Memberfunktionen aufgeführt.

Wenn ein shared_ptr<Ty>-Objekt von einem Ressourcenzeiger des Typs G* oder von shared_ptr<G> erstellt wird, muss der Zeigertyp G* zu Ty* konvertierbar sein.Wenn dies nicht der Fall ist, wird der Code nicht.Beispiel:

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>

Ein shared_ptr-Objekt besitzt eine Ressource:

wenn er mit einem Zeiger auf diese Ressource erstellt wurde,
wenn sie von einem shared_ptr-Objekt erstellt wurde, das diese Ressource besitzt,
wenn sie von einem weak_ptr Class-Objekt erstellt wurde, das auf diese Ressource zeigt oder
unklarem Besitzer dieser Ressource hinzufügen, entweder mit shared_ptr::operator= zugewiesen wurde oder die Memberfunktion shared_ptr::reset aufgerufen wurde.

shared_ptr-Objekte, dass eine Ressourcenfreigabe ein Kontrollblock besitzen Sie.Die Kontrollblockgriffe:

Anzahl der shared_ptr-Objekte, dass die Ressource besitzen Sie,
Anzahl der weak_ptr-Objekte diesen Punkt zu der Ressource ein,
der Deleter für diese Ressource, wenn ein verfügt,
die benutzerdefinierte Belegungsfunktion für den Kontrollblock, sofern vorhanden.

Ein - Objekt, das shared_ptr initialisiert wird, indem ein NULL-Zeiger verwendet, enthält einen Kontrollblock und ist nicht leer.Nachdem ein shared_ptr-Objekt eine Ressource freigibt, besitzt keine weiteren diese Ressource.Nachdem ein weak_ptr-Objekt eine Ressource freigibt, werden sie nicht mehr auf diese Ressource.

Wenn die Anzahl der shared_ptr, dass besitzen Sie, eine Ressource wird null angegeben, wird die Ressource, entweder freigegeben, indem es gelöscht oder, durch Übergeben der Adresse zu einem Deleter, je nachdem, wie der Besitz Ressource ursprünglich erstellt wurde.Wenn die Anzahl der shared_ptr, dass besitzen Sie, eine Ressource ist null Objekte sowie die Anzahl der weak_ptr diesen Punkt auf diese Ressource ist null, der Kontrollblock wird freigegeben, mit der benutzerdefinierten Belegungsfunktion für den Kontrollblock übergeben werden, wenn sie ein verfügt.

Ein leeres shared_ptr-Objekt besitzt keine Ressourcen und verfügt über keinen Kontrollblock.

Ein Deleter ist ein Funktionsobjekt, das eine Memberfunktion operator() verfügt.Der Typ muss die konstruierbare Kopie sein, und der Kopierkonstruktor und Destruktor dürfen keine Ausnahmen auslösen.Sie akzeptiert einen Parameter, die gelöscht werden, Objekt.

Einige Funktionen akzeptieren eine Argumentliste, die Eigenschaften des resultierenden shared_ptr<Ty> oder weak_ptr<Ty>-Objekts definiert.Sie können eine solche Argumentliste auf verschiedene Arten angeben:

keine Argumente -- das resultierende - Objekt ist ein leeres shared_ptr-Objekt oder ein leeres weak_ptr-Objekt.

ptr -- ein Zeiger des Typs Other* zur Ressource verwaltet werden.Ty muss ein vollständiger Typ sein.Wenn die Funktion fehlschlägt (da der Kontrollblock nicht zugeordnet werden kann), ergibt der Ausdruck delete ptr aus.

ptr, dtor -- ein Zeiger des Typs Other* zur verwaltet werden Ressource und ein Deleter für diese Ressource.Wenn die Funktion fehlschlägt (da der Kontrollblock nicht zugeordnet werden kann), ruft sie dtor(ptr) auf, die genau definiert sein muss.

ptr, dtor, alloc -- ein Zeiger des Typs Other* zur verwaltet werden Ressource ein, Deleter für diese Ressource und eine Belegungsfunktion verwendet, um einen beliebigen Speicher zu verwalten, der zugeordnet und freigegeben werden muss.Wenn die Funktion fehlschlägt (da der Kontrollblock nicht zugeordnet werden kann), ruft er dtor(ptr) auf, die genau definiert sein muss.

sp -- shared_ptr<Other> ein Objekt, das die verwaltet werden Ressource besitzt.

wp -- weak_ptr<Other> ein - Objekt, das zur verwaltet werden zeigt Ressource.

ap -- auto_ptr<Other> ein Objekt, das einen Zeiger auf die verwaltet werden Ressource enthält.Wenn die Funktion folgt, ruft sie ap.release() auf; andernfalls können sie ap unverändert.

In allen Fällen muss der Zeigertyp Other* zu Ty* konvertierbar sein.

Threadsicherheit

Mehrere Threads können lesen und anderen shared_ptr schreiben Objekte gleichzeitig ein, auch wenn die Objekte Kopien sind, die Kapitalbeteiligung.

Mitglieder

Konstruktoren

shared_ptr::shared_ptr	Erstellt einen shared_ptr.
shared_ptr::~shared_ptr	Zerstört shared_ptr.

Methoden

shared_ptr::element_type	Der Typ eines Elements.
shared_ptr::get	Ruft Adresse von zugehörigen Ressourcen ab.
shared_ptr::owner_before	Gibt true zurück, wenn dieses shared_ptr vor (oder weniger als) dem bereitgestellten Zeiger sortiert wird.
shared_ptr::reset	Replace besaß Ressourcen.
shared_ptr::swap	Austausch zwei shared_ptr-Objekte.
shared_ptr::unique	Prüft, ob Besitze Ressourcen eindeutig sind.
shared_ptr::use_count	Zählt Zahlen Ressourcenbesitzer.

Operatoren

shared_ptr::operator boolean-type	Prüft, ob besitzenden Ressourcen vorhanden sind.
shared_ptr::operator*	Ruft den festgelegten Wert ab.
shared_ptr::operator=	Ersetzt die zugehörigen Ressourcen.
shared_ptr::operator->	Ruft einen Zeiger auf den festgelegten Wert.

Anforderungen

Header: <memory>

Namespace: std

Siehe auch

Referenz

weak_ptr Class

Threadsicherheit in der C++-Standardbibliothek

Weitere Ressourcen

<memory> Member

Freigeben über