El poder de Troy

La palabra clave auto en C++

En C++, la palabra clave auto es una funcionalidad muy potente introducida en C++11 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 fácil de mantener.

Ejemplo de uso

Fíjate en el siguiente ejemplo, en el que 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 del valor con el que se inicializa.

Inferencia de tipos

La palabra clave auto ayuda a escribir código más conciso y legible al reducir 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 fragmento de código, auto deduce el tipo de purple_wedding_pie como std::vector<std::string>, lo que evita tener que especificar el tipo explícitamente otra vez.

Compatibilidad

La palabra clave auto es compatible con diversas 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 con expresiones lambda, bucles for basados en rangos e iteradores.

Punteros inteligentes

Los punteros inteligentes son una funcionalidad moderna de C++ diseñada para proporcionar una gestión automática de la memoria, lo que ayuda a evitar las fugas de memoria y los punteros colgantes que suelen asociarse a los punteros sin procesar. Actúan como envoltorios de los punteros sin procesar y añaden funcionalidad adicional, como la liberación automática de memoria cuando el puntero ya no es necesario.

Sintaxis general

Los punteros inteligentes se implementan normalmente como plantillas de clase en la biblioteca estándar de C++. Los dos punteros inteligentes más utilizados 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 automáticamente los objetos 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()

Al crear un std::unique_ptr, es preferible usar std::make_unique() en lugar de usar new directamente para reservar 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 liberará 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 está reservando, ya que los argumentos de plantilla se deducen automáticamente.
3. Oportunidades de optimización: los compiladores pueden optimizar std::make_unique() con más eficacia que una reserva de memoria manual con new, lo que puede traducirse en una mejora del rendimiento.
4. Evitar un uso indebido: es posible eliminar el recurso subyacente cuando el std::unique_ptr se construye de forma manual. Eso daría lugar a un comportamiento indefinido cuando el std::unique_ptr intente eliminarlo al final de su scope.

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 scope 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()

Al igual que std::make_unique(), std::make_shared() ofrece ventajas como una mayor eficiencia de memoria, seguridad ante excepciones y legibilidad. Combina la reserva 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 la legibilidad. Usar std::make_shared() favorece un código más limpio, seguro y 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 sin procesar para referencias que no impliquen propiedad o cuando tengas que interactuar 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 recuento de referencias. std::shared_ptr debe usarse con moderación, ya que introduce sobrecarga y complejidad a menos que se necesite una propiedad compartida real.