Namespaces
Variants

std::experimental::shared_ptr<T>:: shared_ptr

From cppreference.net
C++
Experimental
Library fundamentals
std::experimental::shared_ptr
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
constexpr shared_ptr ( ) noexcept ;
(1)
constexpr shared_ptr ( std:: nullptr_t ) noexcept ;
(2)
template < class Y >
explicit shared_ptr ( Y * ptr ) ;
(3)
template < class Y, class Deleter >
shared_ptr ( Y * ptr, Deleter d ) ;
(4)
template < class Deleter >
shared_ptr ( std:: nullptr_t ptr, Deleter d ) ;
(5)
template < class Y, class Deleter, class Alloc >
shared_ptr ( Y * ptr, Deleter d, Alloc alloc ) ;
(6)
template < class Deleter, class Alloc >
shared_ptr ( std:: nullptr_t ptr, Deleter d, Alloc alloc ) ;
(7)
template < class Y >
shared_ptr ( const shared_ptr < Y > & r, element_type * ptr ) noexcept ;
(8)
shared_ptr ( const shared_ptr & r ) noexcept ;
(9)
template < class Y >
shared_ptr ( const shared_ptr < Y > & r ) noexcept ;
(9)
shared_ptr ( shared_ptr && r ) noexcept ;
(10)
template < class Y >
shared_ptr ( shared_ptr < Y > && r ) noexcept ;
(10)
template < class Y >
explicit shared_ptr ( const std:: weak_ptr < Y > & r ) ;
(11)
template < class Y >
shared_ptr ( std:: auto_ptr < Y > && r ) ;
(12)
template < class Y, class Deleter >
shared_ptr ( std:: unique_ptr < Y,Deleter > && r ) ;
(13)

Konstruiert einen neuen shared_ptr aus verschiedenen Zeigertypen, die auf ein zu verwaltendes Objekt verweisen.

Für die Zwecke der nachfolgenden Beschreibung wird ein Zeigertyp Y* als kompatibel mit einem Zeigertyp T* betrachtet, wenn entweder Y* in T* konvertierbar ist oder Y der Array-Typ U[N] ist und T gleich U cv [] ist (wobei cv eine Menge von CV-Qualifizierern darstellt).

1,2) Konstruiert einen shared_ptr ohne verwaltetes Objekt, d.h. einen leeren shared_ptr .
3-7) Konstruiert einen shared_ptr mit ptr als Zeiger auf das verwaltete Objekt. Wenn T ein Array-Typ U[N] ist, muss Y(*)[N] konvertierbar zu T* sein. Wenn T ein Array-Typ U[] ist, muss Y(*)[] konvertierbar zu T* sein. Andernfalls muss Y* konvertierbar zu T* sein. Zusätzlich:
3) Verwendet einen delete-expression ( delete ptr , falls T kein Array-Typ ist; delete [ ] ptr falls T ein Array-Typ ist) als Deleter. Y muss ein vollständiger Typ sein. Dieser delete-Ausdruck muss wohlgeformt sein, wohldefiniertes Verhalten aufweisen und keine Ausnahmen werfen.
4,5) Verwendet den angegebenen Deleter d als Deleter. Der Ausdruck d ( ptr ) muss wohlgeformt sein, wohldefiniertes Verhalten aufweisen und keine Ausnahmen werfen. Deleter muss CopyConstructible sein, und sein Kopierkonstruktor und Destruktor dürfen keine Ausnahmen werfen.
6,7) Gleich wie (4,5) , verwendet jedoch zusätzlich eine Kopie von alloc für die Allokation von Daten für interne Verwendung. Alloc muss ein Allocator sein, und sein Kopierkonstruktor sowie Destruktor dürfen keine Ausnahmen werfen.
8) Der Aliasing-Konstruktor : Konstruiert einen shared_ptr , der Besitzinformationen mit r teilt, aber einen unabhängigen und nicht verwalteten Zeiger ptr hält. Selbst wenn dieser shared_ptr der letzte der Gruppe ist, der den Gültigkeitsbereich verlässt, wird er den Destruktor für das ursprünglich von r verwaltete Objekt aufrufen. Allerdings gibt ein Aufruf von get() hier stets eine Kopie von ptr zurück. Es liegt in der Verantwortung des Programmierers, sicherzustellen, dass dieser ptr solange gültig bleibt, wie dieser shared_ptr existiert, wie in den typischen Anwendungsfällen, in denen ptr ein Member des von r verwalteten Objekts ist oder ein Alias (z.B. Downcast) von r. get ( ) .
9) Konstruiert einen shared_ptr , der die Eigentümerschaft des von r verwalteten Objekts teilt. Falls r kein Objekt verwaltet, verwaltet auch * this kein Objekt. Die Template-Überladung nimmt nicht an der Überladungsauflösung teil, wenn Y* nicht kompatibel mit T* ist.
10) Move-konstruiert einen shared_ptr aus r . Nach der Konstruktion enthält * this eine Kopie des vorherigen Zustands von r , r ist leer. Die Template-Überladung nimmt nicht an der Überladungsauflösung teil, wenn Y* nicht kompatibel mit T* ist.
11) Konstruiert einen shared_ptr , der die Eigentümerschaft des durch r verwalteten Objekts teilt. Y* muss kompatibel mit T* sein. Beachten Sie, dass r. lock ( ) für denselben Zweck verwendet werden kann: Der Unterschied besteht darin, dass dieser Konstruktor eine Ausnahme auslöst, wenn das Argument leer ist, während weak_ptr < T > :: lock ( ) in diesem Fall einen leeren shared_ptr konstruiert.
12) Konstruiert einen shared_ptr , der das zuvor von r verwaltete Objekt speichert und besitzt. Y* muss in T* konvertierbar sein. Nach der Konstruktion ist r leer.
13) Konstruiert einen shared_ptr , der das Objekt verwaltet, das aktuell von r verwaltet wird. Der mit r assoziierte Deleter wird für die zukünftige Löschung des verwalteten Objekts gespeichert. r verwaltet nach dem Aufruf kein Objekt mehr. Diese Überladung nimmt nicht an der Überladungsauflösung teil, wenn Y* nicht kompatibel mit T* ist.
Wenn D ein Referenztyp ist, entspricht dies shared_ptr ( r. release ( ) , std:: ref ( r. get_deleter ( ) ) . Andernfalls entspricht es shared_ptr ( r. release ( ) , r. get_deleter ( ) ) .

Inhaltsverzeichnis

Hinweise

Beim Erstellen eines shared_ptr aus einem rohen Zeiger auf ein Objekt eines von std::experimental::enable_shared_from_this abgeleiteten Typs aktualisieren die Konstruktoren von shared_ptr das private weak_ptr -Mitglied der std::experimental::enable_shared_from_this -Basis, sodass zukünftige Aufrufe von shared_from_this() die Eigentümerschaft mit dem durch diesen Rohzeiger-Konstruktor erstellten shared_ptr teilen würden.

Die Überladungen für Rohzeiger übernehmen die Eigentümerschaft des gezeigten Objekts, und daher kann die Konstruktion eines shared_ptr unter Verwendung der Rohzeiger-Überladung für ein Objekt, das bereits von einem shared_ptr verwaltet wird, zu undefiniertem Verhalten führen, selbst wenn das Objekt von einem Typ ist, der von std::experimental::enable_shared_from_this abgeleitet ist.

Parameter

ptr - ein Zeiger auf ein zu verwaltendes Objekt
d - ein Deleter zur Zerstörung des Objekts
alloc - ein Allokator für interne Speicherallokationen
r - ein weiterer Smart Pointer zur gemeinsamen Nutzung oder Übernahme der Eigentümerschaft

Ausnahmen

3) std::bad_alloc falls der erforderliche zusätzliche Speicher nicht beschafft werden konnte. Kann implementationsdefinierte Ausnahmen für andere Fehler werfen. Der zutreffende delete-Ausdruck ( delete ptr falls T kein Array-Typ ist, delete [ ] ptr andernfalls) wird aufgerufen, falls eine Ausnahme auftritt.
4-7) std::bad_alloc wenn der benötigte zusätzliche Speicher nicht beschafft werden konnte. Kann implementationsdefinierte Ausnahmen für andere Fehler werfen. d ( ptr ) wird aufgerufen, falls eine Ausnahme auftritt.
11) std::bad_weak_ptr wenn r. expired ( ) == true . Der Konstruktor hat in diesem Fall keine Auswirkung.
12) std::bad_alloc falls die benötigte zusätzliche Speichermenge nicht beschafft werden konnte. Kann implementationsdefinierte Ausnahmen für andere Fehler werfen. Dieser Konstruktor hat keine Wirkung, wenn eine Ausnahme auftritt.
13) Wenn eine Exception ausgelöst wird, hat der Konstruktor keine Auswirkungen.

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

Siehe auch

(C++20)
Erstellt einen Shared Pointer, der ein neues Objekt verwaltet
(Funktions-Template)
(C++20)
Erstellt einen Shared Pointer, der ein neues Objekt verwaltet, das mit einem Allokator alloziert wurde
(Funktions-Template)