O poder de Troy

A palavra-chave auto em C++

Em C++, a palavra-chave auto é um recurso poderoso introduzido no C++11, usada para declarar variáveis com um tipo de dado inferido. O compilador deduz o tipo da variável a partir do seu inicializador, o que pode deixar o código mais legível e mais fácil de manter.

Exemplo de uso

Considere o exemplo a seguir, em que auto é usada para declarar variáveis:

auto dragon_population{3};          // dragon_population is deduced as an integer
auto westeros{7.7777};              // westeros is deduced as a double
auto wedding_location{"The Twins"}; // wedding_location is deduced as a const char*, not std::string

Em cada caso, o tipo da variável é inferido a partir do valor com o qual ela é inicializada.

Inferência de tipo

A palavra-chave auto ajuda a escrever código mais conciso e legível, reduzindo a verbosidade dos tipos explícitos.

const std::vector<std::string> pigeon_pie{"flour", "butter", "pigeon", "salt"};
auto purple_wedding_pie{pigeon_pie};
purple_wedding_pie.emplace_back("the strangler");

Neste laço, auto deduz o tipo de purple_wedding_pie como std::vector<std::string>, evitando a necessidade de especificar o tipo novamente de forma explícita.

Compatibilidade

A palavra-chave auto é compatível com diversas construções de C++, o que a torna uma ferramenta versátil na programação moderna em C++.

auto& element{array[0]};           // reference to an element
const auto object{otherObject};    // const type version of otherObject's type
auto* ptr{&x};                     // pointer to x with the same type as x, but as a pointer.

Em conceitos posteriores, veremos com frequência a palavra-chave auto com expressões lambda, laços for baseados em intervalo e iteradores.

Ponteiros inteligentes

Ponteiros inteligentes são um recurso moderno do C++ criado para oferecer gerenciamento automático de memória, ajudando a evitar vazamentos de memória e ponteiros pendentes, problemas comuns associados a ponteiros brutos. Eles funcionam como wrappers em torno de ponteiros brutos, acrescentando funcionalidades extras, como a liberação automática da memória quando o ponteiro não é mais necessário.

Sintaxe geral

Ponteiros inteligentes geralmente são implementados como templates de classe na biblioteca padrão do C++. Os dois ponteiros inteligentes mais usados são std::unique_ptr e std::shared_ptr.

Ponteiros únicos

std::unique_ptr é um ponteiro inteligente que possui o objeto com exclusividade. Ele garante que, a qualquer momento, apenas um objeto std::unique_ptr seja dono do recurso. Quando o std::unique_ptr proprietário é destruído ou reiniciado, ele destrói automaticamente os objetos e libera sua memória.

#include <memory>
// Declaring and defining a unique pointer
auto rightful_king_of_england = std::make_unique<std::string>("Excalibur");

// Unique pointers cannot be copied or assigned
auto mordred = rightful_king_of_england; // Error: Cannot copy a unique_ptr

Vantagens de std::make_unique()

Ao criar um std::unique_ptr, é preferível usar std::make_unique() em vez de usar new diretamente para alocar memória. std::make_unique() oferece várias vantagens:

1. Segurança de exceções: std::make_unique() garante segurança de exceções. Se uma exceção for lançada durante a construção do objeto, a memória será liberada automaticamente, evitando vazamentos de memória.
2. Clareza: Usar std::make_unique() deixa o código mais claro e mais conciso. Elimina a necessidade de especificar explicitamente o tipo que está sendo alocado, já que os argumentos de template são deduzidos automaticamente.
3. Oportunidades de otimização: Os compiladores têm a oportunidade de otimizar std::make_unique() de forma mais eficaz do que alocando memória manualmente com new, o que pode resultar em melhor desempenho.
4. Evitar uso indevido: É possível excluir o recurso subjacente quando o std::unique_ptr é construído manualmente. Isso levaria a um comportamento indefinido quando o std::unique_ptr tenta excluí-lo ao final do seu escopo.

Ponteiros compartilhados

std::shared_ptr é um ponteiro inteligente que permite que vários objetos std::shared_ptr compartilhem a propriedade do mesmo recurso. Ele acompanha quantos ponteiros compartilhados estão referenciando o recurso e libera a memória apenas quando o último ponteiro compartilhado que possui o recurso sai de escopo ou é reiniciado.

// Declaring and defining a shared pointer to a dynamically allocated string
auto martian_congressional_republic = std::make_shared<std::string>("protomolecule");

// Creating more shared pointer that shares ownership
auto outer_planets_alliance = martian_congressional_republic;
auto united_nations = martian_congressional_republic;

Vantagens de std::make_shared()

Assim como std::make_unique(), std::make_shared() oferece benefícios como maior eficiência de memória, segurança de exceções e legibilidade. Ela combina a alocação de memória para o bloco de controle e para o objeto gerenciado em uma única operação, melhorando a eficiência e reduzindo o risco de vazamentos de memória. Além disso, a dedução automática dos argumentos de template simplifica o código e melhora a legibilidade. Usar std::make_shared() promove um código mais limpo, mais seguro e mais eficiente ao trabalhar com objetos std::shared_ptr em C++.

Recomendações de uso

Use ponteiros inteligentes por padrão: std::unique_ptr para propriedade exclusiva e std::shared_ptr para propriedade compartilhada. Reserve ponteiros brutos para referências não proprietárias ou para interagir com código legado. Na maioria dos casos, std::unique_ptr é suficiente para propriedade exclusiva, pois oferece um gerenciamento de memória leve, sem a sobrecarga da contagem de referências. std::shared_ptr deve ser usado com moderação, pois introduz sobrecarga e complexidade, a menos que a propriedade compartilhada de fato seja necessária.