Fixed-size container for converting argument list in variation template

Question

I need to call a template function variable that can take any number of arguments.

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

I want to write a small wrapper function so that I can call fwith N arguments of the same type contained in a container with a fixed size, for example 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 using some combination of initializer lists and std::forward, but to no avail. Is there any way to achieve what I want?

Answer 1

std::array, ?

(: std:: array version, )

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

, ( ). I = 0 Args..args 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...);
    }
};
}

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

.

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

Answer 2

++ 14, :

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

++ 11 SO- , ( ):

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