Funcionalidad y diferencia entre *& y **& en C++

1. Funcionalidad y diferencia entre *& y **& en C++
2. Manejar valores por puntero en C++
3. Manejar valores por puntero de referencia en C++
4. Manejar valores por referencia de puntero a puntero (puntero doble) en C++

Esta guía explica la diferencia y la funcionalidad de *& y **& en C++. Para comprender estos símbolos, debe estar familiarizado con el concepto de punteros en C++.

Entonces, antes de continuar y leer la guía completa, visite la guía sobre punteros. Una vez que hayas entendido este concepto, será fácil entender esta guía.

Funcionalidad y diferencia entre *& y **& en C++

Cuando buscamos manejar valores por puntero, usamos un puntero. Su sintaxis es *ptr.

Entendamos todo este concepto con la ayuda de los siguientes ejemplos.

#include <iostream>
using namespace std;

// global variables
int value_1 = 10, value_2 = 20, *global_ptr;

Simplemente estamos creando dos variables, value_1, value_2, y un puntero global como *global_ptr. A continuación, hemos creado tres funciones y métodos diferentes para aclarar todo.

Esas funciones son las siguientes.

Manejar valores por puntero en C++

// function which handles values by pointer
void byPointer(int *ptr) {
  *ptr = 5;
  ptr = global_ptr;
  *ptr = 3;
}

La primera función maneja los valores por el puntero, como puede ver que su parámetro es un puntero.

En el interior, simplemente estamos anulando el valor del puntero, apuntándolo a un puntero global y luego anulando su valor nuevamente. Veamos la función main().

int main() {
  // a pointer to value 1
  int *ptrValue_1 = &value_1;

  // a global pointer having an address of value 2

  global_ptr = &value_2;

  // values before calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;

  byPointer(ptrValue_1);

  // values after calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  return 0;
}

Primero, creamos un puntero que apunta a la dirección de la primera variable. El puntero global apunta a la dirección de la segunda variable.

Simplemente estamos pasando el puntero ptrValue_1 a la función mencionada anteriormente, como puedes ver, los valores iniciales de las variables value_1 y value_2 son 10 y 20, respectivamente.

Pero dentro de la función byPointer(), esos valores se anulan. El puntero también apunta a la dirección del puntero global, que apunta a la dirección de valor_2; por eso se cambiaron ambos valores.

La salida del código anterior es:

Value_1 = 10
Value_2 = 20
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004
Value_1 = 5
Value_2 = 3
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004

Como puede ver, los valores de ambas variables se cambiaron, pero no cambiaron la dirección de los punteros. Esto se debe a que hace copias de punteros y maneja valores usando las copias de esta forma de manejar valores.

Es por eso que la dirección permanece sin cambios. Este concepto le ayudará a entender más.

Manejar valores por puntero de referencia en C++

Ahora, comprendamos el concepto de *& en C++. Echa un vistazo al siguiente código.

// function which handle values by pointer Reference
void byPointerReference(int*& ptr) {
  *ptr = 40;
  ptr = global_ptr;
  *ptr = 50;
}

En el método anterior, pasamos una referencia a un puntero como su parámetro. Funcionará igual que la función en la que pasamos el puntero.

La única diferencia será que también cambiará la dirección de los punteros. Después del método, la dirección de los punteros será la misma que la dirección del puntero global según este código.

int main() {
  // a pointer to value 1
  int *ptrValue_1 = &value_1;

  // a global pointer having the address of value 2

  global_ptr = &value_2;

  // values before calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;

  byPointerReference(ptrValue_1);

  // values after calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  return 0;
}

La idea aquí es mostrarle que tanto la dirección como el valor del puntero cambiarán. La salida del código anterior es la siguiente.

Value_1 = 10
Value_2 = 20
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004
Value_1 = 40
Value_2 = 50
ptrValue_1 = 0x4b8004
global_ptr = 0x4b8004

Manejar valores por referencia de puntero a puntero (puntero doble) en C++

Funcionará igual que la referencia de puntero único. La única diferencia es que es un doble puntero.

Por ejemplo, si empaca un regalo dentro de una caja y empaca el mismo regalo dentro de la caja en una caja, eventualmente, la otra persona tendrá el regalo. No hace la diferencia.

La única diferencia estará en la sintaxis. La referencia de doble puntero es la siguiente.

int **ptrToptr = &ptrValue_1;

Echemos un vistazo a la función/método.

void bypointerPointerReference(int**& ptr) {
  **ptr = 40;
  *ptr = global_ptr;
  **ptr = 50;
}

No hay diferencia excepto por la sintaxis. La función principal será la siguiente.

int main() {
  // a double pointer to value 1
  int *ptrValue_1 = &value_1;
  int **ptrToptr = &ptrValue_1;

  // a global pointer having an address of value 2

  global_ptr = &value_2;

  // values before calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  bypointerPointerReference(ptrToptr);

  // values after calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  return 0;
}

La salida será la misma que la anterior.

Value_1 = 10
Value_2 = 20
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004
Value_1 = 40
Value_2 = 50
ptrValue_1 = 0x4b8004
global_ptr = 0x4b8004