Why do we need reference variables if we have pointers

Pointers: A pointer is a variable that holds memory address of another variable. A pointer needs to be de referenced with * operator to access the memory location it points to.
References: A Reference can be called as a constant pointer that becomes de referenced implicitly. When we access the reference it means we are accessing the storage.
Why do we need reference variables if we have pointers?
In Pointers to access the value of the actual variable, we need to explicitly dereference the pointer variable by using ‘value at address’ dereferencing operator(*).
In References to access the value of the actual variable, we do not need to explicitly dereference the reference variable, they get de-referenced automatically.
Pointers and References are equivalent, except: 

• A reference is like a constant name for an address. We need to initialize the reference during the declaration. Once a reference is established to a variable, we cannot change the reference to reference another variable.
• To get the value pointed to by a pointer, we need to use the dereferencing operator(*).

For Example: If a is a pointer to integer type, *a returns the value pointed to by a. 
To assign an address of a variable b into a pointer, we need to use the address-of operator(&).
For Example: int *a= &b.

• Reference are used over pointer to avoid Object Slicing. 
  

Object slicing happens when a derived class object is assigned to a base class object, additional attributes of a derived class object are sliced off to form the base class object.

• In references, referencing and de-referencing are done implicitly. No explicit de-referencing operator(*) and to assign the address of a variable to reference variable, no address-of operator(&).
• A reference variable provides a new name to the existing variable. It is de-referenced implicitly and does not need a de-referencing operator(*) to retrieve the value referenced. Whereas, to retrieve the value pointed to by a pointer we need de-referencing operator(*) which is known as explicit de-referencing.
• Reference can be treated as a constant pointer. It has to be initialized during declaration and its content cannot be changed.

Below is the program for the illustration of pointer and references: 

C++14

// C++ program to illustrate
// pointer and references

#include <iostream>
using namespace std;

// function to illustrate
// pointer and references
void pointer_vs_reference()
{
    int num1 = 20, num2 = 23;

    // Pointer pointing to num1
    // Explicit referencing
    int* ptr1 = &num1;
    cout << *ptr1 << endl; // 20

    // Explicit dereferencing
    *ptr1 = 26;
    cout << *ptr1 << endl; // 26

    // pointer can be reassigned to
    // store another address
    ptr1 = &num2;
    cout << *ptr1 << endl; // 23

    // Reference to num1
    // Implicit referencing
    int& ref1 = num1;
    cout << ref1 << endl; // 26 not 20

    // Implicit dereferencing
    ref1 = 18;

    cout << ref1 << endl; // 18

    // reference cannot be reassigned
}

// Driver code
int main()
{
    pointer_vs_reference();
    return 0;
}

Output:

20
26
23
26
18

Explanation of output: 

• when pointer ptr pointed to num1 var then it printed 20
• when *ptr was de-referred and changed the value then it printed 26
• similar for another variable called num2, printed 23
• when reference ref1 was initialized by num1 then it printed 26 not 20
• finally when 18 was assigned into ref1 then it printed 18 due to implicit de-referencing

Illustration of Reference Variable:
Best example of the reference variable is the concept of copy constructor. Copy constructor takes a reference variable as an argument, pointer cannot be used here.

C++

#include <iostream>
using namespace std;

class complex {
private:
    int a, b;

public:
    // Parametric constructor
    complex(int x, int y)
    {
        a = x;
        b = y;
    }
    // Copy constructor
    complex(const complex& c)
    {
        a = c.a;
        b = c.b;
    }

    // Function to print data
    void printData()
    {
        cout << "a = " << a << endl;
        cout << "b = " << b;
    }
};

int main()
{

    complex c1(5, 10);
    complex c2(c1);
    c2.printData();
}

Output:

a = 5
b = 10

Explanation: In the above example if we take pointer in the argument of copy constructor then object of complex class will be created again and again which will never be stopped and it is error in oops concept. choosing reference is only the solution in this condition.