¿Un miembro de la clase de referencia constante prolonga la vida de un temporal?

¿Por qué esto:

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

class Sandbox
{
public:
    Sandbox(const string& n) : member(n) {}
    const string& member;
};

int main()
{
    Sandbox sandbox(string("four"));
    cout << "The answer is: " << sandbox.member << endl;
    return 0;
}

Dar salida de:

La respuesta es:

En vez de:

La respuesta es: cuatro

Solo las const referencias locales prolongan la vida útil.

El estándar especifica dicho comportamiento en §8.5.3 / 5, [dcl.init.ref], la sección sobre inicializadores de declaraciones de referencia. La referencia en su ejemplo está vinculada al argumento del constructor n, y deja de ser válida cuando el objeto nestá fuera de alcance.

La extensión de por vida no es transitiva a través de un argumento de función. §12.2 / 5 [clase.temporal]:

El segundo contexto es cuando una referencia está vinculada a una temporal. El temporal al que está vinculada la referencia o el temporal que es el objeto completo de un subobjeto del cual está vinculado el temporal persiste durante la vida útil de la referencia, excepto como se especifica a continuación. Un enlace temporal a un miembro de referencia en el ctor-initializer de un constructor (§12.6.2 [class.base.init]) persiste hasta que el constructor salga. Un enlace temporal a un parámetro de referencia en una llamada de función (§5.2.2 [llamada expr.]) Persiste hasta la finalización de la expresión completa que contiene la llamada.

Aquí está la forma más simple de explicar lo que sucedió:

En main () creaste una cadena y la pasaste al constructor. Esta instancia de cadena solo existía dentro del constructor. Dentro del constructor, asignó miembro para apuntar directamente a esta instancia. Cuando cuando el ámbito abandonó el constructor, la instancia de cadena se destruyó, y el miembro luego señaló un objeto de cadena que ya no existía. Hacer que Sandbox.member apunte a una referencia fuera de su alcance no mantendrá esas instancias externas dentro del alcance.

Si desea arreglar su programa para mostrar el comportamiento que desea, realice los siguientes cambios:

int main()
{
    string temp = string("four");    
    Sandbox sandbox(temp);
    cout << sandbox.member << endl;
    return 0;
}

Ahora temp pasará fuera del alcance al final de main () en lugar de al final del constructor. Sin embargo, esta es una mala práctica. Su variable miembro nunca debe ser una referencia a una variable que existe fuera de la instancia. En la práctica, nunca se sabe cuándo esa variable estará fuera de alcance.

Lo que recomiendo es definir Sandbox.member como un const string member;Esto copiará los datos del parámetro temporal en la variable miembro en lugar de asignar la variable miembro como el parámetro temporal en sí.

Técnicamente hablando, este programa no requiere que realmente envíe nada a la salida estándar (que es una secuencia almacenada para empezar).

• El cout << "The answer is: "bit se emitirá "The answer is: "en el búfer de stdout.

• Luego, el << sandbox.memberbit proporcionará la referencia colgante operator << (ostream &, const std::string &), que invoca un comportamiento indefinido .

Debido a esto, no se garantiza que suceda nada. El programa puede funcionar aparentemente bien o puede fallar sin siquiera descargar stdout, lo que significa que el texto "La respuesta es:" no aparecería en su pantalla.

Debido a que su cadena temporal quedó fuera de alcance una vez que el constructor de Sandbox regresó, y la pila ocupada por ella fue reclamada para otros fines.

En general, nunca debe retener referencias a largo plazo. Las referencias son buenas para argumentos o variables locales, nunca miembros de la clase.

te estás refiriendo a algo que ha desaparecido. Lo siguiente funcionará

#include <string>
#include <iostream>

class Sandbox
{

public:
    const string member = " "; //default to whatever is the requirement
    Sandbox(const string& n) : member(n) {}//a copy is made

};

int main()
{
    Sandbox sandbox(string("four"));
    std::cout << "The answer is: " << sandbox.member << std::endl;
    return 0;
}