Reference initialization

Enlaza una referencia a un objeto.

Sintaxis

Inicialización no de lista

Inicialización de lista ordinaria (desde C++11)

Inicialización de lista designada (desde C++20)

` y `$`\; se\; ha\; conservado\; sin\; traducción,\; así\; como\; todos\; los\; términos\; específicos\; de\; C++.\; Solo\; se\; han\; traducido\; los\; elementos\; de\; texto\; fuera\; de\; estas\; etiquetas\; siguiendo\; las\; instrucciones\; proporcionadas.$

Una referencia a T puede ser inicializada con un objeto de tipo T , una función de tipo T , o un objeto implícitamente convertible a T . Una vez inicializada, una referencia no puede ser reasignada (cambiada) para referirse a otro objeto.

Las referencias se inicializan en las siguientes situaciones:

Explicación

Definiciones

Para dos tipos T1 y T2 :

• Dadas las versiones sin calificación cv de T1 y T2 como U1 y U2 respectivamente, si U1 es similar a U2 , o U1 es una clase base de U2 , T1 está relacionado por referencia con T2 .
• Si un valor pr de tipo "puntero a T2 " puede convertirse al tipo "puntero a T1 " mediante una secuencia de conversión estándar, T1 es compatible por referencia con T2 .

Reglas de inicialización

Para la inicialización de referencias no de lista, dado el tipo del target como U , la referencia o bien se enlaza directamente al target o se enlaza a un valor de tipo T convertido desde el target . Primero se considera el enlace directo, seguido del enlace indirecto; si ninguno de los enlaces está disponible, el programa está mal formado.

En todos los casos donde la relación de compatibilidad de referencia de dos tipos se utiliza para establecer la validez de un enlace de referencia y la secuencia de conversión estándar sería incorrecta, un programa que requiera dicho enlace es incorrecto.

Enlace directo

Si se cumplen todas las siguientes condiciones:

• La referencia a ser inicializada es una referencia lvalue.
• target es un lvalue que no es un campo de bits .
• T es compatible por referencia con U .

Entonces la referencia se enlaza a target , o a su subobjeto de clase base apropiado:

double d = 2.0;
double& rd = d;        // rd se refiere a d
const double& rcd = d; // rcd se refiere a d
struct A {};
struct B : A {} b;
A& ra = b;             // ra se refiere al subobjeto A en b
const A& rca = b;      // rca se refiere al subobjeto A en b

De lo contrario, si se cumplen todas las siguientes condiciones:

• La referencia a inicializar es una referencia lvalue.
• U es un tipo clase.
• T no está relacionado por referencia con U .
• target puede convertirse a un lvalue de tipo V tal que T sea compatible por referencia con V .

Entonces la referencia se enlaza al resultado lvalue de la conversión, o a su subobjeto de clase base apropiado:

struct A {};
struct B : A { operator int&(); };
int& ir = B(); // ir hace referencia al resultado de B::operator int&

De lo contrario, si la referencia a inicializar es una referencia de lvalue, y T no está calificado como const o está calificado como volatile, el programa está mal formado:

double& rd2 = 2.0; // error: no es un lvalue y la referencia no es const
int i = 2;
double& rd3 = i;   // error: tipo incompatible y la referencia no es const

De lo contrario, si se cumplen todas las siguientes condiciones:

• target es un valor de cualquiera de las siguientes categorías:

• T es compatible por referencia con U .

Entonces la referencia se enlaza a target , o a su subobjeto de clase base apropiado:

struct A {};
struct B : A {};
extern B f();
const A& rca2 = f(); // vinculado al subobjeto A del valor temporal B.
A&& rra = f();       // igual que el anterior
int i2 = 42;
int&& rri = static_cast<int&&>(i2); // vinculado directamente a i2

De lo contrario, si se cumplen todas las siguientes condiciones:

• U es un tipo de clase.
• T no está relacionado por referencia con U .
• target puede convertirse a un valor v de tipo V tal que T sea compatible por referencia con V , donde v es de cualquiera de las siguientes categorías:

Entonces la referencia se enlaza al resultado de la conversión, o a su subobjeto de clase base apropiado:

struct A {};
struct B : A {};
struct X { operator B(); } x;
const A& r = x; // vinculado al subobjeto A del resultado de la conversión
B&& rrb = x;    // vinculado directamente al resultado de la conversión

Enlace indirecto

Si el enlace directo no está disponible, se considera el enlace indirecto. En este caso, T no puede estar relacionado por referencia con U .

Si T o U es un tipo clase, se consideran conversiones definidas por el usuario usando las reglas para inicialización por copia de un objeto de tipo T mediante conversión definida por el usuario. El programa está mal formado si la correspondiente inicialización por copia no referencial estaría mal formada. El resultado de la llamada a la función de conversión, como se describe para la inicialización por copia no referencial, se utiliza luego para inicializar directamente la referencia. Para esta inicialización directa, no se consideran conversiones definidas por el usuario.

const std::string& rs = "abc"; // rs se refiere a una copia temporal inicializada desde un array de caracteres
const double& rcd2 = 2;        // rcd2 se refiere a un temporal con valor 2.0
int i3 = 2;
double&& rrd3 = i3;            // rrd3 se refiere a un temporal con valor 2.0

Vida útil de un temporal

Siempre que una referencia se vincula a un objeto temporal o a un subobjeto del mismo, el tiempo de vida del objeto temporal se extiende para coincidir con el tiempo de vida de la referencia (consulte excepciones de tiempo de vida de objeto temporal ), donde el objeto temporal o su subobjeto se denota mediante una de las siguientes expresiones:

• una expresión entre paréntesis ( e ) , donde e es una de estas expresiones,
• una expresión de subíndice incorporada de la forma a [ n ] o n [ a ] , donde a es un array y es una de estas expresiones,
• una expresión de acceso a miembro de clase de la forma e. m , donde e es una de estas expresiones y m designa un miembro de datos no estático de tipo objeto,
• una operación de puntero-a-miembro de la forma e. * mp , donde e es una de estas expresiones y mp es un puntero a miembro de datos,
• una conversión const_cast , static_cast , dynamic_cast , o reinterpret_cast sin una conversión definida por el usuario que convierta una de estas expresiones al glvalue que se refiere al objeto designado por el operando, o a su objeto completo o un subobjeto del mismo (una expresión de conversión explícita se interpreta como una secuencia de estas conversiones),
• una expresión condicional de la forma cond ? e1 : e2 que es un glvalue, donde e1 o e2 es una de estas expresiones, o
• una expresión de coma incorporada de la forma x, e que es un glvalue, donde e es una de estas expresiones.

Existen las siguientes excepciones a esta regla de duración:

• un temporal vinculado a un parámetro de referencia en una llamada de función existe hasta el final de la expresión completa que contiene esa llamada de función: si la función retorna una referencia, que sobrevive a la expresión completa, se convierte en una referencia colgante.

struct A
{
    int&& r;
};
A a1{7}; // OK, lifetime is extended
A a2(7); // well-formed, but dangling reference

En general, la vida útil de un temporal no puede extenderse más al "pasarlo": una segunda referencia, inicializada desde la variable de referencia o miembro de datos al que estaba vinculado el temporal, no afecta su vida útil.

Notas

Las referencias aparecen sin inicializadores solo en la declaración de parámetros de función, en la declaración del tipo de retorno de función, en la declaración de un miembro de clase, y con el extern especificador.

Hasta la resolución de CWG issue 1696 , se permitía que un temporal se vinculara a un miembro de referencia en una lista de inicialización initializer list del constructor, y persistía solo hasta que el constructor finalizaba, no mientras existiera el objeto. Dicha inicialización es incorrecta desde CWG 1696 , aunque muchos compiladores aún la admiten (una excepción notable es clang).

Ejemplo

#include <sstream>
#include <utility>
struct S
{
    int mi;
    const std::pair<int, int>& mp; // miembro de referencia
};
void foo(int) {}
struct A {};
struct B : A
{
    int n;
    operator int&() { return n; }
};
B bar() { return B(); }
//int& bad_r;      // error: sin inicializador
extern int& ext_r; // OK
int main()
{
//  Lvalues
    int n = 1;
    int& r1 = n;                    // referencia lvalue al objeto n
    const int& cr(n);               // la referencia puede ser más cv-calificada
    volatile int& cv{n};            // se puede usar cualquier sintaxis de inicialización
    int& r2 = r1;                   // otra referencia lvalue al objeto n
//  int& bad = cr;                  // error: menos cv-calificada
    int& r3 = const_cast<int&>(cr); // se necesita const_cast
    void (&rf)(int) = foo; // referencia lvalue a función
    int ar[3];
    int (&ra)[3] = ar;     // referencia lvalue a array
    B b;
    A& base_ref = b;        // referencia al subobjeto base
    int& converted_ref = b; // referencia al resultado de una conversión
//  Rvalues
//  int& bad = 1;        // error: no se puede enlazar ref lvalue a rvalue
    const int& cref = 1; // enlazado a rvalue
    int&& rref = 1;      // enlazado a rvalue
    const A& cref2 = bar(); // referencia al subobjeto A del temporal B
    A&& rref2 = bar();      // igual
    int&& xref = static_cast<int&&>(n); // enlazar directamente a n
//  int&& copy_ref = n;                 // error: no se puede enlazar a un lvalue
    double&& copy_ref = n;              // enlazar a un temporal rvalue con valor 1.0
//  Restricciones en tiempos de vida de temporales
//  std::ostream& buf_ref = std::ostringstream() << 'a';
                     // el temporal ostringstream se enlazó al operando izquierdo
                     // de operator<< pero su tiempo de vida terminó en el punto y coma
                     // por lo que buf_ref es una referencia colgante
    S a {1, {2, 3}}; // par temporal {2, 3} enlazado al miembro referencia
                     // a.mp y su tiempo de vida se extiende para coincidir
                     // con el tiempo de vida del objeto a
    S* p = new S{1, {2, 3}}; // par temporal {2, 3} enlazado a la referencia
                             // miembro p->mp, pero su tiempo de vida terminó en el punto y coma
                             // p->mp es una referencia colgante
    delete p;
    // Imitar [[maybe_unused]] aplicado a las siguientes variables:
    [](...){}
    (
        cv, r2, r3, rf, ra, base_ref, converted_ref,
        a, cref, rref, cref2, rref2, copy_ref, xref
    );
}

Informes de defectos

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

Véase también

• constructor
• converting constructor
• copy assignment
• copy constructor
• explicit
• inicialización
  • constant initialization
  • copy initialization
  • direct initialization
  • list initialization
• move assignment
• move constructor
• new