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 mehreren shared_ptr-Objekten verwaltet wird. Die weak_ptr Objekte, die auf eine Ressource verweisen, wirken sich nicht auf den Verweiszähler der Ressource aus. Wenn das letzte shared_ptr Objekt, das diese Ressource verwaltet, zerstört wird, wird die Ressource freigegeben, auch wenn Objekte vorhanden sind, die weak_ptr auf diese Ressource verweisen. Dieses Verhalten ist wichtig, 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 ihm diese Ressource mit operator= zugewiesen wurde. Ein weak_ptr -Objekt bietet keinen direkten Zugriff auf die Ressource, auf die es verweist. Code, der auf die Ressource zugreifen muss, erledigt dies über ein shared_ptr-Objekt, das diese Ressource besitzt, die durch Aufrufen der Memberfunktion lock erstellt wurde. Ein weak_ptr -Objekt ist abgelaufen, wenn die Ressource, auf die es zeigt, freigegeben wurde, da alle Objekte, die shared_ptr die Ressource besitzen, zerstört wurden. Ein Aufrufen von lock für ein weak_ptr-Objekt, das abgelaufen ist, erstellt ein leeres shared_ptr-Objekt.

Ein leeres weak_ptr-Objekt verweist nicht auf Ressourcen und verfügt über keinen Kontrollblock. Ihre 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 Verweisanzahlen 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 Objekt nicht besitzt, wirkt es sich nicht auf den weak_ptr N0 N0 Verweiszähler aus, und wenn der letzte Verweis des Programms auf den Hauptknoten zerstört wird, werden auch die Knoten in der Liste zerstört.

Member

name BESCHREIBUNG
Konstruktoren
weak_ptr Erstellt ein Objekt vom Typ weak_ptr.
Destruktoren
~weak_ptr Erstellt ein Objekt vom Typ weak_ptr.
TypeDefs
element_type Der Typ des Elements.
Memberfunktionen
Abgelaufen Überprüft, ob der Besitz abgelaufen ist.
lock Bedingt exklusiven Besitz einer Ressource.
owner_before Gibt true zurück, wenn dieser weak_ptr vor (oder kleiner als) dem bereitgestellten Zeiger sortiert 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 T dar.

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

Abgelaufen

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

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

Sperren

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

shared_ptr<T> lock() const noexcept;

Hinweise

Die Memberfunktion gibt ein leeres shared_ptr Objekt zurück, wenn *this abgelaufen ist. Andernfalls gibt sie ein shared_ptr<T> -Objekt zurück, das die Ressource besitzt, auf die *this zeigt. Gibt einen Wert zurück, der der atomaren Ausführung von expired() ? shared_ptr<T>() : shared_ptr<T>(*this) entspricht.

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

Andere
Der Typ, der vom argument shared- oder weak-Zeiger gesteuert wird.

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

Hinweise

Alle Operatoren geben die Ressource frei, auf die derzeit von verwiesen wird, *this und weisen den Besitz der von ptr benannten Ressource *this zu. Wenn ein Operator fehlschlägt, bleibt er *this 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 dieser weak_ptr vor (oder kleiner als) dem bereitgestellten Zeiger sortiert 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 oder shared_ptr . weak_ptr

Hinweise

Die Vorlagenmemberfunktion gibt true zurück, wenn *this vor ptr sortiert ist.

Zurücksetzen

Gibt die eigene Ressource frei.

void reset() noexcept;

Hinweise

Die Memberfunktion gibt die Ressource frei, auf die von gezeigt *this wird, und konvertiert *this sie in ein leeres 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 einem wird auf die Ressource, auf die ursprünglich von verwiesen wurde, von wp verwiesen, und die Ressource, auf die wp ursprünglich verweist, swap wird von auf die Ressource *this *this verwiesen. Die Funktion ändert die Verweisanzahl für die beiden Ressourcen nicht und löst keine Ausnahmen aus. Der Effekt der Vorlagenspezialisierung entspricht 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 die freigegebene Ressource besitzen.

long use_count() const noexcept;

Hinweise

Die Memberfunktion gibt die Anzahl der Objekte shared_ptr zurück, die die Ressource besitzen, auf die von verwiesen *this 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

Andere
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 ist mit element_type* kompatibel.

Wp
Der zu kopierende schwache Zeiger.

Sp
Der zu kopierende gemeinsame Zeiger

Hinweise

Der Standardkonstruktor erstellt ein leeres weak_ptr Objekt. Die Konstruktoren, die ein Argument verwenden, erstellen jeweils ein leeres weak_ptr Objekt, wenn der Argumentzeiger leer ist. Andernfalls erstellen sie ein weak_ptr -Objekt, das auf die Ressource verweist, die durch das -Argument benannt wird. 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, hat jedoch keine Auswirkungen auf die Verweisanzahl des Objekts, auf das weak_ptr sein gespeicherter Zeiger zeigt.

Siehe auch

Headerdateireferenz
<memory>
shared_ptr-Klasse