Extract Parameter Pack - c++

Question

I want to write a function taking N arguments of type T. The use case is to initialize an array in a class with an initializer list.
Vector<uint8_t, 3> vector {5, 4, 3}
Vector<uint16_t, 2> vector2 {90, 7}
The reason, I don't use std::initalizer list is that for the platform I develop, no standard library is available. Therefore I tried some approaches with a self-made integer_list (similar to the one from std).
template <uint8_t ... Ints >
class IndexSequence {};
This works perfectly fine (Array is also similiar to std::array):
template <typename T, uint8_t I>
using ParamPack = T;
template <typename T, uint8_t N, typename I = makeIndexSequence<N>>
class Test;
template <typename T, uint8_t N, uint8_t... I>
class Test<T, N, IndexSequence<I...>> {
public:
Test(ParamPack<T, I>... v)
: data {v...} {}
private:
Array<T,N> data;
};
But I don't like this "trick" to extract the integer param pack from integerSequece so much, because the integer param pack is now part of the class template. And I actually would prefer it just in a template of the constructor or even without any templates.
For example something like this:
Test(ParamPack<T, makeIndexSequence<N>.getParamPack()>... v)
Or something similar. This would be much cleaner in my opinion.
Is there any way to extract the Param Pack from integerSequence without having the param pack in the class template?
I tried to use the same trick just with a template of a function. Unfortunately, it doesn't work, because functions cannot be partially specialised.
Maybe you even have a completely different approach to have something like std::initializer_list or Param packs of a specific type (I'm aware of the possibility to just use variadic templates and cast it into T, but I would like to avoid this if there is a better solution).

Answer 1

Why do you want to avoid variadic templates? They are the right way to solve these kind of problems.
There is no easy way of generating a dynamic number of parameters from a static value N. All solutions involve specialization for some sort of variadic input (std::index_sequence does exactly the same, it generates variadic template parameters).
I think the most elegant way is to use variadic templates and protect the input using static_assert.
template <typename T, size_t N>
class Test {
public:
template <typename... Ts>
Test(Ts&&... v) : data{std::forward<Ts>(v)...} {
static_assert(sizeof...(Ts) == N, "invalid number of arguments");
static_assert((std::is_same_v<T, Ts> && ...), "wrong type");
}
private:
std::array<T, N> data;
};
Note that I am using std::array in this example. It fails to compile when you pass an invalid type or invalid number of arguments.
Test<int, 2> a{1, 2}; // compiles
Test<int, 2> b{1}; // invalid number of arguments
Test<int, 2> c{1, 2, 3}; // invalid number of arguments
Test<int, 2> d{1, 2.f}; // wrong type