Namensräume
Varianten
Aktionen

std::weak_ptr<T>::lock

Von cppreference.com
< cpp‎ | memory‎ | weak ptr
 
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
 
std::shared_ptr<T> lock() const noexcept;
 (seit C++11)

Erzeugt einen neuen std::shared_ptr, der das Besitzrecht am verwalteten Objekt teilt. Wenn kein verwaltetes Objekt vorhanden ist, d.h. *this leer ist, dann ist der zurückgegebene shared_ptr ebenfalls leer.

Gibt effektiv expired() ? shared_ptr<T>() : shared_ptr<T>(*this) zurück, atomar ausgeführt.

Inhalt

[bearbeiten] Parameter

(keine)

[bearbeiten] Rückgabewert

Ein shared_ptr, der das Besitzrecht am verwalteten Objekt teilt, wenn std::weak_ptr::expired false zurückgibt. Andernfalls wird ein standardkonstruierter shared_ptr vom Typ T zurückgegeben.

[bearbeiten] Hinweise

Sowohl diese Funktion als auch der Konstruktor von std::shared_ptr können verwendet werden, um temporäres Besitzrecht an dem von einem std::weak_ptr referenzierten verwalteten Objekt zu erlangen. Der Unterschied besteht darin, dass der Konstruktor von std::shared_ptr eine Ausnahme auslöst, wenn sein std::weak_ptr-Argument leer ist, während std::weak_ptr<T>::lock() einen leeren std::shared_ptr<T> konstruiert.

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <iostream>
#include <memory>
 
void observe(std::weak_ptr<int> weak)
{
    if (auto p = weak.lock())
        std::cout << "\tobserve() is able to lock weak_ptr<>, value=" << *p << '\n';
    else
        std::cout << "\tobserve() is unable to lock weak_ptr<>\n";
}
 
int main()
{
    std::weak_ptr<int> weak;
    std::cout << "weak_ptr<> is not yet initialized\n";
    observe(weak);
 
    {
        auto shared = std::make_shared<int>(42);
        weak = shared;
        std::cout << "weak_ptr<> is initialized with shared_ptr\n";
        observe(weak);
    }
 
    std::cout << "shared_ptr<> has been destructed due to scope exit\n";
    observe(weak);
}

Ausgabe

weak_ptr<> is not yet initialized
        observe() is unable to lock weak_ptr<>
weak_ptr<> is initialized with shared_ptr
        observe() is able to lock weak_ptr<>, value=42
shared_ptr<> has been destructed due to scope exit
        observe() is unable to lock weak_ptr<>

[bearbeiten] 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 2316 C++11 lock() war nicht als atomar erforderlich, aber als noexcept, was zu einem Widerspruch führte als atomar spezifiziert

[bearbeiten] Siehe auch

 prüft, ob das referenzierte Objekt bereits gelöscht wurde
(public member function) [edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/weak_ptr/lock&oldid=152413"