weak_ptr-Klasse

Umschließt einen schwach verknüpften Zeiger.

Syntax

template<class T> class weak_ptr;

Parameter

T
Der vom schwachen Zeiger gesteuerte Typ.

Hinweise

Die Klassenvorlage beschreibt ein Objekt, das auf eine Ressource verweist, die von einem oder shared_ptr mehreren Objekten verwaltet wird. Die weak_ptr Objekte, die auf eine Ressource verweisen, wirken sich nicht auf die Referenzanzahl der Ressource aus. Wenn das letzte shared_ptr Objekt, das diese Ressource verwaltet, zerstört wird, wird die Ressource freigegeben, auch wenn weak_ptr Objekte auf diese Ressource verweisen. Dieses Verhalten ist unerlässlich, um Zyklen in Datenstrukturen zu vermeiden.

Ein weak_ptr Objekt verweist auf eine Ressource, wenn es aus einem shared_ptr Objekt erstellt wurde, das diese Ressource besitzt, wenn es aus einem weak_ptr Objekt erstellt wurde, das auf diese Ressource verweist, oder wenn diese Ressource ihm operator=zugewiesen wurde. Ein weak_ptr Objekt bietet keinen direkten Zugriff auf die Ressource, auf die es verweist. Code, der die Ressource verwenden muss, erfolgt über ein shared_ptr Objekt, das diese Ressource besitzt, die durch Aufrufen der Memberfunktion lockerstellt wird. Ein weak_ptr Objekt ist abgelaufen, wenn die Ressource, auf die sie verweist, freigegeben wurde, da alle shared_ptr Objekte, die die Ressource besitzen, zerstört wurden. Durch Aufrufen lock eines weak_ptr Objekts, das abgelaufen ist, wird ein leeres shared_ptr Objekt erstellt.

Ein leeres weak_ptr Objekt verweist nicht auf Ressourcen und weist keinen Steuerelementblock auf. Die Memberfunktion lock gibt ein leeres shared_ptr Objekt zurück.

Ein Zyklus tritt auf, wenn es für zwei oder mehr Ressourcen, die von shared_ptr-Objekten gesteuert werden, shared_ptr-Objekte gibt, die gegenseitig auf sich verweisen. Angenommen, eine kreisförmig verknüpfte Liste mit drei Elementen hat den Kopfknoten N0; dieser Knoten enthält ein shared_ptr-Objekt, das den nächsten Knoten, N1, besitzt; dieser Knoten enthält ein shared_ptr-Objekt, das den nächsten Knoten, N2, besitzt; dieser Knoten wiederum enthält ein shared_ptr-Objekt, das den Kopfknoten N0 besitzt, wodurch der Zyklus geschlossen wird. In dieser Situation werden die Referenzanzahlen nie null, und die Knoten im Zyklus werden nie freigegeben. Um den Zyklus zu vermeiden, sollte der letzte Knoten, N2, anstelle eines shared_ptr-Objekts ein weak_ptr-Objekt enthalten, das auf N0 verweist. Da das weak_ptr Objekt nicht besitzt N0 , wirkt es sich nicht auf N0die Referenzanzahl aus, und wenn der letzte Verweis des Programms auf den Kopfknoten zerstört wird, werden auch die Knoten in der Liste zerstört.

Mitglieder

Name	Beschreibung
Konstruktoren
weak_ptr	Erstellt ein Objekt vom Typ weak_ptr.
Destruktoren
~weak_ptr	Beschädigt ein Objekt vom Typ weak_ptr.
TypeDefs
element_type	Der Typ des Elements.
Memberfunktionen
expired	Überprüft, ob der Besitz abgelaufen ist.
lock	Bedingt exklusiven Besitz einer Ressource.
owner_before	Gibt true zurück, wenn dieses weak_ptr-Objekt vor dem bereitgestellten Zeiger angeordnet (oder kleiner als dieser) ist.
reset	Gibt eine in Besitz befindliche Ressource frei.
swap	Tauscht zwei weak_ptr-Objekte.
use_count	Zählt die Anzahl der shared_ptr Objekte.
Operatoren
operator=	Ersetzt eine in Besitz befindliche Ressource.

element_type

Der Typ des Elements.

typedef T element_type; // through C++17
using element_type = remove_extent_t<T>; // C++20

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Tdar.

Beispiel

// std__memory__weak_ptr_element_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::weak_ptr<int> wp0(sp0);
    std::weak_ptr<int>::element_type val = *wp0.lock();

    std::cout << "*wp0.lock() == " << val << std::endl;

    return (0);
}

*wp0.lock() == 5

expired

Testet, ob der Besitz abgelaufen ist, d. h., das referenzierte Objekt wurde gelöscht.

bool expired() const noexcept;

Hinweise

Die Memberfunktion gibt true zurück, wenn *this abgelaufen ist, andernfalls false.

Beispiel

// std__memory__weak_ptr_expired.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> sp(new int(10));
        wp = sp;
        std::cout << "wp.expired() == " << std::boolalpha
            << wp.expired() << std::endl;
        std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    }

    // check expired after sp is destroyed
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;
    std::cout << "(bool)wp.lock() == " << std::boolalpha
        << (bool)wp.lock() << std::endl;

    return (0);
}

wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false

lock

Ruft einen shared_ptr Besitz einer Ressource ab, die den Besitz einer Ressource teilt.

shared_ptr<T> lock() const noexcept;

Hinweise

Die Memberfunktion gibt ein leeres shared_ptr Objekt zurück, wenn *this es abgelaufen ist. Andernfalls wird ein shared_ptr<T> Objekt zurückgegeben, das die Ressource besitzt, auf die *this verweist. Gibt einen Wert zurück, der der Atomausführung entspricht expired() ? shared_ptr<T>() : shared_ptr<T>(*this).

Beispiel

// std__memory__weak_ptr_lock.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> sp(new int(10));
        wp = sp;
        std::cout << "wp.expired() == " << std::boolalpha
            << wp.expired() << std::endl;
        std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    }

    // check expired after sp is destroyed
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;
    std::cout << "(bool)wp.lock() == " << std::boolalpha
        << (bool)wp.lock() << std::endl;

    return (0);
}

wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false

operator=

Ersetzt eine in Besitz befindliche Ressource.

weak_ptr& operator=(const weak_ptr& ptr) noexcept;

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

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

Parameter

Other
Der Typ, der vom freigegebenen oder schwachen Zeiger gesteuert wird.

ptr
Der schwache Zeiger oder der freigegebene Zeiger, der kopiert werden soll.

Hinweise

Die Operatoren geben die Ressource frei, auf *this die derzeit verwiesen wird, und weisen den Besitz der Ressource zu*this, die von ptr ihnen benannt ist. Wenn ein Operator fehlschlägt, bleibt *this er unverändert. Jeder Operator hat einen Effekt, der weak_ptr(ptr).swap(*this)entspricht .

Beispiel

// std__memory__weak_ptr_operator_as.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::weak_ptr<int> wp0(sp0);
    std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;

    std::shared_ptr<int> sp1(new int(10));
    wp0 = sp1;
    std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;

    std::weak_ptr<int> wp1;
    wp1 = wp0;
    std::cout << "*wp1.lock() == " << *wp1.lock() << std::endl;

    return (0);
}

*wp0.lock() == 5
*wp0.lock() == 10
*wp1.lock() == 10

owner_before

Gibt true zurück, wenn dieses weak_ptr-Objekt vor dem bereitgestellten Zeiger angeordnet (oder kleiner als dieser) ist.

template <class Other>
bool owner_before(const shared_ptr<Other>& ptr) const noexcept;

template <class Other>
bool owner_before(const weak_ptr<Other>& ptr) const noexcept;

Parameter

ptr
Ein lvalue-Verweis auf shared_ptr oder weak_ptr.

Hinweise

Die Elementfunktion der Vorlage gibt zurück true , wenn *this sie vor ptrgeordnet ist.

reset

Gibt die ressource im Besitz frei.

void reset() noexcept;

Hinweise

Die Memberfunktion gibt die Ressource frei, auf *this die verwiesen wird, und konvertiert sie in ein leeres *this weak_ptr Objekt.

Beispiel

// std__memory__weak_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp(new int(5));
    std::weak_ptr<int> wp(sp);
    std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;

    wp.reset();
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;

    return (0);
}

*wp.lock() == 5
wp.expired() == false
wp.expired() == true

swap

Tauscht zwei weak_ptr-Objekte.

void swap(weak_ptr& wp) noexcept;

Umfasst auch die Spezialisierung:

template<class T>
void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

Parameter

wp
Der schwache Zeiger, mit dem getauscht werden soll.

Hinweise

Nach einer swap, die ursprünglich auf die Ressource verweist, *this wird wpvon , und die Ressource, auf die ursprünglich durch verwiesen wurde, wird durch .wp *this Die Funktion ändert die Verweisanzahl für die beiden Ressourcen nicht und löst keine Ausnahmen aus. Die Auswirkung der Vorlagenspezialisierung ist das Äquivalent von a.swap(b).

Beispiel

// std__memory__weak_ptr_swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::shared_ptr<int> sp2(new int(10));
    std::cout << "*sp1 == " << *sp1 << std::endl;

    sp1.swap(sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;

    swap(sp1, sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;
    std::cout << std::endl;

    std::weak_ptr<int> wp1(sp1);
    std::weak_ptr<int> wp2(sp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    wp1.swap(wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    swap(wp1, wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    return (0);
}

*sp1 == 5
*sp1 == 10
*sp1 == 5

*wp1 == 5
*wp1 == 10
*wp1 == 5

use_count

Zählt die Anzahl der shared_ptr Objekte, die der freigegebenen Ressource gehören.

long use_count() const noexcept;

Hinweise

Die Memberfunktion gibt die Anzahl der shared_ptr-Objekte zurück, die die Ressource besitzen, auf die von *this gezeigt wird.

Beispiel

// std__memory__weak_ptr_use_count.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::weak_ptr<int> wp(sp1);
    std::cout << "wp.use_count() == "
        << wp.use_count() << std::endl;

    std::shared_ptr<int> sp2(sp1);
    std::cout << "wp.use_count() == "
        << wp.use_count() << std::endl;

    return (0);
}

wp.use_count() == 1
wp.use_count() == 2

weak_ptr

Erstellt ein Objekt vom Typ weak_ptr.

constexpr weak_ptr() noexcept;

weak_ptr(const weak_ptr& wp) noexcept;

weak_ptr(weak_ptr&& wp) noexcept;

template <class Other>
weak_ptr(const weak_ptr<Other>& wp) noexcept;

template <class Other>
weak_ptr(weak_ptr<Other>&& sp) noexcept;

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

Parameter

Other
Der Typ, der vom Argument für den gemeinsamen/schwachen Zeiger gesteuert wird. Diese Konstruktoren nehmen nicht an der Überladungsauflösung teil, es sei denn Other* , sie sind kompatibel mit element_type*.

wp
Der zu kopierende schwache Zeiger.

sp
Der zu kopierende gemeinsame Zeiger.

Hinweise

Der Standardkonstruktor erstellt ein leeres weak_ptr Objekt. Die Konstruktoren, die jeweils ein Argument annehmen, erstellen ein leeres weak_ptr Objekt, wenn der Argumentzeiger leer ist. Andernfalls erstellen sie ein weak_ptr Objekt, das auf die vom Argument benannte Ressource verweist. Die Verweisanzahl des freigegebenen Objekts wird nicht geändert.

Beispiel

// std__memory__weak_ptr_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp0;
    std::cout << "wp0.expired() == " << std::boolalpha
        << wp0.expired() << std::endl;

    std::shared_ptr<int> sp1(new int(5));
    std::weak_ptr<int> wp1(sp1);
    std::cout << "*wp1.lock() == "
        << *wp1.lock() << std::endl;

    std::weak_ptr<int> wp2(wp1);
    std::cout << "*wp2.lock() == "
        << *wp2.lock() << std::endl;

    return (0);
}

wp0.expired() == true
*wp1.lock() == 5
*wp2.lock() == 5

~weak_ptr

Beschädigt ein Objekt vom Typ weak_ptr.

~weak_ptr();

Hinweise

Der Destruktor zerstört dies weak_ptr , hat jedoch keine Auswirkung auf die Referenzanzahl des Objekts, auf dessen gespeicherten Zeigerpunkte es liegt.

Siehe auch

Headerdateienreferenz
<memory>
shared_ptr-Klasse