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 Standardwert deleter default_delete<T> geht davon aus, dass die ressource, auf ptr die verwiesen wird, zugeordnet newist und dass sie durch Aufrufen delete _Ptrfreigegeben werden kann. (Eine Partialspezialisierung unique_ptr<T[]>verwaltet Arrayobjekte, die zugeordnet new[]sind, und verfügt über die Standardeinstellung deleter default_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

TypeDefs

Functions

Operatoren

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_ptr Ptr-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.