Variadic模板部分特化的类，用于限制模板参数的类型

Question

I have a class Foo that needs to have a variable number of template arguments, but these arguments need to be of a certain generic type, as opposed to being completely arbitrary. Eg

template < int I, typename T> struct Arg;
using type1 = Foo<Arg<3, double>>;
using type2 = Foo<Arg<1, int>, Arg<7, float>, Arg<1, int>>;

I am wondering what would be the best way to achieve this. I guess I need to start first with a plain variadic template

template < typename ...T >
class Foo;

From there, I could follow the recursive road

template < int I, typename T, typename ...Others>
template Foo<Arg<I, T>, Others...>
{
    ...
};

but the reading of this answer to another question left me wonder about my knowledge of variadic templates and how recursion can sometimes be avoided.

My question is, does the fact that the template arguments are expected to be in a relatively rigid format enable a partial specialization of Foo that would not be recursive, and that would effectively handle all Foo s of the form Foo<Arg<...>,Arg<...>,...> ?

Answer 1

This works:

#include <iostream>

template <int i, typename T> struct Arg;

template <typename ...T>
class Foo;

template <int ...Is, typename ...Ts>
class Foo<Arg<Is, Ts>...>
{
public:
    static constexpr unsigned int N = sizeof...(Is);
};

int main()
{
    using type2 = Foo<Arg<1, int>, Arg<7, float>, Arg<1, int>>;
    std::cout << type2::N << "\n";
}

Though it might or might not be easy or convenient to use the template arguments in that form, depending on what you want to do with them.

Answer 2

You can do this with SFINAE. Here is a sketch:

template<class...Bs>
constexpr bool is_all_true(Bs...); // write this

template<class T>
constexpr bool is_valid_arg(); // write this

template < class=void, class...Ts >
class FooImpl;

template < class...Ts >
class FooImpl<std::enable_if_t<is_all_true( is_valid_arg<Ts>()...) >, Ts...> {
  // code
};

template<class...Ts>
class Foo:FooImpl<void, Ts...> {};

now Foo is a FooImpl , which tests if your preconditions are all met.

You do have to write is_all_true and is_valid_arg , where is_valid_arg tests if T is of the form Arg<int, Type> .

As an example, in C++17, is_all_true is just return (true && ... && bs); (The true is redundant if I remember rightly, but I like it for clarity). In C++11/14 it will be harder.