Referencias en C++: paso por referencia, const& y alias

Otro nombre para lo mismo

En la página de parámetros de función, cada argumento se copiaba dentro de la función. Esa copia es la razón por la que una función no puede cambiar la variable del llamador: solo ve su propio duplicado. Una referencia rompe ese muro. Es un alias: un segundo nombre ligado a una variable existente, que comparte exactamente la misma memoria.

Creas una referencia con & en la declaración. Una vez ligada, la referencia y el original son indistinguibles:

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias es otro nombre para score

    alias = 99;           // escribe directamente en score
    cout << score << "\n"; // 99
    cout << alias << "\n"; // 99

    score = 5;
    cout << alias << "\n"; // 5 - son el mismo objeto
}

Dos reglas hacen que las referencias sean seguras y predecibles: una referencia debe inicializarse en el momento en que se declara (int& r; es un error de compilación) y nunca puede reasignarse para apuntar a otra cosa después. Asignar a una referencia siempre escribe en aquello a lo que se ligó originalmente.

Paso por referencia: deja que una función alcance hacia atrás

La verdadera ventaja está en las funciones. Pon & en un parámetro y la función recibe un alias del argumento del llamador en lugar de una copia. Ahora los cambios dentro de la función son visibles fuera de ella:

#include <iostream>
using namespace std;

void addBonus(int& points) {   // & significa "la variable del llamador, no una copia"
    points += 50;
}

int main() {
    int total = 100;
    addBonus(total);
    cout << total << "\n";   // 150 - el original cambió
}

Quita el & y addBonus incrementaría una copia desechable, dejando total en 100. Ese único carácter es toda la diferencia. Esta es la forma canónica de escribir una función que devuelve más de un resultado o edita su entrada en el sitio. El ejemplo clásico es intercambiar dos variables:

#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << "\n";   // 2 1
}

Sin referencias, swapValues solo intercambiaría copias locales y x/y se quedarían en 1 2. (La biblioteca estándar ya tiene std::swap, pero escribirlo tú mismo muestra exactamente lo que te aporta un parámetro por referencia.)

Referencias const: lee rápido, promete no tocar

El paso por referencia también evita copiar, y para un objeto grande esa copia puede ser costosa. Pero un parámetro T& simple señala "podría modificar esto", lo cual es engañoso cuando solo quieres leer. La solución es const T&: obtienes la velocidad sin copia de una referencia y una promesa, garantizada por el compilador, de que la función no cambiará el argumento.

#include <iostream>
#include <string>
using namespace std;

// No se hace ninguna copia del string, y no podemos modificarlo por accidente.
void greet(const string& name) {
    cout << "Hello, " << name << "! (" << name.size() << " chars)\n";
    // name = "x";  // sería un error de compilación - name es const
}

int main() {
    string user = "Ada Lovelace";
    greet(user);
    greet("literal works too");   // const& también puede ligarse a un temporal
}

Una referencia no const solo puede ligarse a una variable modificable, pero una referencia const también puede ligarse a literales y temporales; por eso greet("literal works too") compila. Una regla práctica para elegir el tipo de un parámetro:

void f(int x)              // tipo barato, solo lectura -> simplemente cópialo
void f(const string& s)   // tipo pesado, solo lectura -> referencia const
void f(string& s)         // tienes la intención de modificar el objeto del llamador

Usa const T& por defecto para cualquier tipo de clase que solo leas (string, vector, tus propios structs), y reserva una referencia no const para cuando realmente quieras escribir de vuelta.

Devolver una referencia

Una función también puede devolver una referencia, entregando al llamador un alias de algo que ya existe. Esto es común en código de tipo contenedor: es lo que permite que v[i] = 5 funcione y lo que hace operator[] por dentro:

#include <iostream>
#include <vector>
using namespace std;

// Devuelve un alias a un elemento, para que el llamador pueda asignarle.
int& at(vector<int>& v, size_t i) {
    return v[i];
}

int main() {
    vector<int> data = {1, 2, 3};
    at(data, 1) = 42;            // asigna a través de la referencia devuelta
    cout << data[1] << "\n";     // 42
}

Como at devuelve int&, la expresión de llamada at(data, 1) es en sí misma un lvalue al que puedes asignar. Devuelve un int simple y at(data, 1) = 42 no compilaría: estarías asignando a una copia temporal.

El gran peligro: referencias colgantes

Una referencia no posee nada; solo apunta a memoria que vive en otro lugar. Si esa memoria muere mientras la referencia sigue en uso, tienes una referencia colgante, y leer a través de ella es comportamiento indefinido: puede imprimir basura, fallar, o parecer que funciona hasta que te arruina el día en producción. El error clásico es devolver una referencia a una variable local:

int& broken() {
    int local = 42;
    return local;   // BUG: local se destruye cuando broken() retorna
}                   // la referencia devuelta queda colgante

int main() {
    int& r = broken();
    cout << r << "\n";   // COMPORTAMIENTO INDEFINIDO - lee memoria muerta
}

La variable local desaparece en el instante en que broken retorna, así que la referencia apunta a espacio de pila ya recuperado. Devuelve solo una referencia a algo que sobreviva a la llamada: un parámetro pasado por referencia, un dato miembro o un static. Si el valor se calcula dentro de la función, devuélvelo por valor y deja que el compilador optimice la copia. La misma trampa afecta a los bucles basados en rango y a cualquier referencia ligada a un temporal: nunca conserves una referencia más allá del tiempo de vida de aquello que nombra.

Siguiente: sobrecarga de funciones

Las referencias te dan una segunda perilla en cada parámetro (copia frente a alias, mutable frente a const) y esa perilla interactúa directamente con el siguiente tema. A continuación, la sobrecarga de funciones te permite definir varias funciones con el mismo nombre pero distintas listas de parámetros, y el compilador elige la correcta haciendo coincidir los tipos de los argumentos, incluyendo si se pasan por valor, por referencia o por referencia const.