Referencias vs punteros en C++: cuándo usar cada uno

Dos formas de referirse a algo

Ya conoces los punteros: variables que almacenan una dirección y te permiten alcanzar el objeto que vive ahí. Las referencias son la otra herramienta que C++ te ofrece para trabajar de forma indirecta con un objeto existente. Se solapan lo suficiente como para que los principiantes no sepan cuál elegir, así que esta página las pone una al lado de la otra.

La versión corta: una referencia es un alias. Una vez que se ejecuta int& r = x;, r es x: el mismo objeto, otro nombre. Un puntero es un objeto independiente que casualmente guarda la dirección de otro. Esa única diferencia condiciona todo lo demás.

Una referencia es un alias

Una referencia debe quedar ligada a un objeto en el momento en que se crea, y a partir de ahí cada uso de la referencia toca el original.

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias y score son ahora el mismo objeto

    alias = 42;           // escribe directamente en score
    cout << score << endl; // 42

    score = 7;
    cout << alias << endl; // 7 - se mueven juntos
    return 0;
}

Fíjate en que no hay ningún * para desreferenciar ni ningún & para "tomar la dirección" en el punto de uso: lees y escribes alias exactamente como un int normal. El & en int& alias forma parte del tipo, no es el operador de dirección.

En qué se diferencian

Los comportamientos de abajo son la razón misma por la que existen ambas herramientas. Esta es la tabla que hay que memorizar.

//                      reference            pointer
// must be initialized? yes                  no (but should be)
// can be null?         no                   yes (nullptr)
// can be reseated?     no                   yes
// pointer arithmetic?  no                   yes
// syntax to use it     just the name        *p  or  p->member
// taking address       &ref == &original    &p is the pointer's own address

Dos de estas son las que más confunden. Primero, una referencia nunca puede reasignarse: asignarle algo copia un valor dentro del objeto referido, no apunta la referencia a algo nuevo.

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int& r = a;

    r = b;   // NO hace que r se refiera a b - copia el valor de b DENTRO de a
    cout << a << endl; // 2  (a cambió)
    cout << b << endl; // 2

    b = 99;
    cout << r << endl; // 2  (r sigue siendo alias de a, no de b)
    return 0;
}

Un puntero, en cambio, es libre de apuntar a otro lugar en cualquier momento:

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int* p = &a;

    p = &b;   // reasigna: p apunta ahora a b
    *p = 99;  // escribe en b
    cout << a << endl; // 1
    cout << b << endl; // 99
    return 0;
}

Segundo, una referencia nunca puede ser legalmente nula, mientras que un puntero sí. Eso hace que "ningún valor" sea representable con un puntero pero no con una referencia, una propiedad en la que te apoyarás constantemente.

Elegir en los parámetros de función

Aquí es donde más aparece la elección. Cuando una función necesita leer o modificar el objeto de quien la llama, ambas funcionan, pero transmiten una intención distinta.

#include <iostream>
using namespace std;

// referencia: el argumento SIEMPRE existe; llamada más limpia
void addTax(double& price) {
    price *= 1.2;
}

// puntero: el argumento es OPCIONAL; nullptr significa "omitir"
void applyDiscount(double* price) {
    if (price == nullptr) return;   // quien llama puede no participar
    *price *= 0.9;
}

int main() {
    double cart = 100.0;

    addTax(cart);              // sin &, se lee como una llamada normal
    cout << cart << endl;      // 120

    applyDiscount(&cart);      // el & explícito avisa "esto puede modificarse"
    cout << cart << endl;      // 108

    applyDiscount(nullptr);    // legal: no pasa nada
    return 0;
}

La versión con referencia (addTax(cart)) es imposible de llamar con "nada", así que dentro de la función nunca compruebas si es nula: el objeto está garantizado. La versión con puntero (applyDiscount(&cart)) anuncia en el punto de llamada, mediante el &, que el argumento podría cambiar, y permite a quien llama pasar nullptr para indicar "no aplica". Elige la que tenga la garantía que encaje con tu función.

Para parámetros de solo lectura de tipos grandes, la opción idiomática es const T&: evita una copia y promete no modificar. Consulta parámetros de función para más sobre paso por valor frente a paso por referencia.

Una regla práctica sencilla

Cuando tengas dudas, opta por defecto por una referencia y solo pásate a un puntero cuando necesites una capacidad que la referencia no tiene:

• Usa una referencia cuando el objeto siempre exista y su identidad nunca cambie: el caso común de los parámetros de función y los alias.
• Usa un puntero cuando se cumpla cualquiera de estas condiciones:
  • "Nada" es un estado válido (argumento opcional, una búsqueda que puede no encontrar coincidencia): un puntero puede ser nullptr.
  • Necesitas apuntar a distintos objetos con el tiempo: un puntero puede reasignarse.
  • Estás gestionando memoria del montón que liberarás con delete, o recorriendo un arreglo con aritmética de punteros.

Si nada de eso aplica, una referencia es la opción más limpia y segura, porque el compilador garantiza por ti "siempre válida, nunca reasignada".

Errores comunes que evitar

• Esperar que ref = other reasigne. En su lugar asigna un valor dentro del objeto referido. Las referencias quedan ligadas de por vida; si necesitas reasignar, usa un puntero.
• Devolver una referencia (o puntero) a una variable local. int& f() { int x = 5; return x; } devuelve una referencia colgante: x muere cuando f retorna y usar el resultado es comportamiento indefinido. La misma trampa afecta a los punteros (return &x;).
• Falsificar una "referencia nula". Escribir int& r = *p; cuando p es nullptr es comportamiento indefinido en el instante en que desreferencias, no una referencia "vacía" segura. Expresa la opcionalidad con un puntero o std::optional.
• Recurrir a un puntero por costumbre. Si el argumento siempre existe y nunca lo reasignarás, una referencia elimina toda una categoría de comprobaciones de nulo y de fallos. No pagues por capacidades que no usas.

Siguiente: Memoria dinámica

Hasta ahora cada objeto al que has referenciado o apuntado se creaba automáticamente en la pila. La siguiente página, memoria dinámica, cubre new y delete: pedir memoria al sistema operativo en tiempo de ejecución, por qué son los punteros (no las referencias) quienes la poseen, y cómo olvidarse de liberarla provoca fugas.