In Kopfzeile definiert <memory>
template< class T > class weak_ptr;
(seit C++11)

std::weak_ptr ist ein intelligenter Zeiger, der eine nicht besitzende ("schwache") Referenz auf ein Objekt enthält, das von verwaltet wird std::shared_ptr. Es muss umgewandelt werden in std::shared_ptr um auf das referenzierte Objekt zuzugreifen.

std::weak_ptr modelliert temporäres Eigentum: wenn auf ein Objekt nur dann zugegriffen werden muss, wenn es existiert, und es kann jederzeit von jemand anderem gelöscht werden, std::weak_ptr wird verwendet, um das Objekt zu verfolgen, und es wird konvertiert in std::shared_ptr vorübergehendes Eigentum zu übernehmen. Wenn das Original std::shared_ptr zu diesem Zeitpunkt zerstört wird, verlängert sich die Lebensdauer des Objekts bis zum temporären std::shared_ptr wird ebenfalls zerstört.

Eine andere Verwendung für std::weak_ptr besteht darin, Referenzzyklen zu unterbrechen, die von Objekten gebildet werden, die von . verwaltet werden std::shared_ptr. Wenn ein solcher Zyklus verwaist ist (d. h. es gibt keine externen gemeinsam genutzten Zeiger in den Zyklus), können die shared_ptr-Referenzzählungen null erreichen und der Speicher geht verloren. Um dies zu verhindern, kann einer der Zeiger im Zyklus schwach gemacht werden.

Mitgliedstypen

Mitgliedstyp Definition
element_type
T (bis C++17)
std::remove_extent_t<T> (seit C++17)

Mitgliederfunktionen

(Konstrukteur) schafft ein neues weak_ptr
(öffentliche Memberfunktion)
(Zerstörer) zerstört weak_ptr
(öffentliche Memberfunktion)
Betreiber= weist die zu weak_ptr
(öffentliche Memberfunktion)
Modifikatoren
zurücksetzen gibt das Eigentum am verwalteten Objekt frei
(öffentliche Memberfunktion)
Tauschen tauscht die verwalteten Objekte aus
(öffentliche Memberfunktion)
Beobachter
use_count gibt die Anzahl der zurück shared_ptr Objekte, die das Objekt verwalten
(öffentliche Memberfunktion)
abgelaufen prüft, ob das referenzierte Objekt bereits gelöscht wurde
(öffentliche Memberfunktion)
sperren erstellt ein shared_ptr die das referenzierte Objekt verwaltet
(öffentliche Memberfunktion)
Besitzer_before bietet eigentümerbasiertes Ordnen von Schwachstellen
(öffentliche Memberfunktion)

Nichtmitgliederfunktionen

std::tauschen(std::weak_ptr)
(C++11)
spezialisiert sich auf die std::swap Algorithmus
(Funktionsvorlage)

Helferklassen

std::atomar
(C++20)
atomarer schwacher zeiger
(Klassenvorlagen-Spezialisierung)

Abzugsanleitungen(seit C++17)

Anmerkungen

Mögen std::shared_ptr, eine typische Implementierung von weak_ptr speichert zwei Zeiger:

  • einen Zeiger auf den Steuerblock; und
  • der gespeicherte Zeiger des shared_ptr es wurde aus gebaut.

Ein separater gespeicherter Zeiger ist erforderlich, um sicherzustellen, dass die Umwandlung von a shared_ptr zu weak_ptr und dann zurück funktioniert korrekt, auch für aliased shared_ptrS. Es ist nicht möglich, auf den gespeicherten Zeiger in a weak_ptr ohne es in a zu verriegeln shared_ptr.

Fehlerberichte

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

DR Angewendet Verhalten wie veröffentlicht Richtiges Verhalten
LWG 3001 C++17 element_type wurde nicht für Array-Unterstützung aktualisiert Aktualisiert

Beispiel

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

#include <iostream>
#include <memory>
 
std::weak_ptr<int> gw;
 
void observe()
{
    std::cout << "use_count == " << gw.use_count() << ": ";
    if (auto spt = gw.lock()) { // Has to be copied into a shared_ptr before usage
        std::cout << *spt << "n";
    }
    else {
        std::cout << "gw is expiredn";
    }
}
 
int main()
{
    {
        auto sp = std::make_shared<int>(42);
        gw = sp;
 
        observe();
    }
 
    observe();
}

Ausgabe:

use_count == 1: 42
use_count == 0: gw is expired