Difference Between C++ Reference vs Pointer
Though C++ reference to pointer seems to be similar there is a significant difference between both C++ Reference vs Pointer. A reference variable can be said as another name for an existing variable. Once this variable is initialized the variable name can be used to refer to another variable. Pointers, on the other hand, are variables that store the address of a variable. Like any variable, these are declared first and then any variable’s address can be stored in them. Let us have a look at the differences between C++ Reference vs Pointer in detail as below.
Head To Head Comparison Between C++ Reference vs Pointer (Infographics)
Below is the top 7 difference between C++ Reference vs Pointer
Key differences between C++ Reference vs Pointer
Both C++ Reference vs Pointer are popular choices in the market; let us discuss some of the major Difference Between C++ Reference vs Pointer:
The main difference between C++ Reference vs Pointer is that one is referring to another variable while the latter is storing the address of a variable. References do not make a change in an original variable while if the pointer is changed it does affect the original variable. A reference must be initialized on declaration while it is not necessary to initialize a pointer once it is declared. An array of pointers can be created while an array of references cannot be created. A null value cannot be assigned to a reference but it can be assigned to a pointer.
C++ Reference vs Pointer Comparison Table
The primary Comparison between C++ Reference vs Pointer are discussed below:
| The basis of comparison Between C++ Reference vs Pointer |
C++ Reference |
Pointer |
| Variables | A reference can be said as an alias to an existing variable. The main use of this variable is working as a parameter which works as a pass-by-reference. This is passed to a function. The function to which this is passed works on the original variable instead of the copy in a pass by value. The changes made inside the function will also be reflected outside. | Pointer variables are variables that store address. Unlike usual variables that we have like int, double and char it stores memory addresses. To make programming easier the need for this variable arises. It is a variable which can store a value of a particular type. |
| Declaration | Declaration of a C++ reference variable is done by adding a ‘&’ symbol before a variable. When it is used with an expression it denotes that it is working as an address of operator. It is used to provide another name to an existing variable.
Syntax: type &newName = existingName; // or type& newName = existingName; // or type & newName = existingName; For eg: /* Test reference declaration and initialization */ #include <iostream> using namespace std;
int main() { string name = “Priya”; // Declare a string variable called name Popular Course in this category
C++ Training (4 Courses, 1+ Projects)
4 Online Courses | 1 Hands-on Projects | 31+ Hours | Verifiable Certificate of Completion | Lifetime Access
4.5 (869 ratings)
Course Price
View Course Related Courses
Java Training (38 Courses, 14+ Projects)Python Certification Training (34 Courses, 9+ Projects)HTML Training (12 Courses)
string & refName = name; // Declare a reference (alias) to the variable name // Both refName and name refer to the same value of “Priya”
cout << name << endl; // It prints value of the variable “Priya”
cout << refName << endl; // It prints value of reference “Priya”
Now change the value of Name refName = “Karishma”; // Re-assign a new value to refName cout << refName << endl; cout << name << endl; // Value of number also changes “Karishma”
name = “Snehal”; // Re-assign a new value to name cout << namer << endl; cout << refName << endl; // Value of refName also changes “Snehal” } This signifies that a reference variable’s values can be changed in the original and copy of the variable. |
Before using a pointer anywhere in the program it should be declared in advance. To declare a pointer and let the system know that it is a pointer a variable is prefixed by a ‘*’. A pointer is accompanied with data type which can be an int or a double, etc.
Syntax: type *pntr; // Declare a pointer variable called pntr as a pointer of type // or type* pntr; // or type * pntr; For eg: int * newPtr; // Declare a pointer variable called newPtr pointing to an int (an int pointer) This pointer will hold the address. That address holds an int value. double * newdPtr; // Declare a double pointer The * indicates that a pointer is being declared and does not act as an operator. |
| Reassignment | A reference variable cannot be reassigned.
Example: int x = 5; int y = 6; int &r = x;
|
A pointer can be reassigned and this property comes in handy when a developer is implementing data structures like linked lists, trees, etc.
Example: int x = 5; int y = 6; int *p; p = &x; p = &y; |
| Memory Address | A reference variable shares the same address as the original variable. These references can be passed to different functions, it can be stored in different classes, etc. A reference never points to a new variable until the old is deleted or goes out of scope. | A pointer has its own memory address and stores it on the stack. A pointer is an independent variable and can have new values assigned to itself. |
| Null Value | A reference cannot have a null value assigned. | A pointer can have a null value assigned directly. |
| Arguments | A reference variable can be referenced bypass by value. Here arguments are passed by value to the functions. A clone is made and sent to the function using it. Changes made to the copy have no effect on the original variable. | When we wish to change the original copy then it can be done by passing a pointer of the object into the function. This is known as pass by reference. |
| When to use | References are indirectly accessing a variable. Consider the following example:
enum day { Sunday, Monday, … }; If we define a variable day x; And we want to overload an operator to the statement then we can write as below: day &operator++(day &d) { d = (day)(d + 1); return d; } In short, this can be used in function parameters and reference types. |
Using pointers is without any pre-declaration.
day *operator++(day *d);
This can be used to implement data structures and pointer arithmetic operations. |
Conclusion – C++ Reference vs Pointer
C++ Reference vs Pointer are difficult to work upon but they improve the efficiency of the program to a great extent. They both C++ Reference vs Pointer have their own uses and serve their own purposes. You can use pointers when you wish to implement data structures and algorithms while references when you wish to use functions and parameters with return types.
Recommended Article
This has a been a guide to the top differences between C++ Reference vs Pointer. Here we also discuss the C++ Reference vs Pointer key differences with infographics, and comparison table. You may also have a look at the following articles to learn more –
