EDUCBA

Home » Software Development » Software Development Tutorials » Top Differences Tutorial » c++ reference vs pointer

C++ Reference vs Pointer

Difference Between C++ Reference and 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.

Head To Head Comparison Between C++ Reference and Pointer (Infographics)

Below is the top 7 difference between C++ Reference vs Pointer

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

C++ Reference vs Pointers Infographics

Key differences Between C++ Reference and Pointer

Both are popular choices in the market; let us discuss some of the major difference:

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 change an original variable, while if the pointer is changed, it affects the original variable. A reference must be initialized on the 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 is discussed below:

The basis of comparison  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 that 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 that 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 the 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
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 by the data type, which can be an int or a double.

Syntax:

type *pntr;   // Declare a pointer variable called pntr as a pointer of type
// or
type* pntr;
// or
type * pntr;

For e.g.:

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; they can be stored in different classes, etc. A reference never points to a new variable until the old one 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 is 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 been a guide to the top differences between C++ Reference vs Pointer. Here we also discuss the key differences with infographics and comparison table. You may also have a look at the following articles to learn more –

  1. Python vs C++ differences
  2. C vs C++ Performance – Best Differences
  3. MongoDB vs Cassandra
  4. Mobx vs Redux
  5. C++ Vector vs Array: Top Differences
  6. MongoDB vs DynamoDB: Functions
  7. MongoDB vs SQL: What are the Functions
  8. C vs C#: Functions
3 Shares
Share
Tweet
Share