Namespaces
Variants

std::weak_ptr<T>:: weak_ptr

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::weak_ptr
constexpr weak_ptr ( ) noexcept ;
(1) (seit C++11)
weak_ptr ( const weak_ptr & r ) noexcept ;
(2) (seit C++11)
template < class Y >
weak_ptr ( const weak_ptr < Y > & r ) noexcept ;
(2) (seit C++11)
template < class Y >
weak_ptr ( const std:: shared_ptr < Y > & r ) noexcept ;
(2) (seit C++11)
weak_ptr ( weak_ptr && r ) noexcept ;
(3) (seit C++11)
template < class Y >
weak_ptr ( weak_ptr < Y > && r ) noexcept ;
(3) (seit C++11)

Konstruiert einen neuen weak_ptr , der möglicherweise ein Objekt mit r teilt.

1) Standardkonstruktor. Erstellt einen leeren weak_ptr .
2) Konstruiert einen neuen weak_ptr , der ein von r verwaltetes Objekt teilt. Falls r kein Objekt verwaltet, verwaltet auch * this kein Objekt. Die templatisierten Überladungen nehmen nicht an der Überladungsauflösung teil, es sei denn Y* ist implizit konvertierbar zu T* , oder Y ist der Typ "Array von N U " für einen Typ U und eine Zahl N , und T ist der Typ "Array unbekannter Größe von (möglicherweise cv-qualifiziertem) U " (seit C++17) .
3) Move-Konstruktoren. Verschiebt eine weak_ptr-Instanz von r nach * this . Danach ist r leer und r. use_count ( ) == 0 . Die templatisierte Überladung nimmt nicht an der Überladungsauflösung teil, es sei denn Y* ist implizit konvertierbar zu T* .

Inhaltsverzeichnis

Parameter

r - a std::shared_ptr or std::weak_ptr that will be viewed by this std::weak_ptr

Hinweise

Da der Standardkonstruktor constexpr ist, werden statische std::weak_ptr s als Teil der statischen Nicht-Lokal-Initialisierung initialisiert, bevor jegliche dynamische Nicht-Lokal-Initialisierung beginnt. Dies macht es sicher, einen std::weak_ptr im Konstruktor eines beliebigen statischen Objekts zu verwenden.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <memory>
struct Foo {};
int main()
{
    std::weak_ptr<Foo> w_ptr;
    {
        auto ptr = std::make_shared<Foo>();
        w_ptr = ptr;
        std::cout << "w_ptr.use_count() inside scope: " << w_ptr.use_count() << '\n';
    }
    std::cout << "w_ptr.use_count() out of scope: " << w_ptr.use_count() << '\n';
    std::cout << "w_ptr.expired() out of scope: "
              << std::boolalpha << w_ptr.expired() << '\n';
}

Ausgabe: 

w_ptr.use_count() inside scope: 1
w_ptr.use_count() out of scope: 0
w_ptr.expired() out of scope: true

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2315 C++11 Move-Semantik war nicht aktiviert für weak_ptr aktiviert

Siehe auch

weist den weak_ptr zu
(öffentliche Elementfunktion)