C ++ 11: Posso passare da più argomenti a tupla, ma posso passare da tupla a più argomenti?

Possibile duplicato:
Come faccio ad espandere una tupla negli argomenti della funzione modello variadic?
“Decompressione” di una tupla per chiamare un puntatore a funzione corrispondente

Nei modelli C ++ 11, c’è un modo per usare una tupla come i singoli argomenti di una funzione (possibilmente modello)?

Esempio:
Diciamo che ho questa funzione:

void foo(int a, int b) { } 

E ho la auto bar = std::make_tuple(1, 2) della tupla auto bar = std::make_tuple(1, 2) .

Posso usare quello per chiamare foo(1, 2) in modo templaty?

Non intendo semplicemente foo(std::get(bar), std::get(bar)) poiché voglio farlo in un modello che non conosce il numero di argomenti.

Esempio più completo:

 template void caller(Func func, Args... args) { auto argtuple = std::make_tuple(args...); do_stuff_with_tuple(argtuple); func(insert_magic_here(argtuple)); // <-- this is the hard part } 

Dovrei notare che preferirei non creare un modello che funzioni per un arg, un altro che funzioni per due, ecc …

Prova qualcosa del genere:

 // implementation details, users never invoke these directly namespace detail { template  struct call_impl { static void call(F f, Tuple && t) { call_impl::call(f, std::forward(t)); } }; template  struct call_impl { static void call(F f, Tuple && t) { f(std::get(std::forward(t))...); } }; } // user invokes this template  void call(F f, Tuple && t) { typedef typename std::decay::type ttype; detail::call_impl::value, std::tuple_size::value>::call(f, std::forward(t)); } 

Esempio:

 #include  int main() { auto t = std::make_tuple("%d, %d, %d\n", 1,2,3); call(std::printf, t); } 

Con un po ‘di magia extra e usando std::result_of , probabilmente puoi anche fare in modo che l’intero elemento restituisca il valore di ritorno corretto.

Crea una “tupla di indice” (una tupla di numeri interi in fase di compilazione) quindi inoltra a un’altra funzione che deduce gli indici come un pacchetto di parametri e li usa in un’espansione di pacchetto per chiamare std::get sulla tupla:

 #include  template void caller_impl(Func func, Tuple&& t, redi::index_tuple) { func(std::get(t)...); } template void caller(Func func, Args... args) { auto argtuple = std::make_tuple(args...); do_stuff_with_tuple(argtuple); typedef redi::to_index_tuple indices; caller_impl(func, argtuple, indices()); } 

La mia implementazione di index_tuple è https://gitlab.com/redistd/redistd/blob/master/include/redi/index_tuple.h ma si basa su alias del modello, quindi se il compilatore non supporta che avresti bisogno di modificare per usare “template typedefs” in stile C ++ 03 e sostituire le ultime due linee del caller

  typedef typename redi::make_index_tuple::type indices; caller_impl(func, argtuple, indices()); 

std::index_sequence simile è stata standardizzata come std::index_sequence in C ++ 14 (vedere index_seq.h per un’implementazione standalone di C ++ 11).