Punteros de desreferencia en C++

1. Punteros en C++
2. Utilice el operador & para obtener la dirección de memoria en C++
3. Declarar punteros en C++
4. Utilice el operador * para desreferenciar el puntero en C++

Este tutorial es una breve discusión sobre la desreferenciación de punteros en C++.

Antes de pasar a nuestro tema real, primero debemos entender qué es un puntero y por qué los programadores de C++ lo necesitan.

Punteros en C++

En C++, las variables se consideran las ubicaciones de memoria a las que acceden sus identificadores. Mediante este método, un programador desconoce la dirección física de la memoria donde se almacena esa variable en particular y accede a ella por su identificador o nombre de variable.

En los programas de C++, la memoria física es una serie de celdas de memoria con cada celda de tamaño de un byte. Cuando una variable con más de un byte se guarda en la memoria, toma ubicaciones de memoria consecutivas.

Por ejemplo, una variable int tiene un tamaño de cuatro bytes, por lo que se necesitan cuatro celdas de memoria consecutivas para almacenar un valor entero.

Cuando se declara una variable en C++, la cantidad de memoria requerida se asigna a una dirección particular (conocida como su dirección física). Esto generalmente se decide en tiempo de ejecución por el sistema operativo o el entorno del programa donde está esa dirección física.

Esta dirección de memoria se puede acceder y almacenar en alguna variable. Usamos un operador conocido como el operador address-of para acceder a él, denotado por el símbolo &.

Utilice el operador & para obtener la dirección de memoria en C++

El operador address-of obtiene la dirección de memoria donde se almacena una determinada variable. Se utiliza precediendo el nombre de la variable con el operador &.

Vea el fragmento de código a continuación:

addr = &newvar

Por esto, la dirección de la variable newvar se le asignará a la variable addr pero no el contenido. Esto se representa en la siguiente figura.

Ejemplo:

newvar = 25;
addr = &newvar

Producción:

En este código, primero, asignamos el valor 25 a la variable newvar, y newvar se almacena en la ubicación de memoria 3. Luego le hemos asignado la dirección de newvar a la variable addr.

Entonces, la variable addr en la que almacenamos la dirección de newvar tiene el valor 3, la dirección de memoria de newvar.

Declarar punteros en C++

La variable utilizada para almacenar la dirección de otra variable se denomina variable de puntero. En el ejemplo anterior, la variable addr es un puntero.

Los punteros son características muy poderosas en la programación. Una variable puntero de un tipo particular apunta a una variable del mismo tipo.

Se declara utilizando un operador de asterisco (*) en el momento de la declaración de la variable de puntero. Considere el fragmento de código a continuación:

#include <iostream>
using namespace std;

int main() {
  int num = 5;
  int* pNum;

  pNum = &num;
  cout << "Value of num is: " << num << endl;
  cout << "Address of num is: " << pNum << endl;
  return 0;
}

Producción:

La salida del programa muestra el valor de newvar que es 5 y su dirección almacenada en el puntero pNum.

Debido a la capacidad de los punteros para apuntar directamente al valor de la variable, deben tener un tipo de datos que sea el mismo que el de la variable a la que apuntan.

Sintaxis:

datatype * nameOfPointer;

Aquí, el tipo de datos es el tipo de la variable a la que apunta.

Ejemplo:

int* numPtr;
char* charPtr;
double* doublePtr;

Hay tres declaraciones de punteros en este fragmento de código, pero son de diferentes tipos. Están destinados a ocupar la misma cantidad de espacio en la memoria (la cantidad de espacio depende del entorno del programa).

Ninguno de ellos puede apuntar a un tipo diferente de variable.

Utilice el operador * para desreferenciar el puntero en C++

En el ejemplo anterior, hemos utilizado el operador address-of para almacenar la dirección de la variable en el puntero. El operador de desreferencia (*) obtiene el contenido de una variable a la que apunta el puntero.

Podemos obtener el valor de la variable cuya dirección se guarda en el puntero.

En el siguiente ejemplo, accedemos al valor de la variable newvar eliminando la referencia del puntero y usando directamente la variable. Podemos observar en la salida que ambos son iguales.

#include <iostream>
using namespace std;

int main() {
  int num = 5;
  int* pNum;

  pNum = &num;
  cout << "Value of num is: " << num << endl;
  cout << "Address of num is: " << pNum << endl;
  cout << "Value of num by using pointer: " << *pNum << endl;
  return 0;
}

Producción:

También podemos guardar el valor que se desreferencia en alguna otra variable como esta:

num2 = *pNum;

Esto significa que num2 es igual al valor de la variable señalado por pNum. Esto se demuestra en la siguiente figura.

Aquí, a num2 se le asigna el mismo valor que a num usando el operador de desreferencia.

¿La desreferenciación hace una copia?

Desreferenciar a veces hace una copia si hacemos algo más que desreferenciar. Por lo tanto, si usamos ese valor desreferenciado para inicializar una nueva variable, esa es una copia, como se muestra en el ejemplo anterior.

Pero si usamos el valor desreferenciado y lo guardamos como referencia en alguna variable de referencia, entonces eso no es una copia, sino que se crea un alias.

int num = 5;
int* pNum = #
int& num2 = *pNum;

El operador de desreferencia inicializó la variable de referencia num2 en la última línea. Esta variable de referencia num2 ahora contendrá la dirección de num y es un alias de num. No copia su valor.

Esto se explica en la siguiente figura.

Ahora, num2 también apunta a num porque contiene la dirección de memoria de num. Por lo tanto, los punteros son una herramienta útil en la programación y nos brindan una gestión eficiente de la memoria y el tiempo durante la programación.