Difference Between Pointer and Reference Variable in C++

In C++, both pointer variables and reference variables are used to indirectly access and manipulate data. However, there are some important differences between the two. Here's an explanation of the difference between pointer variables and reference variables, along with examples:

Pointer Variables:

A pointer variable is a variable that stores the memory address of another variable.

It is declared using the * symbol before the variable name.

Pointers can be reassigned to point to different memory addresses.

Pointers can be assigned a nullptr value to indicate that they are not currently pointing to any valid memory address.

Pointers can perform pointer arithmetic.

To access the value at the memory address stored in a pointer variable, we need to use the dereference operator *.

Pointers can be made to point to dynamically allocated memory using the new keyword.

C++ Example code for the pointer:

#include<iostream>
using namespace std;

int main() {
    int num = 10;
    int* ptr = &num; // pointer variable

    cout << *ptr << endl; // Output: 10 (dereferencing the pointer)

    *ptr = 20; // changing the value using the pointer
    cout << num << endl; // Output: 20 (value updated)

    return 0;
}

Output:

10
20

Reference Variables:

A reference variable is an alias or alternative name for an existing variable.

It is declared using the & symbol after the variable name.

References must be initialized when declared and cannot be reassigned to refer to a different variable.

References cannot be nullptr and must always refer to a valid object.

References do not have a separate memory address; they are simply another name for the original variable.

To access the value of a reference variable, we use the reference variable itself.

C++ Example Code for Reference Variable.

#include<iostream>
using namespace std;

int main() {
    int num = 10;
    int& ref = num; // reference variable

    cout << ref << endl; // Output: 10 (directly accessing the reference)

    ref = 20; // changing the value using the reference
    cout << num << endl; // Output: 20 (value updated)

    return 0;
}

Output:

10
20

Pointer Vs Preference Variable in C++.

Pointer Variable	Reference Variable
The pointer is Declared using * symbol.	Reference is Declared using & symbol.
Can be initialized to nullptr or memory address.	Must be initialized upon declaration to refer to an existing variable.
Can be reassigned to point to different memory locations.	Cannot be reassigned once initialized; it always refers to the same object.
Requires explicit memory allocation and deallocation (e.g., new and delete).	Does not require explicit memory allocation or deallocation.
Can point to nullptr, which means it doesn't point to any valid memory location.	Cannot be null; must always refer to a valid object.
Syntax: int* ptr;	Syntax: int value = 10; int& ref = value;

When to use what:

Use pointers when you need to deal with dynamic memory allocation, create data structures, or perform pointer arithmetic. Also, use pointers when you want to point to multiple different objects during the program's execution or when you need a nullable reference. (alert-success)

Use reference variables when you want to avoid the overhead of copying large objects in function calls, want to modify the value of an existing variable directly, or when want a more convenient and safer alternative to pointers for passing parameters to functions.

Conclusion:

The main difference between pointer variables and reference variables in C++ is that pointers store memory addresses, can be reassigned, and require dereferencing to access the value, while references are aliases for existing variables, cannot be reassigned, and allow direct access to the value without dereferencing.