El poder de Troy

La palabra clave auto en C++

En C++, la palabra clave auto es una funcionalidad poderosa que se introdujo en C++11 y que sirve para declarar variables con un tipo de dato inferido. El compilador deduce el tipo de la variable a partir de su inicializador, lo que puede hacer que el código sea más legible y más fácil de mantener.

Ejemplo de uso

Fíjate en el siguiente ejemplo, donde se usa auto para declarar variables:

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

En cada caso, el tipo de la variable se infiere a partir del valor con el que se inicializa.

Inferencia de tipos

La palabra clave auto te ayuda a escribir código más conciso y legible, ya que reduce la verbosidad de los 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");

En este bucle, auto deduce que el tipo de purple_wedding_pie es std::vector<std::string>, lo que evita tener que especificar el tipo otra vez.

Compatibilidad

La palabra clave auto es compatible con varias construcciones de C++, lo que la convierte en una herramienta versátil en la programación moderna en 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.

En conceptos posteriores veremos a menudo la palabra clave auto junto con expresiones lambda, bucles for basados en rangos e iteradores.

Punteros inteligentes

Los punteros inteligentes son una funcionalidad moderna de C++ diseñada para ofrecer gestión automática de memoria, y ayudan a evitar las fugas de memoria y los punteros colgantes que suelen acompañar a los punteros crudos. Actúan como wrappers alrededor de los punteros crudos y añaden funcionalidad adicional, como liberar la memoria automáticamente cuando el puntero ya no se necesita.

Sintaxis general

Los punteros inteligentes suelen implementarse como plantillas de clase en la biblioteca estándar de C++. Los dos punteros inteligentes más usados son std::unique_ptr y std::shared_ptr.

Punteros únicos

std::unique_ptr es un puntero inteligente que posee el objeto en exclusiva. Garantiza que, en un momento dado, solo un objeto std::unique_ptr posea el recurso. Cuando el std::unique_ptr propietario se destruye o se reinicia, destruye los objetos automáticamente y libera su memoria.

#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

Ventajas de std::make_unique()

Cuando creas un std::unique_ptr, es preferible usar std::make_unique() en lugar de usar new directamente para asignar memoria. std::make_unique() ofrece varias ventajas:

1. Seguridad ante excepciones: std::make_unique() garantiza la seguridad ante excepciones. Si se lanza una excepción durante la construcción del objeto, la memoria se libera automáticamente, lo que evita fugas de memoria.
2. Claridad: usar std::make_unique() hace que el código sea más claro y conciso. Elimina la necesidad de especificar explícitamente el tipo que se asigna, ya que los argumentos de plantilla se deducen automáticamente.
3. Oportunidades de optimización: los compiladores pueden optimizar std::make_unique() de forma más eficaz que si asignas la memoria manualmente con new, lo que puede mejorar el rendimiento.
4. Evitar un uso indebido: es posible eliminar el recurso subyacente cuando el std::unique_ptr se construye manualmente. Eso provocaría un comportamiento indefinido cuando el std::unique_ptr intenta eliminarlo al final de su ámbito.

Punteros compartidos

std::shared_ptr es un puntero inteligente que permite que varios objetos std::shared_ptr compartan la propiedad del mismo recurso. Lleva la cuenta de cuántos punteros compartidos hacen referencia al recurso y solo libera la memoria cuando el último puntero compartido que posee el recurso sale de su ámbito o se reinicia.

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

Ventajas de std::make_shared()

De forma similar a std::make_unique(), std::make_shared() ofrece beneficios como una mejor eficiencia de memoria, seguridad ante excepciones y legibilidad. Combina la asignación de memoria del bloque de control y del objeto gestionado en una sola operación, lo que mejora la eficiencia y reduce el riesgo de fugas de memoria. Además, la deducción automática de los argumentos de plantilla simplifica el código y mejora su legibilidad. Usar std::make_shared() favorece un código más limpio, más seguro y más eficiente cuando trabajas con objetos std::shared_ptr en C++.

Consejos de uso

Usa punteros inteligentes de forma predeterminada: std::unique_ptr para la propiedad exclusiva y std::shared_ptr para la propiedad compartida. Reserva los punteros crudos para referencias que no implican propiedad o cuando interactúes con código heredado. En la mayoría de los casos, std::unique_ptr basta para la propiedad exclusiva, ya que ofrece una gestión de memoria ligera sin la sobrecarga del conteo de referencias. std::shared_ptr debería usarse con moderación, ya que introduce sobrecarga y complejidad a menos que se necesite una propiedad compartida de verdad.