Namensräume
Varianten
Aktionen

std::inout_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::inout_ptr_t
 
Definiert in Header <memory>
template< class Smart, class Pointer, class... Args >
class inout_ptr_t;
 (seit C++23)

inout_ptr_t wird verwendet, um Typen wie Smart Pointern für Fremdfunktionen anzupassen, die den Besitz über einen Pointer* (normalerweise T** für einen Objektetyp T) oder einen void** Parameter zurücksetzen.

inout_ptr_t erfasst beim Konstruieren zusätzliche Argumente, stellt einen Speicher für das Ergebnis bereit, auf den die oben erwähnte Fremdfunktion zugreift, gibt den Besitz des angepassten Smart-Objekts frei und setzt schließlich das angepasste Smart-Objekt beim Zerstören mit dem Ergebnis und den erfassten Argumenten zurück.

inout_ptr_t verhält sich so, als ob es die folgenden nicht-statischen Datenmember hätte

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

Wenn Smart kein Zeigertyp ist, wird release() höchstens einmal für das angepasste Objekt aufgerufen. Implementierungen können release() im Konstruktor oder vor dem Zurücksetzen im Destruktor aufrufen, wenn der Pointer-Wert nicht null ist.

Benutzer können steuern, ob jedes Argument für das Zurücksetzen per Kopie oder per Referenz erfasst wird, indem sie entsprechend 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 - Typ des Objekts (typischerweise ein roher Zeiger), auf das eine Fremdfunktion zum Zurücksetzen des Besitzes zugreift
Args... - 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 ill-formed, wenn Smart eine std::shared_ptr-Spezialisierung ist.

[edit] Spezialisierungen

Im Gegensatz zu den meisten Klassenschablonen in der Standardbibliothek müssen programmierdefinierte Spezialisierungen von inout_ptr_t, die von mindestens einem programmierdefinierten Typ abhängen, nicht die Anforderungen der Primärschablone erfüllen.

Diese Lizenz erlaubt es einer programmierdefinierten Spezialisierung, den rohen Zeiger, der in einem nicht standardmäßigen Smart Pointer gespeichert ist, für Fremdfunktionen zugänglich zu machen.

[edit] Member-Funktionen

(C++23)
 konstruiert ein inout_ptr_t
(öffentliche Memberfunktion)
operator=
[deleted](C++23)
 inout_ptr_t ist nicht zuweisbar
(öffentliche Memberfunktion)
(C++23)
 setzt den angepassten Smart Pointer zurück, nachdem sein Besitz freigegeben wurde
(öffentliche Memberfunktion)
(C++23)
 konvertiert den inout_ptr_t in die Adresse des Speichers für die Ausgabe
(öffentliche Memberfunktion)

[edit] Nicht-Member-Funktionen

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

[edit] Hinweise

inout_ptr_t erwartet, dass die Fremdfunktionen den durch den Wert des gezeigten Pointer repräsentierten Besitz freigeben und ihn dann neu initialisieren. Da eine solche Operation einzigartigen Besitz erfordert, ist die Verwendung mit std::shared_ptr verboten.

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

if (int ec = foreign_resetter(std::inout_ptr(up)))
    return ec;

ist ungefähr äquivalent zu

T *raw_p = up.get();
up.release();
int ec = foreign_resetter(&raw_p);
up.reset(raw_p);
if (ec != 0)
    return ec;

Es wird nicht empfohlen, ein inout_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 bei der Zerstörung zu undefiniertem Verhalten führt.

Erfasste Argumente werden typischerweise in ein std::tuple<Args...> gepackt. Implementierungen können unterschiedliche Mechanismen verwenden, um das Pointer- oder void*-Objekt 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 und setzt einen intelligenten Zeiger 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/inout_ptr_t&oldid=170143"