unique_ptr Klasa

Przechowuje wskaźnik do należącego obiektu lub tablicy. Obiekt/tablica nie jest własnością innego unique_ptrobiektu . Obiekt/tablica jest niszczona, gdy unique_ptr obiekt zostanie zniszczony.

Składnia

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
Klasa unique_ptr.

Nptr
std::nullptr_tTyp rvalue .

Ptr
Klasa pointer.

Deleter
deleter Funkcja powiązana z elementem unique_ptr.

Wyjątki

Żadne wyjątki nie są generowane przez program unique_ptr.

Uwagi

Klasa unique_ptr zastępuje auto_ptrklasę i może być używana jako element kontenerów biblioteki standardowej języka C++.

make_unique Użyj funkcji pomocnika, aby efektywnie tworzyć nowe wystąpienia programu unique_ptr.

unique_ptr unikatowo zarządza zasobem. Każdy unique_ptr obiekt przechowuje wskaźnik do obiektu, którego jest właścicielem lub przechowuje wskaźnik o wartości null. Zasób może być własnością nie więcej niż jednego unique_ptr obiektu; gdy unique_ptr obiekt będący właścicielem określonego zasobu zostanie zniszczony, zasób zostanie zwolniony. Obiekt unique_ptr może zostać przeniesiony, ale nie skopiowany. Aby uzyskać więcej informacji, zobacz Rvalue Reference Deklarator: &&.

Zasób jest zwalniany przez wywołanie przechowywanego deleter obiektu typu Del , który wie, jak zasoby są przydzielane dla określonego unique_ptrelementu . Domyślnie deleter default_delete<T> zakłada się, że zasób wskazywany przez ptr element jest przydzielany za pomocą newelementu i że można go zwolnić przez wywołanie metody delete _Ptr. (Częściowa specjalizacja unique_ptr<T[]>zarządza obiektami tablicy przydzielonymi za pomocą new[], i ma domyślną deleter default_delete<T[]>, wyspecjalizowaną do wywoływania delete[] ptr).

Przechowywany wskaźnik do zasobu należącego do niego ma stored_ptr typ pointer. Jest Del::pointer to wartość zdefiniowana, a T * jeśli nie. deleter Przechowywany obiekt stored_deleter nie zajmuje miejsca w obiekcie, jeśli deleter obiekt jest bezstanowy. Należy pamiętać, że Del może to być typ odwołania.

Elementy członkowskie

Konstruktory

Typedefs

Funkcje

Operatory

deleter_type

Typ jest synonimem parametru Delszablonu .

typedef Del deleter_type;

Uwagi

Typ jest synonimem parametru Delszablonu .

element_type

Typ jest synonimem parametru Typeszablonu .

typedef Type element_type;

Uwagi

Typ jest synonimem parametru Tyszablonu .

get

Zwraca wartość stored_ptr.

pointer get() const;

Uwagi

Funkcja składowa zwraca wartość stored_ptr.

get_deleter

Zwraca odwołanie do stored_deleter.

Del& get_deleter();

const Del& get_deleter() const;

Uwagi

Funkcja składowa zwraca odwołanie do stored_deleterelementu .

operator=

Przypisuje adres podanego unique_ptr do bieżącego.

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

Odwołanie unique_ptr użyte do przypisania wartości do bieżącego unique_ptrelementu .

Uwagi

Funkcje składowe wywołają metodę reset(right.release()) i przeniosą się right.stored_deleter do stored_deletermetody , a następnie zwracają wartość *this.

pointer

Synonim , jeśli Del::pointer jest zdefiniowany, w przeciwnym razie Type *.

typedef T1 pointer;

Uwagi

Typ jest synonimem , Del::pointer jeśli jest zdefiniowany, w przeciwnym razie Type *.

release

Zwalnia własność zwróconego wskaźnika przechowywanego do obiektu wywołującego i ustawia wartość przechowywanego wskaźnika na nullptr.

pointer release();

Uwagi

Użyj release polecenia , aby przejąć własność nieprzetworzonego wskaźnika przechowywanego przez element unique_ptr. Obiekt wywołujący jest odpowiedzialny za usunięcie zwróconego wskaźnika. Właściwość unique-ptr jest ustawiona na pusty stan skonstruowany domyślnie. Możesz przypisać kolejny wskaźnik zgodnego typu do unique_ptr elementu po wywołaniu metody release.

Przykład

W tym przykładzie pokazano, jak obiekt wywołujący wydanie jest odpowiedzialny za zwrócony obiekt:

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

Przejmuje własność parametru wskaźnika, a następnie usuwa oryginalny przechowywany wskaźnik. Jeśli nowy wskaźnik jest taki sam jak oryginalny przechowywany wskaźnik, reset usuwa wskaźnik i ustawia przechowywany wskaźnik na nullptr.

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

Parametry

ptr
Wskaźnik do zasobu do przejęcia własności.

Uwagi

Użyj reset polecenia , aby zmienić przechowywane przez pointer unique_ptr element do ptr , a następnie usunąć oryginalny przechowywany wskaźnik. Jeśli element unique_ptr nie był pusty, reset wywołuje funkcję deleter zwracaną przez get_deleter element w oryginalnym przechowywanym wskaźniku.

Ponieważ reset najpierw przechowuje nowy wskaźnik ptr, a następnie usuwa oryginalny przechowywany wskaźnik, można reset go natychmiast usunąć ptr , jeśli jest on taki sam jak oryginalny przechowywany wskaźnik.

swap

Wymienia wskaźniki między dwoma unique_ptr obiektami.

void swap(unique_ptr& right);

Parametry

right
Element unique_ptr używany do zamiany wskaźników.

Uwagi

Funkcja składowa zamienia się stored_ptr elementami right.stored_ptr i stored_deleter na right.stored_deleter.

unique_ptr

Istnieje siedem konstruktorów dla programu 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
Wskaźnik do zasobu, który ma zostać przypisany do klasy unique_ptr.

_Deleter
Element do deleter przypisania do .unique_ptr

right
Element rvalue reference do obiektu unique_ptr , z którego unique_ptr pola są przenoszone do nowo skonstruowanego unique_ptrobiektu .

Uwagi

Dwa pierwsze konstruktory skonstruuje obiekt, który nie zarządza żadnym zasobem. Trzeci konstruktor przechowuje ptr w pliku stored_ptr. Czwarty konstruktor przechowuje w elementach ptr stored_ptr i deleter w .stored_deleter

Piąty konstruktor przechowuje ptr i stored_ptr przenosi deleter się do .stored_deleter Szósty i siódmy konstruktor przechowuje right.release() i przenosi się right.get_deleter() do klasy stored_deleterstored_ptr .

~unique_ptr

Destruktor for unique_ptr, niszczy unique_ptr obiekt.

~unique_ptr();

Uwagi

Destruktor wywołuje metodę get_deleter()(stored_ptr).