fixed size container to variadic template argument list conversion

Question

I have to call a variadic template function which can take any number of arguments.

template < class ... Args >
void f( Args&... args);

I wish to write a small wrapper function so that I can call f with N arguments of the same type contained in a fixed size container like std::array.

The goal is to write something like

std::array<int, 3> arr = {1,2,3};
wrapper(arr); // calls f(1,2,3);

I tried to use some combination of initializer lists and std::forward but to no avail. Is there a way to achieve what I want ?

I think you might be looking for a [`std::integer_sequence`](http://en.cppreference.com/w/cpp/utility/integer_sequence) — NathanOliver, Feb 05 '16 at 19:35
@NathanOliver -- what if the type of the arguments may be something other than `int` ? — Louen, Feb 05 '16 at 19:36
I see two problem for making it generic: Creating a tuple from your container, and unpacking the tuple into the argument pack. The latter part [have already been done](http://stackoverflow.com/a/1547118/440558) which leaves the creation of the tuple which I unfortunately have no idea how to do. — Some programmer dude, Feb 05 '16 at 19:38
@Louen As Joachim Pileborg said I think then you need a tuple but I do not know how you would construct it. — NathanOliver, Feb 05 '16 at 19:39
@Louen you can use [make_tuple](http://en.cppreference.com/w/cpp/utility/tuple/make_tuple) — Fozi, Feb 05 '16 at 19:42
If it can work with a tuple, why not with any compile-time sized container ? — Louen, Feb 05 '16 at 19:43
You need to have a parameter pack. I don't think you can convert an array to a parameter pack. — NathanOliver, Feb 05 '16 at 19:44
I think you could go from a non-type parameter pack to an initializer list, to a std::array, so long as it was okay to construct the array from the parameter pack instead of the other way around. — AndyG, Feb 05 '16 at 19:48
@NathanOliver It's as easy as converting a tuple to a parameter pack since `std::array` has the same interface (`std::get`, `std::tuple_size`, etc.). — cpplearner, Feb 05 '16 at 19:49
@cpplearner Good to know. Some of these TMP techniques are still obscure to me. — NathanOliver, Feb 05 '16 at 19:50

score 8 · Answer 1 · edited May 23 '17 at 11:55

If your compiler supports C++14 you can do it the following way:

template <class ... Args>
void f(Args&&... args) {
...
}

template<typename T, std::size_t N, std::size_t... I>
void wrapper_impl(std::array<T, N> const &arr, std::index_sequence<I...>) {
  f(arr[I]...);
}

template<typename T, std::size_t N, 
         typename Indices = std::make_index_sequence<N>>
void wrapper(std::array<T, N> const &arr) {
  wrapper_impl(arr, Indices());
}

Live Demo

For C++11 based on this SO answer you could code some extra machinery and do it as below (haven't test it though):

namespace detail {
  template<std::size_t... Is>        struct seq {};
  template<std::size_t N, int... Is> struct gen_seq : gen_seq<N-1,N-1, Is...> {};
  template<std::size_t... Is>        struct gen_seq<0, Is...> : seq<Is...> {};
}

template <class ... Args>
void f(Args&&... args) {
...
}

template<typename T, std::size_t N, std::size_t... I>
void wrapper_impl(std::array<T, N> const &arr, detail::seq<I...>) {
  f(arr[I]...);
}

template<typename T, std::size_t N>
void wrapper(std::array<T, N> const &arr) {
  wrapper_impl(arr, detail::gen_seq<N>());
}

Live Demo

score 3 · Accepted Answer · edited May 23 '17 at 10:31

I managed to solve it using std::array , inspired by the tuple solution in How do I expand a tuple into variadic template function's arguments?

(Edited : std::array version, first version used raw pointers)

// Function I want to call : 
template< class... Args >
void f( Args&... args ) {
    // ...
}

Using recursive templates who grab the arguments from the end of the array (so that they end up in the correct order). A specialization at I = 0 has all the arguments in the Args..args and calls f()

namespace Helper {
template< unsigned int N, unsigned int I > 
struct Caller {
    template< class T, class...Args >
    static void call( const std::array<T,N>& arr, Args&... args  ){
        Caller<N,I-1>::call( arr, std::get<I-1>(arr), args... );
    }
};

template < unsigned int N >
struct Caller<N, 0> {
    template< class T, class...Args >
    static void call( const std::array<T,N>&  arr, Args&... args ) {
        f(args...);
    }
};
}

Let's wrap it up in a nice function

template< typename T, unsigned N >
void call_f( const std::array<T,N>& arr ){
    Helper::Caller<N,N>::call(arr);
}

Here's what the calling code looks like.

std::array<float,3> array = {4.3, 3.14,2.1} ;
call_f(array);

Live version here

fixed size container to variadic template argument list conversion

2 Answers2

Linked