Namensräume
Varianten
Aktionen

std::out_ptr_t

Von cppreference.com
< cpp‎ | memory
 
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::out_ptr_t
 
Definiert in Header <memory>
template< class Smart, class Pointer, class... Args >
class out_ptr_t;
 (seit C++23)

out_ptr_t wird verwendet, um Typen wie Smart Pointers für externe Funktionen anzupassen, die ihre Ergebnisse über einen Pointer* (üblicherweise T** für einen beliebigen Objekttyp T) oder einen void** Parameter ausgeben.

out_ptr_t erfasst beim Konstruieren zusätzliche Argumente, stellt Speicher für das Ergebnis bereit, in das eine der oben genannten externen Funktionen schreibt, und setzt schließlich das angepasste Smart-Objekt beim Zerstören mit dem Ergebnis und den erfassten Argumenten zurück.

out_ptr_t verhält sich so, als ob es folgende nicht-statische Datenmember hätte:

  • eine Referenz vom Typ Smart&, die beim Konstruieren an das angepasste Objekt gebunden wird,
  • für jedes T in Args... ein Member vom Typ T, der beim Konstruieren als Argument erfasst und beim Zerstören zum Zurücksetzen verwendet wird, und
  • ein Subobjekt, das geeignet ist, einen Pointer darin zu speichern und ein Objekt vom Typ void* bereitzustellen, wobei das Pointer- oder void*-Objekt im Allgemeinen einer externen Funktion zur Reinitialisierung ausgesetzt wird.

Benutzer können steuern, ob jedes Argument zum Zurücksetzen per Kopie oder per Referenz erfasst wird, indem sie jeweils einen Objekttyp oder einen Referenztyp in Args... angeben.

Inhalt

[edit] Template-Parameter

Smart - der Typ des Objekts (typischerweise ein Smart Pointer), das angepasst werden soll
Zeiger - der Typ des Objekts (typischerweise ein Rohzeiger), in das eine externe Funktion ihr Ergebnis schreibt
Args... - der Typ der erfassten Argumente, die zum Zurücksetzen des angepassten Objekts verwendet werden
Typanforderungen
-
Pointer muss die Anforderungen von NullablePointer erfüllen.
-
Das Programm ist schlecht formuliert, wenn Smart eine std::shared_ptr-Spezialisierung ist und sizeof...(Args) == 0.

[edit] Spezialisierungen

Im Gegensatz zu den meisten Klassentemplates in der Standardbibliothek müssen program-definierte Spezialisierungen von out_ptr_t, die von mindestens einem program-definierten Typ abhängen, nicht die Anforderungen des Primär-Templates erfüllen.

Diese Lizenz erlaubt es einer program-definierten Spezialisierung, den innerhalb eines nicht-standardmäßigen Smart Pointers gespeicherten Rohzeiger für externe Funktionen offenzulegen.

[edit] Member-Funktionen

(C++23)
 konstruiert ein out_ptr_t
(öffentliche Memberfunktion)
operator=
[deleted](C++23)
 out_ptr_t ist nicht zuweisbar
(öffentliche Memberfunktion)
(C++23)
 setzt den angepassten Smart Pointer zurück
(öffentliche Memberfunktion)
(C++23)
 konvertiert das out_ptr_t in die Adresse des Speichers für die Ausgabe
(öffentliche Memberfunktion)

[edit] Nicht-Member-Funktionen

(C++23)
 erstellt einen out_ptr_t mit einem zugehörigen intelligenten Zeiger und Zurücksetzungsargumenten
(Funktions-Template) [edit]

[edit] Hinweise

out_ptr_t geht davon aus, dass die externen Funktionen den Wert des zeigenden Pointer nicht verwenden und ihn nur neu initialisieren. Der Wert des Smart Pointers vor der Anpassung wird nicht verwendet.

Die typische Verwendung von out_ptr_t ist die Erstellung seiner temporären Objekte durch std::out_ptr, was den angepassten Smart Pointer sofort zurücksetzt. Z.B. gegeben eine Setter-Funktion und ein Smart Pointer vom entsprechenden Typ, deklariert mit int foreign_setter(T**); und std::unique_ptr<T, D> up; jeweils,

int foreign_setter(T**);
std::unique_ptr<T, D> up;
 
if (int ec = foreign_setter(std::out_ptr(up)))
    return ec;

ist ungefähr äquivalent zu

int foreign_setter(T**);
std::unique_ptr<T, D> up;
T* raw_p{};
 
int ec = foreign_setter(&raw_p);
up.reset(raw_p);
if (ec != 0)
    return ec;

Es wird nicht empfohlen, ein out_ptr_t-Objekt mit einer anderen Speicherdauer als der automatischen Speicherdauer zu erstellen, da ein solcher Code wahrscheinlich zu hängenden Referenzen führt und beim Zerstören zu undefiniertem Verhalten resultiert.

out_ptr_t verbietet die Verwendung, die einen std::shared_ptr zurücksetzen würde, ohne einen Deleter anzugeben, da dies std::shared_ptr::reset aufrufen und später einen benutzerdefinierten Deleter ersetzen würde.

Erfasste Argumente werden typischerweise in ein std::tuple<Args...> gepackt. Implementierungen können unterschiedliche Mechanismen verwenden, um das Objekt vom Typ Pointer oder void* bereitzustellen, das sie speichern müssen.

Feature-Test-Makro Wert Std Feature
__cpp_lib_out_ptr 202106L (C++23) std::out_ptr, std::inout_ptr
202311L (C++26) freistehendes std::out_ptr und std::inout_ptr

[edit] Beispiel

Dieser Abschnitt ist unvollständig
Grund: kein Beispiel

[edit] Siehe auch

(C++23)
 interagiert mit externen Zeiger-Setzern, ermittelt den anfänglichen Zeigerwert aus einem intelligenten Zeiger und setzt ihn bei der Zerstörung zurück
(Klassen-Template) [edit]
(C++11)
 intelligenter Zeiger mit semantisch eindeutigem Objektbesitz
(Klassen-Template) [edit]
(C++11)
 intelligenter Zeiger mit semantisch geteiltem Objektbesitz
(Klassen-Template) [edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/out_ptr_t&oldid=170141"