unique_ptr-Klasse
Es wird ein Zeiger auf ein im Besitz befindliches Objekt oder Array gespeichert. Das Objekt/Array ist nicht im Besitz eines anderen unique_ptr-Elements. Das Objekt/Array wird zerstört, wenn unique_ptr zerstört wird.
Syntax
class unique_ptr {
public:
unique_ptr();
unique_ptr(nullptr_t Nptr);
explicit unique_ptr(pointer Ptr);
unique_ptr(pointer Ptr,
typename conditional<is_reference<Del>::value, Del,
typename add_reference<const Del>::type>::type Deleter);
unique_ptr(pointer Ptr,
typename remove_reference<Del>::type&& Deleter);
unique_ptr(unique_ptr&& Right);
template <class T2, Class Del2>
unique_ptr(unique_ptr<T2, Del2>&& Right);
unique_ptr(const unique_ptr& Right) = delete;
unique_ptr& operator=(const unique_ptr& Right) = delete;
};
//Specialization for arrays:
template <class T, class D>
class unique_ptr<T[], D> {
public:
typedef pointer;
typedef T element_type;
typedef D deleter_type;
constexpr unique_ptr() noexcept;
template <class U>
explicit unique_ptr(U p) noexcept;
template <class U>
unique_ptr(U p, see below d) noexcept;
template <class U>
unique_ptr(U p, see below d) noexcept;
unique_ptr(unique_ptr&& u) noexcept;
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { } template <class U, class E>
unique_ptr(unique_ptr<U, E>&& u) noexcept;
~unique_ptr();
unique_ptr& operator=(unique_ptr&& u) noexcept;
template <class U, class E>
unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
unique_ptr& operator=(nullptr_t) noexcept;
T& operator[](size_t i) const;
pointer get() const noexcept;
deleter_type& get_deleter() noexcept;
const deleter_type& get_deleter() const noexcept;
explicit operator bool() const noexcept;
pointer release() noexcept;
void reset(pointer p = pointer()) noexcept;
void reset(nullptr_t = nullptr) noexcept;
template <class U>
void reset(U p) noexcept = delete;
void swap(unique_ptr& u) noexcept; // disable copy from lvalue unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
};
Parameter
Right
Ein unique_ptr.
Nptr
Ein rvalue vom Typ std::nullptr_t.
Ptr
Ein pointer.
Deleter
Eine deleter-Funktion, die an unique_ptr gebunden ist.
Ausnahmen
Es werden keine Ausnahmen von unique_ptr generiert.
Hinweise
Die unique_ptr-Klasse löst auto_ptr ab und kann als Element von C++Standardbibliothek-Containern verwendet werden.
Verwenden Sie die make_unique Hilfsfunktion, um effizient neue Instanzen von unique_ptr.
unique_ptr verwaltet eine Ressource eindeutig. Jedes unique_ptr-Objekt speichert einen Zeiger auf das Objekt, das es besitzt, oder speichert einen NULL-Zeiger. Es kann höchstens ein unique_ptr-Objekt eine Ressource besitzen. Wird ein unique_ptr-Objekt, das eine bestimmte Ressource besitzt, zerstört, wird die Ressource freigegeben. Ein unique_ptr Objekt kann verschoben, aber nicht kopiert werden. Weitere Informationen finden Sie unter Rvalue Reference Declarator: &&.
Die Ressource wird freigegeben, indem ein gespeichertes deleter-Objekt vom Typ Del aufgerufen wird, dem bekannt ist, wie Ressourcen für ein bestimmtes unique_ptr-Objekt zugeordnet werden. Der standardmäßige deleterdefault_delete<T> geht davon aus, dass die Ressource, auf die ptr zeigt, new zugeordnet wird und dass sie freigegeben werden kann, indem delete _Ptr aufgerufen wird. (Eine Partialspezialisierung unique_ptr<T[]>verwaltet Arrayobjekte, die zugeordnet new[]sind, und verfügt über die Standardeinstellung deleterdefault_delete<T[]>, die speziell für den Aufruf delete[] ptrvon .)
Der gespeicherte Zeiger auf eine zugehörige Ressource stored_ptr ist vom Typ pointer. Del::pointer Wenn sie definiert ist und T * nicht. Das gespeicherte deleter-Objekt stored_deleter belegt keinen Speicherplatz im Objekt, wenn deleter zustandslos ist. Beachten Sie, dass Del ein Verweistyp sein kann.
Member
Konstruktoren
| Name | Beschreibung |
|---|---|
unique_ptr |
Es gibt sieben Konstruktoren für unique_ptr. |
TypeDefs
| Name | Beschreibung |
|---|---|
deleter_type |
Ein Synonym für den Vorlagenparameter Del. |
element_type |
Ein Synonym für den Vorlagenparameter T. |
pointer |
Ein Synonym für Del::pointer, wenn der Wert definiert ist; andernfalls T *. |
Funktionen
| Name | Beschreibung |
|---|---|
get |
Gibt stored_ptr zurück. |
get_deleter |
Gibt einen Verweis auf stored_deleterzurück. |
release |
speichert pointer() in stored_ptr und gibt seinen vorherigen Inhalt zurück. |
reset |
Gibt die zurzeit zugehörige Ressource frei und akzeptiert eine neue Ressource. |
swap |
Tauscht die Ressource und deleter mit dem bereitgestellten unique_ptr-Objekt aus. |
Operatoren
| Name | Beschreibung |
|---|---|
operator bool |
Der Operator gibt einen Wert eines Typs zurück, der in bool konvertiert werden kann. Das Ergebnis der Konvertierung in bool ist true, wenn get() != pointer(), andernfalls false. |
operator-> |
Die Memberfunktion gibt stored_ptr zurück. |
operator* |
Die Memberfunktion gibt *stored_ptr zurück. |
operator= |
Weist den Wert eines unique_ptr (oder eines pointer-type) dem aktuellen unique_ptr zu. |
deleter_type
Der Type stellt ein Synonym für den Vorlagenparameter Deldar.
typedef Del deleter_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Deldar.
element_type
Der Type stellt ein Synonym für den Vorlagenparameter Typedar.
typedef Type element_type;
Hinweise
Der Type stellt ein Synonym für den Vorlagenparameter Tydar.
get
Gibt stored_ptr zurück.
pointer get() const;
Hinweise
Die Memberfunktion gibt stored_ptr zurück.
get_deleter
Gibt einen Verweis auf stored_deleterzurück.
Del& get_deleter();
const Del& get_deleter() const;
Hinweise
Die Memberfunktion gibt einen Verweis auf stored_deleter zurück.
operator=
Weist die Adresse des bereitgestellten unique_ptr-Objekts dem aktuellen Objekt zu.
unique_ptr& operator=(unique_ptr&& right);
template <class U, Class Del2>
unique_ptr& operator=(unique_ptr<Type, Del>&& right);
unique_ptr& operator=(pointer-type);
Parameter
Ein unique_ptr-Verweis, der verwendet wird, um den Wert des aktuellen unique_ptr-Objekts zuzuweisen.
Hinweise
Die Memberfunktionen rufen reset(right.release()) auf, verschieben right.stored_deleter zu stored_deleter und geben dann *this zurück.
pointer
Ein Synonym für Del::pointer, wenn der Wert definiert ist; andernfalls Type *.
typedef T1 pointer;
Hinweise
Der Typ ist ein Synonym für Del::pointer, sofern dieser definiert ist; andernfalls Type *.
release
Gibt den Besitz des zurückgegebenen gespeicherten Zeigers für den Aufrufer frei und legt den Wert des gespeicherten Zeigers auf nullptr fest.
pointer release();
Hinweise
Verwenden Sie release, um den Besitz des von unique_ptr gespeicherten unformatierten Zeigers zu übernehmen. Der Aufrufer ist für das Löschen des zurückgegebenen Zeigers verantwortlich. unique-ptr wird in seinen leeren, standardmäßig konstruierten Zustand gesetzt. Sie können unique_ptr einen anderen Zeiger mit kompatiblem Typ nach dem Aufruf von release zuweisen.
Beispiel
Dieses Beispiel zeigt, inwiefern der Aufrufer von „release“ für das zurückgegebene Objekt verantwortlich ist:
// stl_release_unique.cpp
// Compile by using: cl /W4 /EHsc stl_release_unique.cpp
#include <iostream>
#include <memory>
struct Sample {
int content_;
Sample(int content) : content_(content) {
std::cout << "Constructing Sample(" << content_ << ")" << std::endl;
}
~Sample() {
std::cout << "Deleting Sample(" << content_ << ")" << std::endl;
}
};
void ReleaseUniquePointer() {
// Use make_unique function when possible.
auto up1 = std::make_unique<Sample>(3);
auto up2 = std::make_unique<Sample>(42);
// Take over ownership from the unique_ptr up2 by using release
auto ptr = up2.release();
if (up2) {
// This statement does not execute, because up2 is empty.
std::cout << "up2 is not empty." << std::endl;
}
// We are now responsible for deletion of ptr.
delete ptr;
// up1 deletes its stored pointer when it goes out of scope.
}
int main() {
ReleaseUniquePointer();
}
Constructing Sample(3)
Constructing Sample(42)
Deleting Sample(42)
Deleting Sample(3)
reset
Übernimmt den Besitz des Zeigerparameters und löscht dann den ursprünglich gespeicherten Zeiger. Wenn der neue Zeiger mit dem ursprünglich gespeicherten Zeiger identisch ist, löscht reset den Zeiger und legt den gespeicherten Zeiger auf nullptr fest.
void reset(pointer ptr = pointer());
void reset(nullptr_t ptr);
Parameter
ptr
Ein Zeiger auf die Ressource, deren Besitz übernommen werden soll.
Hinweise
Dient reset zum Ändern des gespeicherten pointer Besitzes im Besitz des unique_ptrPtr-Steuerelements , und löschen Sie dann den ursprünglich gespeicherten Zeiger. Wenn die unique_ptr Funktion nicht leer war, wird die Löschfunktion aufgerufen, reset die vom get_deleter ursprünglich gespeicherten Zeiger zurückgegeben wird.
Da reset zuerst der neue Zeiger ptrgespeichert und dann der ursprüngliche gespeicherte Zeiger gelöscht wird, ist es möglich reset , sofort zu löschen ptr , wenn er mit dem ursprünglich gespeicherten Zeiger identisch ist.
swap
Tauscht Zeiger zwischen zwei unique_ptr-Objekten aus.
void swap(unique_ptr& right);
Parameter
right
Ein unique_ptr-Objekt, das zum Tauschen von Zeigern verwendet wird.
Hinweise
Die Memberfunktion tauscht stored_ptr mit right.stored_ptr und stored_deleter mit right.stored_deleter.
unique_ptr
Es gibt sieben Konstruktoren für unique_ptr.
unique_ptr();
unique_ptr(nullptr_t);
explicit unique_ptr(pointer ptr);
unique_ptr(
Type* ptr,
typename conditional<
is_reference<Del>::value,
Del,
typename add_reference<const Del>::type>::type _Deleter);
unique_ptr(pointer ptr, typename remove_reference<Del>::type&& _Deleter);
unique_ptr(unique_ptr&& right);
template <class Ty2, Class Del2>
unique_ptr(unique_ptr<Ty2, Del2>&& right);
Parameter
ptr
Ein Zeiger auf die Ressource, die einem unique_ptrzugeordnet werden soll.
_Deleter
Eine deleter-Funktion, die einem unique_ptr-Objekt zugewiesen werden soll.
right
Eine rvalue reference auf ein unique_ptr-Objekt, aus dem unique_ptr-Felder dem neu erstellten unique_ptr-Objekt zugewiesen werden.
Hinweise
Die ersten beiden Konstruktoren erstellen ein Objekt, das keine Ressource verwaltet. Der dritte Konstruktor speichert ptr in stored_ptr. Der vierte Konstruktor speichert ptr in stored_ptr und deleter in stored_deleter.
Der fünfte Konstruktor speichert ptr in stored_ptr und verschiebt deleter in stored_deleter. Der sechste und der siebte Konstruktor speichern right.release() in stored_ptr und verschieben right.get_deleter() in stored_deleter.
~unique_ptr
Der Destruktor für unique_ptr zerstört ein unique_ptr-Objekt.
~unique_ptr();
Hinweise
Der Destruktor ruft get_deleter()(stored_ptr) auf.
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für