c++ - que - Extensión de por vida y el operador condicional.
que es un bucle en c (2)
Las referencias locales de valor-referencia-a-const y rvalor pueden extender la vida útil de los temporales:
const std::string& a = std::string("hello");
std::string&& b = std::string("world");
¿Eso también funciona cuando el inicializador no es una expresión simple, pero usa el operador condicional?
std::string&& c = condition ? std::string("hello") : std::string("world");
¿Qué pasa si uno de los resultados es un objeto temporal, pero el otro no lo es?
std::string d = "hello";
const std::string& e = condition ? d : std::string("world");
¿C ++ ordena que la duración del tiempo temporal se extienda cuando la condición es falsa?
La pregunta surgió al responder esta pregunta sobre objetos no copiables.
Ambos están bien.
§5.16 dice (extraordinariamente abreviado):
2 Si el segundo o el tercer operando tiene el tipo void
No
3 De lo contrario, si el segundo y tercer operando tienen diferentes tipos
No
4 Si el segundo y tercer operandos son glvalores de la misma categoría de valor
No (En el primero, ambos son prvalores y en el segundo es un valor de gl, y uno es un valor de prorrateo.)
5 De lo contrario, el resultado es un prvalue.
De acuerdo, ambos resultados se traducen en prvalores. Así que el enlace está bien, pero ¿a qué se debe el enlace?
6 Las conversiones estándar de Lvalue-to-rvalue (4.1), array-to-pointer (4.2) y function-to-pointer (4.3) se realizan en el segundo y tercer operandos.
Bien, ambos son ahora valores si aún no lo estaban.
6 (continuación) Después de esas conversiones, se mantendrá una de las siguientes:
El segundo y tercer operandos tienen el mismo tipo; El resultado es de ese tipo. Si los operandos tienen un tipo de clase, el resultado es un prvalor temporal del tipo de resultado, que se inicializa con copia desde el segundo operando o el tercer operando, según el valor del primer operando.
Bien, entonces es std::string(first_operand) o std::string(second_operand) .
Independientemente, el resultado de la expresión condicional es un nuevo prvalue temporal, y ese valor se extiende al vincularse a sus referencias.
std::string d = "hello";
const std::string& e = condition ? d : std::string("world");
¿C ++ ordena que la duración del tiempo temporal se extienda cuando la condición es falsa?
Será. El condicional es una expresión rvalue, y cuando se enlaza con una referencia const el compilador creará un objeto sin nombre y vinculará la referencia a él. Lo que no estoy 100% seguro es si el tiempo temporal cuya vida útil se extiende es std::string("world") o si se realiza (conceptualmente) una copia de ella (y se elimina).