Diferentes formas de usar Const con referencia a un puntero en C++

Antes de seguir adelante con el uso de const con Referencia a punteros, primero veamos cuáles son uno por uno:

• Los punteros se utilizan para almacenar la dirección de las variables o una ubicación de memoria. Una variable se puede declarar como un puntero poniendo ‘ * ‘ en la declaración.

  datatype *var_name; 
  

  Ejemplo:

  // C++ program to // demonstrate a Pointer    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;        // Pointer to i     int* ptr_i = &i;        cout << *ptr_i;        return 0; }

  Producción:

  10
  

• Referencia : cuando una variable se declara como referencia, se convierte en un nombre alternativo para una variable existente. Una variable se puede declarar como referencia poniendo ‘ & ​​’ en la declaración.

  datatype &var_name; 
  

  Ejemplo:

  // C++ program to // demonstrate a Reference    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;        // Reference to i.     int& ref = i;        // Value of i is now     // changed to 20     ref = 20;        cout << i;        return 0; }

  Producción:

  20
  

• Las referencias a punteros son un valor modificable que se usa igual que un puntero normal.

  datatype *&var_name; 
  

  Ejemplo 1:

  // C++ program to demonstrate // References to pointers    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;        // Pointer to i     int* ptr_i = &i;        // Reference to a Pointer ptr_i     int*& ptr_ref = ptr_i;        cout << *ptr_ref;        return 0; }

  Producción:

  10
  

  Aquí ptr_ref es una referencia al puntero ptr_i que apunta a la variable ‘i’. Por lo tanto, imprimir el valor en ptr_ref da el valor de ‘i’, que es 10.

  Ejemplo 2: ahora intentemos cambiar la dirección representada por una referencia a un puntero

  // C++ program to demonstrate // References to pointers    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;     int j = 5;        // Pointer to i     int* ptr = &i;        // Reference to a Pointer ptr     int*& ptr_ref = ptr;        // Trying to change the reference     // to Pointer ptr_ref to address of j     ptr_ref = &j;        cout << *ptr;        return 0; }

  Producción:

  5
  

  Aquí imprime 5, porque el valor de j es 5 y cambiamos ptr_ref para que apunte a j. Ahora, como ptr_ref es una referencia al puntero ptr, ptr ahora apunta a j. Así obtenemos el resultado que esperábamos ver.

• Const La referencia a un puntero es un valor no modificable que se usa igual que un puntero const.

  datatype* const &var_name; 
  

  Ejemplo 1:

  // C++ program to demonstrate // References to pointers    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;     int j = 5;        // Pointer to i     int* ptr = &i;        // Const Reference to a Pointer     int* const& ptr_ref = ptr;        // Trying to change the const reference     // to Pointer ptr_ref to address of j     ptr_ref = &j;        cout << *ptr;        return 0; }

  Error de compilación:

  In function 'int main()':
  prog.cpp:23:13: error: assignment of read-only reference 'ptr_ref'
       ptr_ref = &j;
               ^
  

  Aquí obtenemos un error de tiempo de compilación ya que es una referencia constante a un puntero, por lo que no podemos reasignarlo.

  Ejemplo 2:

  // C++ program to demonstrate // References to pointers    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;     int j = 5;        // Pointer to i     int* ptr = &i;        // Const Reference to a Pointer     int* const& ptr_ref = ptr;        // Trying to change the reference     // to Pointer ptr_ref     *ptr_ref = 100;        cout << *ptr;        return 0; }

  Producción:

  100
  

  Imprime 100 ya que no es una referencia a un puntero de una const.

  ¿Por qué el Ejemplo 2 no arrojó un error de tiempo de compilación cuando lo hizo el Ejemplo 1?

  • En el Ejemplo 1 , ptr_ref es una referencia constante a un puntero a int, y estamos tratando de cambiar el valor de ptr_ref . Entonces, el compilador arroja un error de tiempo de compilación, ya que estamos tratando de modificar un valor constante.
  • En el Ejemplo 2 , ptr_ref es una referencia constante a un puntero a int, y estamos tratando de cambiar el valor de *ptr_ref , lo que significa que estamos cambiando el valor de int al que apunta el puntero, y no la referencia constante de un puntero Entonces, el compilador no arroja ningún error y el puntero ahora apunta a un valor de 100. Por lo tanto, el int no es una constante aquí, pero el puntero sí lo es. Como resultado, el valor de int cambió a 100.
• La referencia a un puntero constante es una referencia a un puntero constante.

  datatype const *&var_name; 
  

  Ejemplo:

  // C++ program to demonstrate // References to pointers    #include <iostream> using namespace std;    int main() {        // Variable     int i = 10;     int j = 5;        // Const Pointer to i     int const* ptr = &i;        // Reference to a Const Pointer     int const*& ptr_ref = ptr;        // Trying to change the value of the pointer     // ptr with help of its reference ptr_ref     *ptr_ref = 124;        cout << *ptr;     return 0; }

  Error de compilación:

  In function 'int main()':
  prog.cpp:23:14: error: assignment of read-only location '* ptr_ref'
       *ptr_ref = 124;
                ^
  

  Aquí nuevamente obtenemos un error de tiempo de compilación. Esto se debe a que aquí el compilador dice que se declare ptr_ref como referencia al puntero a const int. Entonces no podemos cambiar el valor de i.