Sdílet prostřednictvím

unique_ptr Třída

Uloží ukazatel na vlastněný objekt nebo pole. Objekt/pole vlastní žádný jiný unique_ptr. Objekt nebo pole je zničen při unique_ptr zničení.

Syntaxe

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;
};

Parametry

Right
Úloha unique_ptr.

Nptr
std::nullptr_tTyp rvalue .

Ptr
Úloha pointer.

Deleter
Funkcedeleter, která je vázána na .unique_ptr

Výjimky

Nejsou generovány unique_ptržádné výjimky .

Poznámky

Třída unique_ptr nahrazuje auto_ptra lze ji použít jako prvek kontejnerů standardní knihovny jazyka C++.

make_unique Pomocí pomocné funkce efektivně vytvářet nové instance unique_ptr.

unique_ptr jednoznačně spravuje prostředek. Každý unique_ptr objekt ukládá ukazatel na objekt, který vlastní, nebo ukládá ukazatel null. Prostředek může vlastnit maximálně jeden unique_ptr objekt. Když unique_ptr dojde ke zničení objektu, který vlastní určitý prostředek, uvolní se prostředek. Objekt unique_ptr lze přesunout, ale ne zkopírovat; další informace naleznete v tématu Deklarátor odkazu Rvalue: &&.

Prostředek je uvolněn voláním uloženého deleter objektu typu Del , který ví, jak jsou prostředky přiděleny pro konkrétní unique_ptr. Ve výchozím nastavení deleter default_delete<T> se předpokládá, že zdroj, na který odkazuje, ptr je přidělen pomocí newa že jej lze uvolnit voláním delete _Ptr. (Částečná specializace unique_ptr<T[]>spravuje objekty pole přidělené new[]a má výchozí deleter default_delete<T[]>, specializované na volání delete[] ptr.)

Uložený ukazatel na vlastněný prostředek stored_ptr má typ pointer. Del::pointer Je-li definován, a T * pokud ne. Uložený deleter objekt stored_deleter nezabývá v objektu žádné místo, pokud je bezstavová deleter . Všimněte si, že Del jde o odkazový typ.

Členové

Konstruktory

Název Popis
unique_ptr Existuje sedm konstruktorů pro unique_ptr.

Typedefs

Název Popis
deleter_type Synonymum pro parametr Delšablony .
element_type Synonymum pro parametr Tšablony .
pointer Synonymum pro Del::pointer , pokud je definováno, jinak T *.

Funkce

Název Popis
get Vrací objekt stored_ptr.
get_deleter Vrátí odkaz na stored_deleter.
release stored_ptr ukládá pointer() a vrací svůj předchozí obsah.
reset Uvolní aktuálně vlastněný prostředek a přijme nový prostředek.
swap Vymění zdroj a deleter s poskytnutým unique_ptr.

Operátory

Název Popis
operator bool Operátor vrátí hodnotu typu, který je konvertibilní na bool. Výsledek převodu na bool je,pokud get() != pointer()true , jinak false.
operator-> Členová funkce vrátí stored_ptr.
operator* Členová funkce vrátí *stored_ptr.
operator= Přiřadí hodnotu unique_ptr (nebo pointer-type) aktuálnímu unique_ptr.

deleter_type

Typ je synonymem pro parametr Delšablony .

typedef Del deleter_type;

Poznámky

Typ je synonymem pro parametr Delšablony .

element_type

Typ je synonymem pro parametr Typešablony .

typedef Type element_type;

Poznámky

Typ je synonymem pro parametr Tyšablony .

get

Vrací objekt stored_ptr.

pointer get() const;

Poznámky

Členová funkce vrátí stored_ptr.

get_deleter

Vrátí odkaz na stored_deleter.

Del& get_deleter();

const Del& get_deleter() const;

Poznámky

Členová funkce vrátí odkaz na stored_deleter.

operator=

Přiřadí adresu zadané unique_ptr hodnoty aktuálnímu.

unique_ptr& operator=(unique_ptr&& right);
template <class U, Class Del2>
unique_ptr& operator=(unique_ptr<Type, Del>&& right);
unique_ptr& operator=(pointer-type);

Parametry

unique_ptr Odkaz použitý k přiřazení hodnoty k aktuálnímu unique_ptr.

Poznámky

Členské funkce volají reset(right.release()) a přesouvají right.stored_deleter se do stored_deletera pak se vrátí *this.

pointer

Synonymum pro Del::pointer , pokud je definováno, jinak Type *.

typedef T1 pointer;

Poznámky

Typ je synonymem pro Del::pointer , pokud je definován, jinak Type *.

release

Uvolní vlastnictví vráceného uloženého ukazatele na volajícího a nastaví uloženou hodnotu ukazatele na nullptr.

pointer release();

Poznámky

Slouží release k převzetí vlastnictví nezpracovaného ukazatele uloženého uživatelem unique_ptr. Volající zodpovídá za odstranění vráceného ukazatele. Je unique-ptr nastavena na prázdný výchozí konstruovaný stav. Můžete přiřadit další ukazatel kompatibilního typu po unique_ptr volání release.

Příklad

Tento příklad ukazuje, jak volající vydané verze zodpovídá za vrácený objekt:

// 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

Převezme vlastnictví parametru ukazatele a odstraní původní uložený ukazatel. Pokud je nový ukazatel stejný jako původní uložený ukazatel, reset odstraní ukazatel a nastaví uložený ukazatel na nullptr.

void reset(pointer ptr = pointer());
void reset(nullptr_t ptr);

Parametry

ptr
Ukazatel na prostředek, který má převzít vlastnictví.

Poznámky

Slouží reset ke změně uloženého uloženého objektu unique_ptr pointer ptr a následnému odstranění původního uloženého ukazatele. unique_ptr Pokud nebyl prázdný, reset vyvolá funkci deleteru vrácenou původním uloženým ukazatelemget_deleter.

Protože reset nejprve uloží nový ukazatel a odstraní původní uložený ukazatel ptr, je možné reset jej okamžitě odstranit ptr , pokud je stejný jako původní uložený ukazatel.

swap

Vyměňuje ukazatele mezi dvěma unique_ptr objekty.

void swap(unique_ptr& right);

Parametry

right
Používá unique_ptr se k prohození ukazatelů.

Poznámky

Členová funkce se prohodí stored_ptr s right.stored_ptr a stored_deleter s right.stored_deleter.

unique_ptr

Existuje sedm konstruktorů pro 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);

Parametry

ptr
Ukazatel na zdroj, který má být přiřazen k unique_ptr.

_Deleter
Adeleter, která má být přiřazena k .unique_ptr

right
Na rvalue reference pole unique_ptr , ze kterých unique_ptr jsou pole přiřazena k nově vytvořenému unique_ptrobjektu .

Poznámky

První dva konstruktory vytvoří objekt, který nespravuje žádný prostředek. Třetí konstruktor ukládá ptr do stored_ptr. Čtvrtý konstruktor ukládá ptr do stored_ptr a deleter do stored_deleter.

Pátý konstruktor ukládá ptr a stored_ptr přesouvá deleter do stored_deleter. Šestý a sedmý konstruktor ukládá right.release() a stored_ptr přechází right.get_deleter() do stored_deleter.

~unique_ptr

Destruktor pro unique_ptr, zničí unique_ptr objekt.

~unique_ptr();

Poznámky

Destruktor volá get_deleter()(stored_ptr).

  • Last updated on