Reference declaration

Declara una variable nombrada como una referencia, es decir, un alias para un objeto o función ya existente.

Sintaxis

Una declaración de variable de referencia es cualquier declaración simple cuyo declarador tiene la forma

Se requiere que una referencia sea inicializada para referirse a un objeto o función válido: consulte reference initialization .

El tipo "referencia a (posiblemente calificado con cv) void " no puede formarse.

Los tipos de referencia no pueden ser cv-qualified en el nivel superior; no existe sintaxis para eso en la declaración, y si se añade una calificación a un typedef-name o decltype specifier, (since C++11) o type template parameter , se ignora.

Las referencias no son objetos; no necesariamente ocupan almacenamiento, aunque el compilador puede asignar almacenamiento si es necesario para implementar la semántica deseada (e.g. un miembro de datos no estático de tipo referencia usualmente incrementa el tamaño de la clase por la cantidad necesaria para almacenar una dirección de memoria).

Debido a que las referencias no son objetos, no existen arreglos de referencias, no hay punteros a referencias, y no hay referencias a referencias:

int& a[3]; // error
int&* p;   // error
int& &r;   // error

typedef int&  lref;
typedef int&& rref;
int n;
lref&  r1 = n; // type of r1 is int&
lref&& r2 = n; // type of r2 is int&
rref&  r3 = n; // type of r3 is int&
rref&& r4 = 1; // type of r4 is int&&

Referencias Lvalue

Las referencias Lvalue pueden utilizarse para crear un alias de un objeto existente (opcionalmente con diferente calificación cv):

#include <iostream>
#include <string>
int main()
{
    std::string s = "Ex";
    std::string& r1 = s;
    const std::string& r2 = s;
    r1 += "ample";           // modifica s
//  r2 += "!";               // error: no se puede modificar mediante referencia a const
    std::cout << r2 << '\n'; // imprime s, que ahora contiene "Example"
}

También pueden utilizarse para implementar semántica de paso por referencia en llamadas a funciones:

#include <iostream>
#include <string>
void double_string(std::string& s)
{
    s += s; // 's' es el mismo objeto que 'str' de main()
}
int main()
{
    std::string str = "Test";
    double_string(str);
    std::cout << str << '\n';
}

Cuando el tipo de retorno de una función es una referencia lvalue, la expresión de llamada a función se convierte en una lvalue expresión:

#include <iostream>
#include <string>
char& char_number(std::string& s, std::size_t n)
{
    return s.at(n); // string::at() returns a reference to char
}
int main()
{
    std::string str = "Test";
    char_number(str, 1) = 'a'; // the function call is lvalue, can be assigned to
    std::cout << str << '\n';
}

#include <iostream>
#include <string>
int main()
{
    std::string s1 = "Test";
//  std::string&& r1 = s1;           // error: can't bind to lvalue
    const std::string& r2 = s1 + s1; // okay: lvalue reference to const extends lifetime
//  r2 += "Test";                    // error: can't modify through reference to const
    std::string&& r3 = s1 + s1;      // okay: rvalue reference extends lifetime
    r3 += "Test";                    // okay: can modify through reference to non-const
    std::cout << r3 << '\n';
}

#include <iostream>
#include <utility>
void f(int& x)
{
    std::cout << "lvalue reference overload f(" << x << ")\n";
}
void f(const int& x)
{
    std::cout << "lvalue reference to const overload f(" << x << ")\n";
}
void f(int&& x)
{
    std::cout << "rvalue reference overload f(" << x << ")\n";
}
int main()
{
    int i = 1;
    const int ci = 2;
    f(i);  // llama a f(int&)
    f(ci); // llama a f(const int&)
    f(3);  // llama a f(int&&)
           // llamaría a f(const int&) si no se proporcionara la sobrecarga f(int&&)
    f(std::move(i)); // llama a f(int&&)
    // las variables de referencia a rvalue son lvalues cuando se usan en expresiones
    int&& x = 1;
    f(x);            // llama a f(int& x)
    f(std::move(x)); // llama a f(int&& x)
}

int i2 = 42;
int&& rri = std::move(i2); // se enlaza directamente a i2

std::vector<int> v{1, 2, 3, 4, 5};
std::vector<int> v2(std::move(v)); // enlaza una referencia de valor-r a v
assert(v.empty());

template<class T>
int f(T&& x)                      // x es una referencia de reenvío
{
    return g(std::forward<T>(x)); // y por lo tanto puede ser reenviada
}
int main()
{
    int i;
    f(i); // el argumento es lvalue, llama a f<int&>(int&), std::forward<int&>(x) es lvalue
    f(0); // el argumento es rvalue, llama a f<int>(int&&), std::forward<int>(x) es rvalue
}
template<class T>
int g(const T&& x); // x no es una referencia de reenvío: const T no está sin calificación cv
template<class T>
struct A
{
    template<class U>
    A(T&& x, U&& y, int* p); // x no es una referencia de reenvío: T no es un
                             // parámetro de plantilla de tipo del constructor,
                             // pero y es una referencia de reenvío
};

auto&& vec = foo();       // foo() puede ser lvalue o rvalue, vec es una referencia de reenvío
auto i = std::begin(vec); // funciona en ambos casos
(*i)++;                   // funciona en ambos casos
g(std::forward<decltype(vec)>(vec)); // reenvía, preservando la categoría de valor
for (auto&& x: f())
{
    // x es una referencia de reenvío; esta es una forma común de usar range for en código genérico
}
auto&& z = {1, 2, 3}; // *no* es una referencia de reenvío (caso especial para listas de inicialización)

Referencias colgantes

Aunque las referencias siempre se refieren a objetos o funciones válidos tras la inicialización, es posible crear un programa donde el lifetime del objeto referenciado finalice, pero la referencia permanezca accesible ( dangling ).

Dada una expresión expr de tipo referencia y sea target el objeto o función denotado por la referencia:

• Si un puntero a target sería válido en el contexto de la evaluación de expr , el resultado designa target .
• De lo contrario, el comportamiento es indefinido.

std::string& f()
{
    std::string s = "Example";
    return s; // sale del ámbito de s:
              // se llama a su destructor y se desasigna su almacenamiento
}
std::string& r = f(); // referencia colgante
std::cout << r;       // comportamiento indefinido: lectura desde una referencia colgante
std::string s = f();  // comportamiento indefinido: inicialización por copia desde una referencia colgante

Tenga en cuenta que las referencias a valor derecho y las referencias a valor izquierdo a const extienden los tiempos de vida de los objetos temporales (consulte Inicialización de referencias para las reglas y excepciones).

Si el objeto referenciado fue destruido (por ejemplo, mediante una llamada explícita al destructor), pero el almacenamiento no fue desasignado, una referencia al objeto fuera de su tiempo de vida puede usarse de maneras limitadas, y puede volverse válida si el objeto es recreado en el mismo almacenamiento (consulte Access outside of lifetime para más detalles).

Referencias inaccesibles por tipo

Intentar enlazar una referencia a un objeto donde el inicializador convertido es un lvalue (until C++11) un glvalue (since C++11) a través del cual el objeto no es type-accessible resulta en comportamiento indefinido:

char x alignas(int);
int& ir = *reinterpret_cast<int*>(&x); // comportamiento indefinido:
                                       // el inicializador hace referencia a un objeto char

Referencias incompatibles de llamada

Intentar enlazar una referencia a una función donde el inicializador convertido es un lvalue (until C++11) un glvalue (since C++11) cuyo tipo no es call-compatible con el tipo de la definición de la función resulta en comportamiento indefinido:

void f(int);
using F = void(float);
F& ir = *reinterpret_cast<F*>(&f); // comportamiento indefinido:
                                   // el inicializador hace referencia a la función void(int)

Notas

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Enlaces externos