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 make_unique die Hilfsfunktion, um effizient neue Instanzen von zu unique_ptr erstellen.

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-Verweisdeklarator: && .

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 setzt voraus, dass die Ressource, auf die von zeigt, mit zugeordnet wird und dass sie durch Aufrufen deleter default_delete<T> von frei werden ptr new delete _Ptr kann. (Eine Teilspezialisierung verwaltet Arrayobjekte, die mit zugeordnet sind, und verfügt über unique_ptr<T[]> new[] die deleter default_delete<T[]> Standardspezialisierung, die auf den Aufruf von spezialisiert delete[] ptr ist.)

Der gespeicherte Zeiger auf eine zugehörige Ressource stored_ptr ist vom Typ pointer. Er lautet Del::pointer, wenn er definiert ist, und T *, wenn er nicht definiert ist. 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_ptrzurü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 konvertierbar bool ist. Das Ergebnis der Konvertierung in bool ist , wenn , true 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 Del dar.

typedef Del deleter_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Del dar.

element_type

Der Type stellt ein Synonym für den Vorlagenparameter Type dar.

typedef Type element_type;

Hinweise

Der Type stellt ein Synonym für den Vorlagenparameter Ty dar.

get

Gibt stored_ptrzurü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 und wechseln zu , und geben dann right.stored_deleter stored_deleter *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 auf den Aufrufer frei und legt den gespeicherten Zeigerwert 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ünglichen gespeicherten Zeiger identisch ist, löscht den Zeiger und legt reset 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

Verwenden Sie , um den gespeicherten im Besitz von in ptr zu ändern und dann reset pointer den ursprünglich unique_ptr gespeicherten Zeiger zu löschen. Wenn nicht unique_ptr leer war, ruft die deleter-Funktion auf, die von für reset get_deleter den ursprünglich gespeicherten Zeiger zurückgegeben wurde.

Da zuerst den neuen Zeiger speichert und dann den ursprünglich gespeicherten Zeiger löscht, ist es möglich, sofort zu löschen, wenn er mit dem ursprünglich gespeicherten reset ptr Zeiger identisch reset ptr 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 zugewiesen werden unique_ptr 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 in deleter stored_deleter .

Der fünfte Konstruktor speichert ptr in und wechselt in stored_ptr deleter 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.