weak_ptr Class

Fasst einen schwach verknüpften Zeiger ein.

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

    weak_ptr();
    weak_ptr(const weak_ptr&);
    template<class Other>
        weak_ptr(const weak_ptr<Other>&);
    template<class Other>
        weak_ptr(const shared_ptr<Other>&);

    weak_ptr& operator=(const weak_ptr&);
    template<class Other>
        weak_ptr& operator=(const weak_ptr<Other>&);
    template<class Other>
        weak_ptr& operator=(shared_ptr<Other>&);

    void swap(weak_ptr&);
    void reset();

    long use_count() const;
    bool expired() const;
    shared_ptr<Ty> lock() const;
    };

Parameter

• Ty
  Der Typ gesteuert vom schwachen Zeiger.

Hinweise

Die Vorlagenklasse beschreibt ein Objekt, das einer Ressource zeigt, die durch eine oder mehrere shared_ptr Class-Objekte verwaltet wird.weak_ptr-Objekte diesen Punkt einer Ressource wirken sich nicht auf den Verweiszähler der Ressource ein.Wenn das letzte shared_ptr-Objekte, die diese Ressource verwaltet, zerstört wird, wird die Ressource freigegeben, auch wenn es weak_ptr-Objekte gibt, die auf diese Ressource zeigen.Dies ist zum Vermeiden von Zyklen in den Datenstrukturen abzugleichen.

weak_ptr-Objektpunkte auf eine Ressource, wenn sie von einem shared_ptr-Objekt erstellt wurde, das diese Ressource besitzt, wenn sie von einem weak_ptr-Objekt erstellt wurde, das auf diese Ressource zeigt, oder wenn diese Ressource mit weak_ptr::operator= zugewiesen wurde.Ein - Objekt stellt weak_ptr nicht direkt auf die Ressource, dass es auf zeigt.Code, dass die Ressource verwenden muss dies jetzt shared_ptr durch ein - Objekt, das diese Ressource besitzt erstellt, indem es die - Memberfunktion weak_ptr::lock.Ein - Objekt weak_ptr abgelaufen ist, wenn die Ressource, die sie zeigt, dass alles, shared_ptr angegeben, dass die Ressource besitzen Sie, sind zerstört wurden freigegeben wurde.lock auf einem weak_ptr-Objekt aufgerufen, das abgelaufen ist, wird ein leerer shared_ptr-Objekt

Ein leeres weak_ptr Objekt zeigt nicht auf allen Ressourcen und verfügt über keinen Kontrollblock.Die Memberfunktion lock gibt ein leeres shared_ptr Objekt zurück.

Ein Zyklus tritt auf, wenn zwei oder mehr Ressourcen, die von shared_ptr-Objekte gesteuert werden, shared_ptr-Objekte gegenseitig verweisen Sie anhalten.Beispielsweise verfügt eine zirkuläre verknüpfte Liste mit drei Elementen einen Kopfknoten N0; dieser Knoten enthält ein shared_ptr-Objekt, das den folgenden Knoten besitzt, N1 an; dieser Knoten enthält ein shared_ptr-Objekt, das den folgenden Knoten besitzt, N2 an; dieser Knoten enthält wiederum ein shared_ptr-Objekt, das den Hauptknoten besitzt, N0 an und bietet den Zyklus.In diesem Fall werden keine der Verweiszähler überhaupt keinen, und die Knoten des Zyklus werden nicht freigegeben.Um den Zyklus zu vermeiden, sollte der letzten Knoten N2 ein weak_ptr-Objekt enthalten, das zu N0 anstelle eines Objekts shared_ptr zeigt.Da das weak_ptr-Objekt nicht N0 besitzt, wirkt sich dies nicht N0 Verweiszähler, und wenn der letzte Verweis des Programms an den Hauptknoten zerstört wird, werden die Knoten in der Liste auch zerstört.

Mitglieder

Konstruktoren

weak_ptr::weak_ptr

Erstellt einen weak_ptr.

Methoden

weak_ptr::element_type	Der Typ des Elements.
weak_ptr::expired	Prüft, ob Besitz abgelaufen ist.
weak_ptr::lock	Erhält exklusiver Besitz einer Ressource.
weak_ptr::owner_before	Gibt true zurück, wenn dieser weak_ptr vor (oder weniger als) dem bereitgestellten Zeiger sortiert wird.
weak_ptr::reset	Besitze Ressourcen der Versionen.
weak_ptr::swap	Austausch zwei weak_ptr-Objekte.
weak_ptr::use_count	Anzahlzahl festgelegte shared_ptr-Objekte.

Operatoren

weak_ptr::operator=

Replaces besaß Ressourcen.

Anforderungen

Header: <memory>

Namespace: std

Siehe auch

Referenz

shared_ptr Class

Weitere Ressourcen

<memory> Member