0Pricing
C++ Academy · Aula

unique_ptr: propriedade exclusiva

Expresse a semântica de proprietário único com unique_ptr e tipos apenas movíveis

unique_ptr: propriedade exclusiva é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

O ponteiro inteligente de proprietário único

std::unique_ptr<T> possui um objeto na memória dinâmica. Quando o unique_ptr é destruído, ele exclui o objeto. Não pode ser copiado — apenas movido.

Criando um unique_ptr

Use std::make_unique (C++14) — é seguro contra exceções e conciso.

#include <memory>
auto w = std::make_unique<Widget>();         // default-constructed
auto p = std::make_unique<Point>(3, 4);       // forwarded args

Usando-o como um ponteiro

unique_ptr oferece as operações usuais de ponteiro.

auto p = std::make_unique<Point>(3, 4);
std::cout << p->x;        // arrow access
std::cout << (*p).y;      // dereference
if (p) std::cout << "non-null";

Não pode copiar — pode mover

Copiar significaria ter dois proprietários — isso violaria o conceito de "único". Mover transfere a posse.

std::unique_ptr<int> a = std::make_unique<int>(1);
std::unique_ptr<int> b = std::move(a);
// a is now empty, b owns the int

Passando para funções

Por valor (com std::move): transfere a posse. Por referência: pega emprestado sem assumir a posse.

void consume(std::unique_ptr<Widget> w);   // takes ownership
void inspect(const Widget& w);              // borrows

auto w = std::make_unique<Widget>();
consume(std::move(w));
// w is now empty
inspect(*w);                                // (after re-creating)

Retornando de funções

Uma função que aloca e retorna a posse deve retornar um std::unique_ptr.

std::unique_ptr<Widget> create() {
    return std::make_unique<Widget>();
}

Redefinindo e liberando

reset() exclui o objeto atual e, opcionalmente, assume a posse de um novo. release() abandona a posse e retorna o ponteiro bruto.

auto p = std::make_unique<int>(10);
p.reset(new int(20));    // delete the old, own the new
int* raw = p.release();   // p is now empty
delete raw;               // caller must delete

get(): pegando emprestado o ponteiro bruto

get() retorna o ponteiro bruto sem abandonar a posse. Use-o para interoperabilidade sem posse.

auto p = std::make_unique<int>(42);
legacy_api(p.get());      // p still owns it

unique_ptr para arrays

Para arrays, use unique_ptr<T[]>. O acesso indexado é feito com []; delete[] é chamado durante a destruição.

auto arr = std::make_unique<int[]>(10);
arr[0] = 99;
std::cout << arr[0];

Eliminadores personalizados

Forneça um eliminador personalizado como parâmetro de modelo quando o recurso não for memória bruta (identificadores de arquivos, recursos do OS).

auto closer = [](FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<FILE, decltype(closer)> file(std::fopen("a.txt","r"), closer);

Desempenho

Com o eliminador padrão, unique_ptr tem o mesmo tamanho e a mesma velocidade de um ponteiro bruto — nenhuma sobrecarga.

Verificação rápida

Por que std::unique_ptr proíbe a cópia?

Recapitulação

std::unique_ptr é o ponteiro inteligente padrão: nenhuma sobrecarga, posse exclusiva, pode ser movido, mas não copiado. Prefira std::make_unique para construí-lo.

Perguntas Frequentes

A aula “unique_ptr: propriedade exclusiva” é grátis?

Sim — o texto completo de “unique_ptr: propriedade exclusiva” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “unique_ptr: propriedade exclusiva”?

Expresse a semântica de proprietário único com unique_ptr e tipos apenas movíveis Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “unique_ptr: propriedade exclusiva”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Por que os ponteiros inteligentes substituem new e delete brutos
  2. unique_ptr: propriedade exclusiva
  3. shared_ptr e weak_ptr: propriedade partilhada
  4. Eliminadores personalizados e funções make
← Voltar para C++ Academy