Suppose I have a simple variadic function like this:
template <typename... A>
void func(A... args)
{
//Do stuff
}
And I need another function to call the arguments from an array, let's say:
int arg[3] = {1,2,3};
call the function
func(1,2,3);
Is it possible to do this without modifying the templated function?
You could write apply which takes a reference to an array and functor to call with the unpacked array (you might want to add perfect forwarding and such):
template <typename F, typename T, std::size_t N, std::size_t... Idx>
decltype(auto) apply_impl (F f, T (&t)[N], std::index_sequence<Idx...>) {
return f(t[Idx]...);
}
template <typename F, typename T, std::size_t N>
decltype(auto) apply (F f, T (&t)[N]) {
return apply_impl(f, t, std::make_index_sequence<N>{});
}
Then call it like this, if foo is a functor class:
apply(foo{}, a);
If foo is just a normal template function like in your example, you could wrap it in a lambda:
apply([](auto...xs){foo(std::forward<decltype(xs)>(xs)...);}, a);
std::tuple and the same kind of approach, substituting t[Idx] for std::get<Idx>(t) and array references for the tuple.foo("a") or foo(1,2.0). Otherwise I end up in the same problem while specifying the std::tuple So what I have is just a list of pairs for example, so that the second value specifies the type, can this still be done?!