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 *thisweak_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
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für