Sposób inicjalizacji z wieloma wartościami zwracanymi w C++ (0x)

Question

tuple w podbiciu i TR1/C++ 0x zapewnia wygodną (dla pisarza funkcji) metodę zwracania dwóch wartości z funkcji - jednak wydaje się, że uszkodzenie jednego główną cechą języka do rozmówcy: zdolność do po prostu użyć funkcji zainicjować zmienną:

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

ale dla:

tuple<T,U> sad(); 

nie mamy się poddać możliwość wybrać znacząca nazwa dla naszych wartości zwracanych i użyj get<n>() wszędzie:

const auto two_unrelated_things(sad()); 

lub dokonać tymczasowej:

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

lub przełączyć się z inicjalizacji do cesji, która działa tylko wtedy, gdy typy są przypisane, i łamie 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(); 

lub zrób coś nienaturalnego dla lokalnej klasy:

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 

Czy istnieje lepszy sposób? Używam powyższych konstruktów kompatybilnych z VC10, czy cokolwiek w pełnym C++ 0x lub wspomaganie?

Idealnie byłoby:

• pozwala mi używać inicjalizacji nie tylko zadanie
• niech rozmówca wybierać imiona dla zwróconych-do zmiennych
• nie wprowadzać dodatkowych kopii
• działa zarówno dla zmiennych stosowych, jak i dla członków klasy:
• może być dużą biblioteką szalonych szablonów, ale ma rozsądną składnię dla pisarza wywołującego i funkcji

Answer 1

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

Nie jestem pewien, co się czwarte środki kulach, ale spełnia cała reszta.

* edytuj: Na podstawie powyższego komentarza dowiedziałem się, co miał na myśli czwarty punktor.

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; 
} 

Zmień w razie potrzeby.

W ogóle nie można po prostu użyć wartości std::tuple, jeśli zwrócone wartości są tak niezwiązane, że trzeba je rozdzielić, aby mogły być używane w rozsądny sposób. Ludzie dostali od lat zwrócone struct s z polami o rozsądnie określonej nazwie lub akceptując parametry referencyjne dla danych wyjściowych.

Na marginesie wydaje się, że jesteś zakochany w auto. Nie bądź. Jest to świetna funkcja, ale jest to , a nie sposób, w jaki powinien być używany. Twój kod będzie nieczytelny, jeśli nie określisz typów od czasu do czasu.