std :: forward_as_tuple um Argumente an 2 Konstruktoren zu übergeben

Question

Ich möchte mehrere Argumente übergeben, um zwei Objekte innerhalb einer Funktion zu konstruieren, genauso wie std::pair<T1, T2>(std::piecewise_construct, ...) funktioniert. So

Ich schrieb

template <typename Args0..., typename Args1...> 
void f(std::tuple<Arg0> args0, std::tuple<Args1> args1) { 
    Object0 alpha(...); 
    Object1 beta(...); 
    ... 
} 

so kann ich

nennen

f(std::forward_as_tuple(..., ..., ...), std::forward_as_tuple(..., ...)) 

Aber ich weiß nicht, wie Object0 und Object1 zu konstruieren. Ich habe den Quellcode meiner Standardbibliothek für std::pair überprüft und sie scheinen komplizierte interne Funktionen zu verwenden, um die Indizes von args0 und args1 zu erhalten. Hast du eine Idee, wie das geht?

Answer 1

C++ 17 wird dafür make_from_tuple haben, aber Sie können dies in C++ 11 schreiben. Hier ist eine C++ 14 Version gestohlen von cppreference (für C++ 11 können Sie die Implementierung von std::index_sequence von Implementation C++14 make_integer_sequence verwenden).

namespace detail { 
template <class T, class Tuple, std::size_t... I> 
constexpr T make_from_tuple_impl(Tuple&& t, std::index_sequence<I...>) 
{ 
    return T(std::get<I>(std::forward<Tuple>(t))...); 
} 
} // namespace detail 

template <class T, class Tuple> 
constexpr T make_from_tuple(Tuple&& t) 
{ 
    return detail::make_from_tuple_impl<T>(std::forward<Tuple>(t), 
     std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{}); 
} 

Mit diesem Programm, die Umsetzung der f ist ein Kinderspiel:

template <typename... Args0, typename... Args1> 
void f(std::tuple<Args0...> args0, std::tuple<Args1...> args1) { 
    auto alpha = make_from_tuple<Object0>(args0); 
    auto beta = make_from_tuple<Object1>(args1); 
} 

es allgemeinere zu machen, ich sie, welche Arten von diesen Tupeln und herzuleiten perfekte Weiterleitung nur empfehlen würde:

template <typename T0, typename T1> 
void f(T0&& args0, T1&& args1) { 
    auto alpha = make_from_tuple<Object0>(std::forward<T0>(args0)); 
    auto beta = make_from_tuple<Object1>(std::forward<T1>(args1)); 
} 

Live C++11 demo