Idioma: ES
LuisLlamas Logo
Buscar
⏲️ ~ 4 minutos Intermedio
cpp-referencias

Referencias en C++

En C++, una referencia es un alias que actúa como un nombre alternativo para otra variable ya existente.

Una vez que se establece una referencia, está queda vinculada permanentemente a la variable original (es decir, que no puede apuntar a ninguna otra variable)

Cualquier operación realizada a través de la referencia se realiza directamente a la variable original.

Características de las referencias:

  • Alias constante: Una referencia no puede volver a apuntar a otra variable después de su inicialización.
  • No ocupa memoria adicional: Internamente, la referencia no añade sobrecarga de memoria; simplemente es otra manera de acceder a la misma dirección.
  • Requiere inicialización: A diferencia de los punteros, una referencia debe ser inicializada en el momento de su declaración.

No confundir una referencia con el operador de dirección &. Ambos usan el símbolo &, pero son conceptos distintos (aunque con cierta relación)

Definición de una referencia

La sintaxis básica para declarar una referencia es:

tipo &nombreReferencia = variable;
  • tipo es el tipo de dato apunta.
  • nombreReferencia es el nombre de la referencia.

Vamos a verlo con un ejemplo,

int a = 10;
int &ref = a; // 'ref' es una referencia a 'a'

ref += 5; // Modifica 'a' a través de 'ref'
std::cout << "Valor de a: " << a << std::endl; // Salida: Valor de a: 15

En este ejemplo, cualquier cambio en ref afecta directamente a a, porque ref es simplemente otro nombre para a.

Usos comunes de las referencias

Las referencias son útiles en varios escenarios, desde la optimización de rendimiento hasta la implementación de características avanzadas.

Pasar argumentos por referencia

En C++, las referencias se utilizan frecuentemente para pasar argumentos a funciones sin copiar el contenido de los mismos.

#include <iostream>
void Incrementar(int &numero) {
    numero++;
}

int main() {
    int valor = 5;
    Incrementar(valor);
    std::cout << "Valor incrementado: " << valor << std::endl; // Salida: 6

    return 0;
}

Devolver referencias desde funciones

Una función puede devolver una referencia para permitir la modificación directa del valor retornado.

#include <iostream>
int& ObtenerElemento(int arr[], int indice) {
    return arr[indice];
}

int main() {
    int numeros[] = {1, 2, 3, 4, 5};
    ObtenerElemento(numeros, 2) = 10; // Modifica el tercer elemento

    std::cout << "Elemento modificado: " << numeros[2] << std::endl; // Salida: 10

    return 0;
}

Este uso debe manejarse con cuidado, ya que devolver referencias a variables locales puede provocar comportamiento indefinido.

Referencias constantes

Cuando no queremos que una referencia permita modificar la variable original, podemos declararla como constante.

#include <iostream>
void Mostrar(const int &valor) {
    std::cout << "Valor: " << valor << std::endl;
}

int main() {
    int x = 42;
    Mostrar(x); // Salida: Valor: 42
    return 0;
}

Uso con clases y sobrecarga de operadores

En clases, las referencias son útiles para implementar métodos que devuelvan el propio objeto (method chaining) o para sobrecargar operadores.

#include <iostream>
class Contador {
private:
    int valor;
public:
    Contador() : valor(0) {}

    Contador& operator++() { // Sobrecarga del operador prefijo ++
        valor++;
        return *this;
    }

    void Mostrar() const {
        std::cout << "Valor: " << valor << std::endl;
    }
};

int main() {
    Contador c;
    ++c; // Incrementa usando una referencia
    c.Mostrar(); // Salida: Valor: 1

    return 0;
}

Comparación Referencias y Punteros

Las referencias fueron introducidas como una alternativa a los punteros, las referencias son más seguras y más intuitivas en muchos casos.

Aunque tanto las referencias como los punteros nos permiten manipular objetos indirectamente, tienen diferencias importantes:

CaracterísticaReferenciaPuntero
Sintaxisint &ref = variable;int *ptr = &variable;
Uso principalAcceso a variables existentesManipulación de memoria.
ReasignaciónNo se puede reasignarSe puede reasignar
Debe inicializarseSíNo necesariamente
NulosNo puede ser nula.Puede ser nulo.
NotaciónMás sencilla y directa.Más compleja

Vamos a verlo en un ejemplo

#include <iostream>
void ModificarPorReferencia(int &ref) {
    ref = 20;
}

void ModificarPorPuntero(int *ptr) {
    *ptr = 30;
}

int main() {
    int a = 10;

    ModificarPorReferencia(a);
    std::cout << "Por referencia: " << a << std::endl; // Salida: 20

    ModificarPorPuntero(&a);
    std::cout << "Por puntero: " << a << std::endl; // Salida: 30

    return 0;
}

En este ejemplo,

  • Tanto referencias como punteros pueden modificar el valor original
  • La sintaxis con referencias es más limpia y menos propensa a errores.

Como consejo general, debemos preferir usar referencias siempre que sea posible. Solo en los casos en los que no sea posible, debemos usar punteros (a ser posible, punteros inteligentes)

En esta página