Por que os ponteiros inteligentes substituem new e delete brutos

A herança do C: new T aloca um T na memória dinâmica; delete a libera. Você deve corresponder cada new a exatamente um delete — caso contrário, haverá um vazamento (ou uma falha).

Falhas comuns:

• delete esquecido — vazamento de memória
• delete duplo — comportamento indefinido
• Exceção lançada entre new e delete — vazamento
• Retorno de um ponteiro bruto com posse não clara

Aquisição de Recursos É Inicialização: associe o tempo de vida de um recurso ao tempo de vida de um objeto na pilha. O destrutor libera o recurso — mesmo que uma exceção seja lançada.

Um ponteiro inteligente é um pequeno invólucro RAII para um ponteiro bruto. Seu destrutor chama delete. Você nunca se esquece de liberar o recurso.

Ponteiros inteligentes da biblioteca padrão em <memory>:

• std::unique_ptr<T> — posse exclusiva
• std::shared_ptr<T> — posse compartilhada com contagem de referências
• std::weak_ptr<T> — observador sem posse de um shared_ptr

unique_ptr não tem sobrecarga adicional (tem o mesmo tamanho e a mesma velocidade de um ponteiro bruto). shared_ptr tem um pequeno custo de contagem atômica de referências.

Com ponteiros inteligentes, você quase nunca escreve delete. O destrutor cuida disso.

Se uma exceção for lançada no meio da função, as variáveis locais serão destruídas na ordem inversa. Os ponteiros inteligentes liberam seus recursos automaticamente — os ponteiros brutos vazam.

Agora o tipo do ponteiro inteligente codifica a posse. Ao ler a assinatura de uma função, você sabe quem possui o objeto.

Use ponteiros brutos (ou referências) para acesso sem posse. Eles comunicam: "estou pegando emprestado, não sou o proprietário".

Prefira std::make_unique (C++14) e std::make_shared (C++11). Eles são seguros contra exceções e um pouco mais eficientes do que chamar new diretamente.

Qual é o principal motivo para usar std::unique_ptr em vez de um par bruto de new/delete?

new/delete brutos são propensos a erros. Os ponteiros inteligentes envolvem objetos alocados na memória dinâmica em mecanismos RAII que os liberam automaticamente. Prefira std::make_unique e std::make_shared por segurança e desempenho.