Cómo inicializar con valores de retorno múltiples en C++ (0x)

Question

tuple en boost y TR1/C++ 0x proporciona un método conveniente (para el escritor de la función) para devolver dos valores de una función, aunque parezca daños una característica importante de la lengua de la persona que llama: la capacidad de utilizar simplemente la función para inicializar una variable:

T happy(); 
const auto meaningful_name(happy()); // RVO means no excess copies 

pero para:

tuple<T,U> sad(); 

que o bien tienen que renunciar a la posibilidad de escoger una nombre significativo para nuestros valores de devolución, y use get<n>() en todas partes:

const auto two_unrelated_things(sad()); 

o hacer un temporal:

const auto unwanted_named_temporary(sad()); 
const auto one_name(get<0>(unwanted_named_temporary)); 
const auto two_name(get<1>(unwanted_named_temporary)); 

o cambiar de inicialización de la asignación, que sólo funciona cuando los tipos son asignables, y se rompe auto:

tuple_element<0, decltype(sad())>::type one_mutable; // there might be a less 
tuple_element<1, decltype(sad())>::type two_mutable; // verbose way 
tie(one_mutable,two_mutable) = sad(); 

o hacer algo antinatural a una clase local:

const struct ugh { 
    ugh(decltype(sad()) rhs) : one_name(get<0>(rhs)), two_name(get<1>(rhs)) {} 
    const tuple_element<0, decltype(sad())>::type one_name; 
    const tuple_element<1, decltype(sad())>::type two_name; 
} stuff(sad()); // at least we avoid the temporary and get initialization 

¿Hay una manera mejor? Estoy usando las construcciones compatibles con VC10 anteriores, ¿habría algo en C++ 0x completo o aumentaría la ayuda?

Lo ideal sería:

• me permite utilizar la inicialización, no sólo la asignación
• dejar que el persona que llama recoger los nombres de los
• no hacer copias adicionales devueltos-en variables
• trabajo para las variables de la pila y los miembros de la clase
• posiblemente sea una biblioteca de plantillas loca, pero tenga una sintaxis sana para el que llama y el escritor de funciones

Answer 1

std::tuple<Type1, Type2> returnValue = sad(); 
Type1& first = std::get<0>(returnValue); 
Type2& second = std::get<1>(returnValue); 

no estoy seguro de lo que los cuartos medios de bala, pero que satisface todos los demás.

* edit: Basado en su comentario anterior, descubrí lo que quería decir con la cuarta viñeta.

struct Object { 
    Object(const std::tuple<Type1, Type2>& t) : value(t) { } 
    Type1& First() { return std::get<0>(value); } 
    Type2& second() { return std::get<1>(value); } 
private: 
    std::tuple<Type1, Type2> value; 
} 

Modificar según sea necesario.

No podría usar std::tuple en absoluto si los valores devueltos son tan independientes que debe dividirlos para que se puedan usar razonablemente. La gente ha sobrevivido durante años devolvió struct s con campos razonablemente nombrados, o al aceptar los parámetros de referencia para la salida.

Como un lado, pareces estar enamorado de auto. No seas. Es una gran característica, pero esto es no la forma en que debe ser utilizado. Su código terminará ilegible si no especifica tipos de vez en cuando.