Namensräume
Varianten
Aktionen

std::weak_ptr

Von cppreference.com
< cpp‎ | memory
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
std::weak_ptr
 
Definiert in Header <memory>
template< class T > class weak_ptr;
 (seit C++11)

std::weak_ptr ist ein Smart Pointer, der eine nicht-besitzende ("schwache") Referenz auf ein Objekt hält, das von std::shared_ptr verwaltet wird. Er muss in einen std::shared_ptr konvertiert werden, um auf das referenzierte Objekt zugreifen zu können.

std::weak_ptr modelliert temporäres Eigentum: Wenn auf ein Objekt nur dann zugegriffen werden muss, wenn es existiert, und es jederzeit von jemand anderem gelöscht werden kann, wird std::weak_ptr verwendet, um das Objekt zu verfolgen, und es wird in einen std::shared_ptr konvertiert, um temporäres Eigentum zu erlangen. Wenn der ursprüngliche std::shared_ptr zu diesem Zeitpunkt zerstört wird, wird die Lebensdauer des Objekts verlängert, bis auch der temporäre std::shared_ptr zerstört wird.

Ein weiterer Verwendungszweck für std::weak_ptr ist das Brechen von Referenzzyklen, die von Objekten gebildet werden, die von std::shared_ptr verwaltet werden. Wenn ein solcher Zyklus verwaist ist (d. h. keine externen gemeinsamen Zeiger in den Zyklus zeigen), können die shared_ptr-Referenzzähler nicht auf Null fallen und der Speicher wird geleckt. Um dies zu verhindern, kann einer der Zeiger im Zyklus schwach gemacht werden.

Inhalt

[edit] Mitgliedstypen

Mitgliedertyp Definition
element_type

T

(bis C++17)

std::remove_extent_t<T>

(seit C++17)

[edit] Mitgliederfunktionen

 erstellt einen neuen weak_ptr
(public member function) [edit]
 zerstört einen weak_ptr
(public member function) [edit]
 weist den weak_ptr zu
(public member function) [edit]
Modifizierer
 gibt den Besitz des verwalteten Objekts frei
(public member function) [edit]
 Vertauscht die verwalteten Objekte
(public member function) [edit]
Observer
 gibt die Anzahl der shared_ptr-Objekte zurück, die das Objekt verwalten
(public member function) [edit]
 prüft, ob das referenzierte Objekt bereits gelöscht wurde
(public member function) [edit]
 erstellt einen shared_ptr, der das referenzierte Objekt verwaltet
(public member function) [edit]
 bietet inhaltsbasiertes Ordering von schwachen Zeigern
(public member function) [edit]
(C++26)
 ermöglicht das Hashing von schwachen Zeigern basierend auf dem Besitzer
(public member function) [edit]
(C++26)
 ermöglicht den gleichheitsbasierten Vergleich von schwachen Zeigern basierend auf dem Besitzer
(public member function) [edit]

[edit] Nicht-Mitgliederfunktionen

(C++11)
 spezialisiert den Algorithmus std::swap
(Funktionsschablone) [bearbeiten]

[edit] Hilfsklassen

(C++20)
 atomarer schwacher Zeiger
(Klassenvorlagenspezialisierung) [bearbeiten]

[edit] Deduktionshilfen (seit C++17)

[edit] Hinweise

Ähnlich wie std::shared_ptr speichert eine typische Implementierung von weak_ptr zwei Zeiger

  • einen Zeiger auf den Kontrollblock; und
  • den gespeicherten Zeiger des shared_ptr, von dem er konstruiert wurde.

Ein separater gespeicherter Zeiger ist notwendig, um sicherzustellen, dass die Konvertierung eines shared_ptr in einen weak_ptr und dann zurück korrekt funktioniert, selbst bei Aliasing-shared_ptrs. Es ist nicht möglich, auf den gespeicherten Zeiger in einem weak_ptr zuzugreifen, ohne ihn in einen shared_ptr zu sperren.

Feature-Test-Makro Wert Std Feature
__cpp_lib_smart_ptr_owner_equality 202306L (C++26) Ermöglicht die Verwendung von std::weak_ptr als Schlüssel in ungeordneten assoziativen Containern

[edit] Beispiel

Demonstriert, wie `lock` verwendet wird, um die Gültigkeit des Zeigers sicherzustellen.

Führen Sie diesen Code aus
#include <iostream>
#include <memory>
 
std::weak_ptr<int> gw;
 
void observe()
{
    std::cout << "gw.use_count() == " << gw.use_count() << "; ";
    // we have to make a copy of shared pointer before usage:
    if (std::shared_ptr<int> spt = gw.lock())
        std::cout << "*spt == " << *spt << '\n';
    else
        std::cout << "gw is expired\n";
}
 
int main()
{
    {
        auto sp = std::make_shared<int>(42);
        gw = sp;
 
        observe();
    }
 
    observe();
}

Ausgabe

gw.use_count() == 1; *spt == 42
gw.use_count() == 0; gw is expired

[edit] Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3001 C++17 element_type wurde für die Array-Unterstützung nicht aktualisiert aktualisiert

[edit] Siehe auch

(C++11)
 intelligenter Zeiger mit semantisch eindeutigem Objektbesitz
(Klassen-Template) [edit]
(C++11)
 intelligenter Zeiger mit semantisch geteiltem Objektbesitz
(Klassen-Template) [edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/weak_ptr&oldid=173517"