Deduce template argument for size of initializer l

Question

I have the following (not compilable) code:

template< size_t N >
void foo( std::array<int, N> )
{
  // Code, where "N" is used.
}

int main()
{
  foo( { 1,2 } );
}

Here, I want to pass an arbitrary number of ints to a function foo -- for convenience, I will use the std::initializer_list notation. I tried to use an std::array to aggregate the ints (as shown in the code above), however, the compiler can not deduce the array size since the ints are passed as an std::initializer_list.

Using an std::initializer_list instead of an std::array also does not solve the problem since (in contrast to std::array) the size of the std::initializer_list is not captured as template argument.

Does anyone know which data structure can be used so that the ints can be passed by using the std::initializer_list notation and without passing the template argument N of foo explicitly?

Many thanks in advance

Answer 1

If using an initializer list is not a must, you can use variadic template parameter packs:

template<size_t S>
void foo_impl(array<int, S> const&)
{
    cout << __PRETTY_FUNCTION__ << endl;
}

template<typename... Vals>
auto foo(Vals&&... vals) {
    foo_impl<sizeof...(vals)>({ std::forward<Vals>(vals)... });
}

you'd call it as follows:

foo(1,2,3,4,5);

This defers common type checks until the initialization point of std::array (unless you add some admittedly ugly asserts), so you probably should prefer Columbo's answer.

Answer 2

Thanks to core issue 1591, you can use

template <std::size_t N>
void foo( int const (&arr)[N] )
{
  // Code, where "N" is used.
}

foo({1, 2, 3});