c++ - terminar - NO es la más importante... ¿pero qué es esto?

que no poner en un cv

Question

Esto produce F~ pero esperaba ~F

#include <iostream>
struct Foo {
int _x;
operator const int & () const {return _x;}
~ Foo () {std :: cout << "~";}
};
void foo (const int &)
{
std :: cout << "F";
}
int main ()
{
foo (Foo ());
}

Construí esto como un contraejemplo para mostrar que el const más importante es una excepción más que una regla. Normalmente se escribe como

cuando una referencia const se une a un temporal, la vida útil de ese temporal se extiende a la duración de la referencia

Estaba intentando ilustrar que, aunque Foo() es temporal, la referencia a _x devuelta por el operador de conversión no lo es, y que el código anterior no es seguro.

Pero el resultado parece demostrar que el ejemplo es seguro, la vida del Foo() temporal se extiende por la existencia de una referencia constante a uno de sus miembros.

¿Es esto correcto? ¿Dónde está especificado en el estándar?

Answer 1

Eso es porque el temporal sobrevive durante toda la duración de la llamada a la función. Cuando haces foo (Foo ()); esto es lo que sucede:

1. el Foo temporal se construye, luego
2. operator const int& se invoca en el temporal
3. se llama a foo() y esto produce F
4. una vez que foo() regrese, se destruye Foo temporalmente y esto se vuelve ~

Answer 2

La regla general, con respecto a los temporales, es que su vida termina cuando termina la expresión completa de la cual forman parte (informalmente, cuando se alcanza el ; ).

12.2 Objetos temporales

3 / [...] Los objetos temporales se destruyen como el último paso en la evaluación de la expresión completa (1.9) que (léxicamente) contiene el punto donde fueron creados. Esto es cierto incluso si esa evaluación termina arrojando una excepción. Los cálculos de valor y los efectos secundarios de destruir un objeto temporal están asociados solo con la expresión completa, no con ninguna subexpresión específica.

Answer 3

No hay magia aquí. Todos los argumentos de funciones viven en el alcance de la persona que llama, incluidos los temporales. El Foo() temporal se construye en el alcance de la persona que llama y se destruye al final de la línea.

Entonces cualquiera que sea la función foo() ocurre antes de que sus argumentos en main() sean destruidos.

Answer 4

Pero su instancia de Foo aquí siempre iba a vivir hasta el punto y coma que termina la declaración en la que se creó. Pasar una referencia a un miembro a una llamada de función no cambió eso.

Tratar:

int const &ref = Foo();
foo(ref);

versus

Foo const &ref = Foo(); // or function returning temp
foo(ref);