Partilhar via

Classe unique_ptr

  • Artigo

Armazena um ponteiro para um objeto ou matriz possuído. O objeto/matriz não pertence a nenhum outro unique_ptr. O objeto/matriz é destruído quando unique_ptr é destruído.

Sintaxe

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

Parâmetros

Right
Um unique_ptr.

Nptr
Um rvalue do tipo std::nullptr_t.

Ptr
Um pointer.

Deleter
Uma função deleter que é associada a unique_ptr.

Exceções

Nenhuma exceção é gerada por unique_ptr.

Comentários

A classe unique_ptr substitui auto_ptr e pode ser usada como um elemento dos contêineres da Biblioteca Padrão C++.

Use a função auxiliar make_unique para criar de modo eficiente novas instâncias de unique_ptr.

unique_ptr gerencia exclusivamente um recurso. Cada objeto unique_ptr armazena um ponteiro para o objeto que possui ou armazena um ponteiro nulo. Um recurso pode ser propriedade de apenas um objeto unique_ptr; quando um objeto unique_ptr que possui um recurso específico é destruído, o recurso é liberado. Um objeto unique_ptr pode ser movido, mas não copiado; para obter mais informações, consulte Declarador de Referência Rvalue&&.

O recurso é liberado chamando um objeto deleter armazenado do tipo Del que sabe como os recursos são alocados para um determinado unique_ptr. O padrão deleter default_delete<T> pressupõe que o recurso apontado por ptr seja alocado com new, e que ele possa ser liberado chamando delete _Ptr. (Uma especialização unique_ptr<T[]>parcial gerencia objetos de matriz alocados com new[], e tem o padrão deleter default_delete<T[]>, specialized para chamar delete[] ptr.)

O ponteiro armazenado para um recurso possuído, stored_ptr tem o tipo pointer. Ele será Del::pointer se for definido e T *, caso não seja definido. O objeto deleter armazenado stored_deleter não ocupará nenhum espaço no objeto se deleter não tiver estado. Observe que Del pode ser um tipo de referência.

Membros

Construtores

Nome Descrição
unique_ptr Há sete construtores para unique_ptr.

Typedefs

Nome Descrição
deleter_type Um sinônimo para o parâmetro de modelo Del.
element_type Um sinônimo para o parâmetro de modelo T.
pointer Um sinônimo para Del::pointer se definido, caso contrário T *.

Funções

Nome Descrição
get Retorna stored_ptr.
get_deleter Retorna uma referência para stored_deleter.
release Armazena pointer() em stored_ptr e retorna seu conteúdo anterior.
reset Libera o recurso possuído atualmente e aceita um novo recurso.
swap Troca o recurso e deleter pelo unique_ptr fornecido.

Operadores

Nome Descrição
operator bool O operador retorna um valor de um tipo que pode ser convertido em bool. O resultado da conversão em bool é true quando get() != pointer(), caso contrário false.
operator-> A função membro retorna stored_ptr.
operator* A função membro retorna *stored_ptr.
operator= Atribui o valor de um unique_ptr(ou um pointer-type) para o unique_ptr atual.

deleter_type

O tipo é um sinônimo do parâmetro de modeloDel.

typedef Del deleter_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloDel.

element_type

O tipo é um sinônimo do parâmetro de modeloType.

typedef Type element_type;

Comentários

O tipo é um sinônimo do parâmetro de modeloTy.

get

Retorna stored_ptr.

pointer get() const;

Comentários

A função membro retorna stored_ptr.

get_deleter

Retorna uma referência para stored_deleter.

Del& get_deleter();

const Del& get_deleter() const;

Comentários

A função membro retorna a referência para stored_deleter.

operator=

Atribui o endereço das unique_ptr fornecidas para a atual.

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

Parâmetros

A referência unique_ptr usada para atribuir a unique_ptr atual.

Comentários

As funções membro chamam reset(right.release()) e movem right.stored_deleter para stored_deleter, em seguida, retornam *this.

pointer

Um sinônimo para Del::pointer se definido, caso contrário Type *.

typedef T1 pointer;

Comentários

O tipo de sinônimo para Del::pointer se definido, caso contrário Type *.

release

Libera a propriedade do ponteiro armazenado e retornado ao chamador e define o valor de ponteiro armazenado para nullptr.

pointer release();

Comentários

Use release para assumir a propriedade do ponteiro bruto armazenado pelo unique_ptr. O chamador é responsável pela exclusão do ponteiro retornado. O unique-ptr é definido como o estado vazio criado por padrão. Você pode atribuir outro ponteiro de tipo compatível para o unique_ptr após a chamada para release.

Exemplo

Este exemplo mostra como o chamador da versão é responsável pelo objeto retornado:

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

Apropria-se do parâmetro de ponteiro e, em seguida, exclui o ponteiro armazenado original. Se o novo ponteiro é o mesmo que o ponteiro armazenado original, reset exclui o ponteiro e define o ponteiro armazenado nullptr.

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

Parâmetros

ptr
Um ponteiro para o recurso se apropriar.

Comentários

Use reset para alterar o pointer armazenado de propriedade de unique_ptr para ptr e, em seguida, exclua o ponteiro armazenado original. Se unique_ptr não estiver vazia, reset invoca a função deleter retornada por get_deleter no ponteiro armazenado original.

Porque reset primeiro armazena o novo ponteiro ptr, e, em seguida, exclui o ponteiro armazenado original, é possível para reset excluir imediatamente ptr se ele for o mesmo que o ponteiro armazenado original.

swap

Troca os valores de dois objetos de unique_ptr.

void swap(unique_ptr& right);

Parâmetros

right
Um unique_ptr usado para a troca de ponteiros.

Comentários

A função membro alterna stored_ptr com right.stored_ptr e stored_deleter com right.stored_deleter.

unique_ptr

Há sete construtores para 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);

Parâmetros

ptr
Um ponteiro para o recurso ser atribuído a unique_ptr.

_Deleter
Um deleter a ser atribuído a um unique_ptr.

right
Um rvalue reference para um unique_ptr do qual unique_ptr campos são atribuídos ao unique_ptr recentemente construído.

Comentários

Os primeiros dois construtores constroem um objeto que não gerencia nenhum recurso. O terceiro construtor armazena ptr em stored_ptr. O quarto construtor armazena ptr em stored_ptr e deleter em stored_deleter.

O quinto construtor armazena ptr em stored_ptr e move deleter em stored_deleter. O sexto e sétimo construtores armazenam right.release() em stored_ptr e move right.get_deleter() em stored_deleter.

~unique_ptr

O destruidor de unique_ptr, destrói um objeto unique_ptr.

~unique_ptr();

Comentários

O destruidor chama get_deleter()(stored_ptr).