¿Por qué necesitamos variables de referencia si tenemos punteros?

Punteros : un puntero es una variable que contiene la dirección de memoria de otra variable. Un puntero debe ser referenciado con el operador * para acceder a la ubicación de memoria a la que apunta.
Referencias : una referencia se puede llamar como un puntero constante que se desreferencia implícitamente. Cuando accedemos a la referencia significa que estamos accediendo al almacenamiento.
¿Por qué necesitamos variables de referencia si tenemos punteros?
En Punteros para acceder al valor de la variable real, necesitamos desreferenciar explícitamente la variable de puntero usando eloperador de desreferenciación ‘ valor en la dirección ‘ (*) .
En Referencias para acceder al valor de la variable real, no necesitamos desreferenciar explícitamente la variable de referencia, se desreferencian automáticamente.
Los punteros y las referencias son equivalentes, excepto: 

• Una referencia es como un nombre constante para una dirección. Necesitamos inicializar la referencia durante la declaración . Una vez que se establece una referencia a una variable, no podemos cambiar la referencia para hacer referencia a otra variable.
• Para obtener el valor al que apunta un puntero , necesitamos usar el operador de desreferenciación (*) .

Por ejemplo: si a es un puntero de tipo entero, *a devuelve el valor al que apunta a . 
Para asignar una dirección de una variable b a un puntero, necesitamos usar el operador de dirección (&) .
Por ejemplo: int *a= &b.
 

• Las referencias se utilizan sobre el puntero para evitar el corte de objetos . 
   

El corte de objetos ocurre cuando un objeto de clase derivada se asigna a un objeto de clase base , los atributos adicionales de un objeto de clase derivada se cortan para formar el objeto de clase base.

• En las referencias, la referenciación y la desreferenciación se realizan de forma implícita . Sin operador de desreferenciación explícito (*) y para asignar la dirección de una variable a la variable de referencia, sin operador de dirección (&).
• Una variable de referencia proporciona un nuevo nombre a la variable existente . Se desreferencia implícitamente y no necesita un operador de desreferencia (*) para recuperar el valor al que se hace referencia. Mientras que , para recuperar el valor al que apunta un puntero , necesitamos un operador de desreferenciación (*) , que se conoce como desreferenciación explícita .
• La referencia se puede tratar como un puntero constante . Tiene que ser inicializado durante la declaración y su contenido no puede ser cambiado.

A continuación se muestra el programa para la ilustración de puntero y referencias: 

// 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;
}

20
26
23
26
18

Explicación de la salida: 

• cuando el puntero ptr apuntaba a num1 var, imprimía 20 
• cuando *ptr fue desreferido y cambió el valor, imprimió 26
• similar para otra variable llamada num2, impresa 23
• cuando la referencia ref1 fue inicializada por num1 entonces imprimió 26 no 20
• finalmente, cuando se asignó 18 a ref1 , imprimió 18 debido a una desreferenciación implícita

Ilustración de la variable de referencia:
el mejor ejemplo de la variable de referencia es el concepto de constructor de copia . El constructor de copia toma una variable de referencia como argumento, el puntero no se puede usar aquí.

#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();
}

a = 5
b = 10

Explicación: en el ejemplo anterior, si tomamos el puntero en el argumento del constructor de copia , se creará una y otra vez un objeto de clase compleja que nunca se detendrá y es un error en el concepto de ups. elegir la referencia es solo la solución en esta condición.