Como muchos otros lenguajes, C++ tiene punteros.
Ya sabes que las referencias y los punteros son similares, pero piensa en ellos como un nivel más cerca del funcionamiento interno de tu ordenador.
Los punteros son variables que contienen direcciones de objetos.
Se utilizan para interactuar directamente con los objetos, lo que permite la asignación dinámica de memoria y una manipulación eficiente de los datos en C++.
Si eres nuevo en los punteros, pueden parecer un poco misteriosos, pero una vez que te acostumbras a ellos, son bastante sencillos.
Son una parte crucial de C++, así que tómate tu tiempo para entenderlos bien.
La versión más básica de este concepto también se conoce como dumb pointer o raw pointer.
Con el C++ moderno también existen los smart pointers; el tipo básico no es nada inteligente y tienes que encargarte de todo el trabajo manualmente.
Antes de profundizar en los detalles, merece la pena entender el uso de los punteros.
Los punteros son una forma de compartir la dirección de un objeto con otras partes de nuestro programa, lo cual es útil por dos razones principales:
- Como las referencias, los punteros evitan copias y ayudan a reducir el consumo de recursos de tu programa.
- A diferencia de las referencias, los punteros se pueden reasignar a objetos diferentes.
- Los punteros también pueden apuntar a un valor nulo, para indicar que actualmente no apuntan a ningún objeto.
Sintaxis general
Una declaración de puntero en C++ implica especificar el tipo de dato al que apunta el puntero, seguido de un asterisco (*) y el nombre del puntero.
Cuando se declaran punteros, no se inicializan automáticamente.
Sin una asignación explícita, un puntero suele contener un valor indeterminado, al que a menudo se denomina «dirección basura».
Aunque algunos compiladores podrían inicializar los punteros a nullptr, este comportamiento no está garantizado en todos los compiladores, por lo que es esencial no confiar en él.
Es una buena práctica inicializar explícitamente los punteros raw y verificar que no sean nulos antes de usarlos, para evitar posibles problemas.
int* ptr{nullptr}; // Declares a pointer and makes sure it is not invalid
Para asignar la dirección de una variable a un puntero, se utiliza el operador de dirección (&).
La desreferenciación de un puntero se realiza mediante el operador de indirección (*).
std::string opponent{"Solomon Lane"};
// 'ethan' points to the address of the string opponent
std::string* ethan{&opponent};
// Instead of ethan's, the opponent's name address is given to the passPort
std::string passportName{*ethan};
Atención: la desreferenciación debe hacerse explícitamente, mientras que las referencias simplemente funcionan como un alias.
Aritmética de punteros
La aritmética de punteros te permite realizar operaciones aritméticas con punteros, lo cual es especialmente útil cuando se trabaja con arrays.
Sumar un número entero a un puntero hace que apunte a un elemento diferente.
// Stargate Coordinate Code
int gateCode[] = {462, 753, 218, 611, 977};
// 'ptr' points to the first element of 'gateCode'
int* ptr{&gateCode[0]};
// Accesses the third Stargate address through pointer arithmetic
int dialedAddress{*(ptr + 2)};
// Chevron encoded! Dialing Stargate address:
openStarGate(dialedAddress);
La aritmética de punteros en C++ puede provocar fácilmente un comportamiento indefinido si no se maneja con cuidado.
El comportamiento indefinido puede manifestarse en resultados inesperados del programa, bloqueos o incluso vulnerabilidades de seguridad.
Un ejemplo famoso de las consecuencias del comportamiento indefinido ocurrió en la explosión del cohete Ariane 5 en 1996, cuando una excepción de software causada por la conversión de un número de coma flotante de 64 bits a un entero con signo de 16 bits provocó un fallo catastrófico.
Acceder a las variables miembro
En C++, el operador -> se utiliza para acceder a los miembros de un objeto a través de un puntero a ese objeto.
Es una forma abreviada que simplifica el acceso a los miembros de los objetos a los que apuntan los punteros.
Por ejemplo, si ptr es un puntero a un objeto con una variable miembro x, en lugar de usar (*ptr).x, puedes usar directamente ptr->x.
Este operador mejora la legibilidad del código y reduce la verbosidad cuando se trabaja con punteros a objetos.
Aquí tienes un breve ejemplo, con una struct Superhero que tiene una variable miembro superpower.
La función main crea un puntero dianaPrince a un objeto Superhero (que representa a Wonder Woman).
Se utiliza el operador -> para acceder a la variable miembro superpower, mostrando el icónico «Lasso of Truth» de Wonder Woman.
struct Superhero {
std::string superpower;
};
Superhero wonder_woman{};
Superhero* dianaPrince = &wonder_woman;
dianaPrince->superpower = "Lasso of Truth";
// Using the -> operator to access member variable superpower:
std::cout << "Wonder Woman, possesses the mighty " << dianaPrince->superpower;
Punteros frente a referencias
Tanto los punteros como las referencias permiten el acceso indirecto a objetos, pero difieren en sus capacidades y consideraciones de seguridad.
Los punteros ofrecen la flexibilidad de cambiar el objeto al que apuntan y pueden asignarse a nulo.
Sin embargo, esta flexibilidad introduce riesgos, como desreferenciar punteros nulos o crear punteros colgantes.
Las referencias, en cambio, no pueden ser nulas y se vinculan a objetos válidos en el momento de su creación, evitando estos riesgos.
Dada su naturaleza más segura, deberían preferirse las referencias a los punteros, a menos que sean necesarias las funcionalidades adicionales que ofrecen los punteros.
Ejercicio de aprendizaje
