O poder de Troia

A palavra-chave auto em C++

Em C++, a palavra-chave auto é uma funcionalidade poderosa introduzida no C++11, utilizada para declarar variáveis com um tipo de dados inferido. O compilador deduz o tipo da variável a partir do seu inicializador, o que pode tornar o código mais legível e mais fácil de manter.

Exemplo de utilização

Repara no seguinte exemplo, em que auto é utilizado 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 que é inicializada.

Inferência de tipos

A palavra-chave auto ajuda-te 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 ciclo, auto deduz o tipo de purple_wedding_pie como std::vector<std::string>, evitando a necessidade de voltar a especificar o tipo explicitamente.

Compatibilidade

A palavra-chave auto é compatível com várias 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 frequentemente a palavra-chave auto com expressões lambda, ciclos for baseados em intervalos e iteradores.

Ponteiros inteligentes

Os ponteiros inteligentes são uma funcionalidade moderna de C++ concebida para proporcionar uma gestão automática de memória, ajudando a evitar as fugas de memória e os ponteiros pendentes habitualmente associados aos ponteiros brutos. Funcionam como invólucros em torno dos ponteiros brutos, acrescentando funcionalidades adicionais, como a libertação automática de memória quando o ponteiro já não é necessário.

Sintaxe geral

Os ponteiros inteligentes são habitualmente implementados como modelos de classe na biblioteca padrão de C++. Os dois ponteiros inteligentes mais utilizados são std::unique_ptr e std::shared_ptr.

Ponteiros únicos

std::unique_ptr é um ponteiro inteligente que detém o objeto em exclusivo. Garante que, em qualquer momento, apenas um objeto std::unique_ptr detém o recurso. Quando o std::unique_ptr detentor é destruído ou reiniciado, destrói automaticamente os objetos e liberta a 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 utilizar std::make_unique() em vez de recorrer diretamente a new para alocar memória. std::make_unique() oferece várias vantagens:

1. Segurança relativamente a exceções: std::make_unique() garante segurança relativamente a exceções. Se for lançada uma exceção durante a construção do objeto, a memória é libertada automaticamente, evitando fugas de memória.
2. Clareza: utilizar std::make_unique() torna o código mais claro e mais conciso. Elimina a necessidade de especificar explicitamente o tipo a alocar, uma vez que os argumentos de modelo 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 alocar memória manualmente com new, o que pode resultar num melhor desempenho.
4. Evitar utilizações indevidas: é possível eliminar o recurso subjacente quando o std::unique_ptr é construído manualmente. Isso levaria a um comportamento indefinido, quando o std::unique_ptr tenta eliminá-lo no fim do seu âmbito.

Ponteiros partilhados

std::shared_ptr é um ponteiro inteligente que permite que vários objetos std::shared_ptr partilhem a posse do mesmo recurso. Mantém o registo de quantos ponteiros partilhados estão a referenciar o recurso e liberta a memória apenas quando o último ponteiro partilhado que detém o recurso sai do âmbito 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()

Tal como std::make_unique(), std::make_shared() oferece benefícios como uma maior eficiência de memória, segurança relativamente a exceções e legibilidade. Combina a alocação de memória do bloco de controlo e do objeto gerido numa única operação, o que aumenta a eficiência e reduz o risco de fugas de memória. Além disso, a dedução automática dos argumentos de modelo simplifica o código e melhora a legibilidade. Utilizar std::make_shared() promove código mais limpo, mais seguro e mais eficiente quando trabalhas com objetos std::shared_ptr em C++.

Conselhos de utilização

Utiliza ponteiros inteligentes por predefinição: std::unique_ptr para posse exclusiva e std::shared_ptr para posse partilhada. Reserva os ponteiros brutos para referências sem posse ou quando interages com código legado. Na maioria dos casos, std::unique_ptr é suficiente para a posse exclusiva, uma vez que oferece uma gestão de memória leve, sem a sobrecarga da contagem de referências. std::shared_ptr deve ser utilizado com moderação, pois introduz sobrecarga e complexidade, a menos que seja realmente necessária uma posse partilhada.