std:: weak_ptr

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

std::weak_ptr modelliert temporären Besitz: Wenn auf ein Objekt nur dann zugegriffen werden muss, falls 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 std::shared_ptr umgewandelt, um temporären Besitz zu erlangen. Falls das ursprüngliche std::shared_ptr zu diesem Zeitpunkt zerstört wird, wird die Lebensdauer des Objekts verlängert, bis das temporäre std::shared_ptr ebenfalls zerstört wird.

Eine weitere Verwendung für std::weak_ptr ist das Unterbrechen von Referenzzyklen, die durch Objekte gebildet werden, die von std::shared_ptr verwaltet werden. Wenn ein solcher Zyklus verwaist (d.h. es gibt keine externen Shared Pointer in den Zyklus), können die shared_ptr Referenzzähler nicht auf Null sinken und der Speicher wird nicht freigegeben. Um dies zu verhindern, kann einer der Pointer im Zyklus als Weak-Pointer ausgelegt werden .

Mitgliedertypen

Memberfunktionen

Nicht-Member-Funktionen

Hilfsklassen

Deduction guides (seit C++17)

Hinweise

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 zu einem weak_ptr und zurück korrekt funktioniert, selbst für aliased shared_ptr s. Es ist nicht möglich, auf den gespeicherten Zeiger in einem weak_ptr zuzugreifen, ohne ihn in einen shared_ptr zu locken.

Beispiel

#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();
}

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

Fehlerberichte

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

Siehe auch