Fundación Speedywagon

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 computadora. Los punteros son variables que contienen direcciones de objetos. Se usan 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 es la primera vez que usas 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 dedícales un tiempo para entenderlos de verdad. La versión más básica de este concepto también se llama puntero tonto o puntero crudo. Con el C++ moderno también existen los punteros inteligentes; el tipo básico no es nada inteligente y tienes que encargarte de todo el trabajo manualmente.

Antes de profundizar en los detalles, vale 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:

1. Al igual que las referencias, los punteros evitan copias y ayudan a reducir la huella de recursos de tu programa.
2. A diferencia de las referencias, los punteros se pueden reasignar a objetos diferentes.
3. 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 los punteros, no se inicializan automáticamente. Sin una asignación explícita, un puntero suele contener un valor indeterminado, al que con frecuencia se le llama «dirección basura». Aunque algunos compiladores podrían inicializar los punteros a nullptr, este comportamiento no está garantizado en todos los compiladores, así que es esencial no confiar en ello. Es una buena práctica inicializar explícitamente los punteros crudos 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, usas el operador de dirección (&). Para desreferenciar un puntero se usa 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 de forma explícita, mientras que las referencias simplemente funcionaban 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 trabajas con arrays. Sumar un 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);

Acceder a las variables miembro

En C++, el operador -> se usa 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 trabajas con punteros a objetos.

Aquí tienes un ejemplo breve, 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). El operador -> se usa para acceder a la variable miembro superpower, que muestra 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 vs. referencias

Los punteros y las referencias permiten ambos el acceso indirecto a los objetos, pero difieren en sus capacidades y en sus consideraciones de seguridad. Los punteros ofrecen la flexibilidad de cambiar el objeto al que apuntan y se les puede asignar un valor nulo. Sin embargo, esta flexibilidad introduce riesgos, como desreferenciar punteros nulos o crear punteros colgantes. Las referencias, por otro lado, no pueden ser nulas y quedan vinculadas a objetos válidos desde su creación, lo que evita estos riesgos. Dado que son más seguras, conviene preferir las referencias sobre los punteros, a menos que se necesiten las funcionalidades adicionales que ofrecen los punteros.