Different ways to use Const with Reference to a Pointer in C++ - GeeksforGeeks

04 Apr, 2020
Before moving forward with using const with Reference to a Pointers, let us first see what they are one by one:
Pointers are used to store the address of variables or a memory location. A variable can be declared as a pointer by putting ‘*’ in the declaration.datatype *var_name; 
Example:// 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;}Output:10

datatype *var_name; 

Example:
// 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;}
10

Reference: When a variable is declared as a reference, it becomes an alternative name for an existing variable. A variable can be declared as a reference by putting ‘&’ in the declaration.datatype &var_name; 
Example:// 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;}Output:20

datatype &var_name; 

Example:
// 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;}
20

References to pointers is a modifiable value that’s used same as a normal pointer.datatype *&var_name; 
Example 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;}Output:10
Here ptr_ref is a reference to the pointer ptr_i which points to variable ‘i’. Thus printing value at ptr_ref gives the value of ‘i’, which is 10.Example 2: Now let us try to change the address represented by a Reference to a Pointer// 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;}Output:5
Here it prints 5, because the value of j is 5 and we changed ptr_ref to point to j. Now as ptr_ref is a reference to pointer ptr, ptr now points to j. Thus we get the output we expected to see.
datatype *&var_name; 

Example 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;}
10

Here ptr_ref is a reference to the pointer ptr_i which points to variable ‘i’. Thus printing value at ptr_ref gives the value of ‘i’, which is 10.
Example 2: Now let us try to change the address represented by a Reference to a Pointer
// 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;}
5

Here it prints 5, because the value of j is 5 and we changed ptr_ref to point to j. Now as ptr_ref is a reference to pointer ptr, ptr now points to j. Thus we get the output we expected to see.
Const Reference to a pointer is a non-modifiable value that’s used same as a const pointer.datatype* const &var_name; 
Example 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;}Compilation Error:In function 'int main()':
prog.cpp:23:13: error: assignment of read-only reference 'ptr_ref'
     ptr_ref = &j;
             ^
Here we get a compile-time error as it is a const reference to a pointer thus we are not allowed to reassign it.Example 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;}Output:100
It prints 100 as it is not a reference to a pointer of a const.Why Example 2 didn’t throw a Compile-time error when Example 1 did?In Example 1, the ptr_ref is a const reference to a pointer to int, and we are trying to change the value of ptr_ref. So the compiler throws a Compile time error, as we are trying to modify a constant value.In Example 2, the ptr_ref is a const reference to a pointer to int, and we are trying to change the value of *ptr_ref, which means we are changing the value of int to which the pointer is pointing, and not the const reference of a pointer. So the compiler doesn’t throw any error and the pointer now points to a value 100. Therefore the int is not a constant here, but the pointer is. As a result, the value of int changed to 100.
datatype* const &var_name; 

Example 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;}
Compilation Error:
In function 'int main()':
prog.cpp:23:13: error: assignment of read-only reference 'ptr_ref'
     ptr_ref = &j;
             ^

Here we get a compile-time error as it is a const reference to a pointer thus we are not allowed to reassign it.
Example 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;}
100

It prints 100 as it is not a reference to a pointer of a const.
Why Example 2 didn’t throw a Compile-time error when Example 1 did?
In Example 1, the ptr_ref is a const reference to a pointer to int, and we are trying to change the value of ptr_ref. So the compiler throws a Compile time error, as we are trying to modify a constant value.
In Example 2, the ptr_ref is a const reference to a pointer to int, and we are trying to change the value of *ptr_ref, which means we are changing the value of int to which the pointer is pointing, and not the const reference of a pointer. So the compiler doesn’t throw any error and the pointer now points to a value 100. Therefore the int is not a constant here, but the pointer is. As a result, the value of int changed to 100.
Reference to a Const Pointer is a reference to a constant pointer.datatype const *&var_name; 
Example:// 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;}Compilation Error:In function 'int main()':
prog.cpp:23:14: error: assignment of read-only location '* ptr_ref'
     *ptr_ref = 124;
              ^
Here again we get compile time error. This is because here the compiler says to declare ptr_ref as reference to pointer to const int. So we are not allowed to change the value of i.
datatype const *&var_name; 

Example:
// 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;}
Compilation Error:
In function 'int main()':
prog.cpp:23:14: error: assignment of read-only location '* ptr_ref'
     *ptr_ref = 124;
              ^

Here again we get compile time error. This is because here the compiler says to declare ptr_ref as reference to pointer to const int. So we are not allowed to change the value of i.
Advanced Pointer
C++-const keyword
cpp-pointer
cpp-references
C++
C++ Programs
CPP
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Map in C++ Standard Template Library (STL)
Constructors in C++
Bitwise Operators in C/C++
Socket Programming in C/C++
Operator Overloading in C++
Header files in C/C++ and its uses
C++ Program for QuickSort
How to return multiple values from a function in C or C++?
Program to print ASCII Value of a character
C++ program for hashing with chaining