C++ variadic templates with type and non-type argument mixing for recursive inheritance

Question

I would like to achieve this:

Foo<int, 5, double, 7> foo_1;
Foo<char, 7> foo_2;

foo_1.Foo<int>::value[4] = 1;
foo_2.Foo<char>::value[1] = 'x';

(This is an oversimplified example, Foo would do much more than this.)

How can I do that with variadic templates?

TLDR;

I know that variadic templates can be used in this way if exclusively types or non-types are used:

template <typename ...T>
struct Foo;

template<typename T, typename ...Args>
struct Foo<T, Args...> : Foo<T>, Foo<Args...> {
    Foo(T t, Args... args) : Foo<T>(t), Foo<Args...>(args...) { }
};

template<typename T>
struct Foo<T> {
    T value;

    Foo<T>(T v) : value(v) {}
};

Foo<int, double, char> f(7, 88.1, 'x');
f.Foo<double>::value = 5;

But I do not whether it is possible to pair and mix type and non-type template arguments using variadic templates.

It feels like you are trying to reinvent tuple

Ranoiaetep
– Ranoiaetep

2021-05-22 19:52:36 +00:00
Commented May 22, 2021 at 19:52 — Ranoiaetep
– Ranoiaetep, Commented May 22, 2021 at 19:52
@Ranoiaetep This is an oversimplified example...

Tibor Takács
– Tibor Takács

2021-05-22 20:05:10 +00:00
Commented May 22, 2021 at 20:05 — Tibor Takács
– Tibor Takács, Commented May 22, 2021 at 20:05

HolyBlackCat · Accepted Answer · 2021-05-22 20:12:23Z

6

It's not possible. You'll have to settle for one of the following:

Foo<Bar<int, 5>, Bar<double, 7>> foo_1;
Foo<int, Bar<5>, double, Bar<7>> foo_1;
// ...?

If the values are always integral, you could also try this:

Foo<int[5], double[7]> foo_1;

And then extract elemenet types & extents from each argument.

answered May 22, 2021 at 20:12

HolyBlackCat

102k13 gold badges182 silver badges306 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

o11c Over a year ago

For your first example, Bar could be std::array. For your second it's almost std::integral_constant except the type would have to be hard-coded.

HolyBlackCat Over a year ago

@o11c For the second example you could also use a class with an auto template parameter.

max66 · Accepted Answer · 2021-05-22 20:32:32Z

4

But I do not whether it is possible to pair and mix type and non-type template arguments using variadic templates.

Not with an alternate variadic template. But you can wrap couples of types/sizes.

Suppose you have a Bar class as follows

template <typename T, std::size_t N>
struct Bar
 { std::array<T, N>  value; };

using class specialization you can have a variadic Bar so a variadic list of types and a variadic list of sizes

template <typename...>
struct Foo;

template <typename ... Ts, std::size_t ... Ns>
struct Foo<Bar<Ts, Ns>...> : public Bar<Ts, Ns>...
 { };

You can use it as follows

   Foo<Bar<int, 5>, Bar<double, 7>> foo_1;
   Foo<Bar<char, 7>> foo_2;

   foo_1.Bar<int, 5>::value[4] = 1;
   foo_2.Bar<char, 7>::value[1] = 'x';

The following is a full compiling example

#include <array>

template <typename T, std::size_t N>
struct Bar
 { std::array<T, N>  value; };

template <typename...>
struct Foo;

template <typename ... Ts, std::size_t ... Ns>
struct Foo<Bar<Ts, Ns>...> : public Bar<Ts, Ns>...
 {
 };

int main ()
 {
   Foo<Bar<int, 5>, Bar<double, 7>> foo_1;
   Foo<Bar<char, 7>> foo_2;

   foo_1.Bar<int, 5>::value[4] = 1;
   foo_2.Bar<char, 7>::value[1] = 'x';
 }

edited May 22, 2021 at 20:32

answered May 22, 2021 at 20:21

max66

67k11 gold badges76 silver badges121 bronze badges

3 Comments

Tibor Takács Over a year ago

Would template <typename ... Ts, std::size_t ... Ns> work? I tried earlier but MSVC compiler complains that the variadic part must be the last one in the template argument list.

Ranoiaetep Over a year ago

@TiborTakács Note the way Ts and Ns are used. They were used together here as Bar<Ts, Ns>...

max66 Over a year ago

@TiborTakács - Observe how are used: Bar<Ts, Ns>.... They are wrapped inside Bar; this way you have a variadic Bar so you can have two parallelized (but also three, or four, etc.) variadic lists of the same length. I've added a full compiling example that compile with both g++ and clang++

Abdurrahim · Accepted Answer · 2021-05-22 20:33:25Z

0

You can pass array type as typename, example in your case will become:

Foo<std::array<int, 5>, std::array<double, 7> > foo_1(
    std::array<int, 5>{0,0,0,0,0},
    std::array<double, 7>{0,0,0,0,0,0,0});

foo_1.Foo<std::array<int, 5>>::value[4] = 1;

answered May 22, 2021 at 20:33

Abdurrahim

2,1941 gold badge18 silver badges24 bronze badges

Collectives™ on Stack Overflow

C++ variadic templates with type and non-type argument mixing for recursive inheritance

3 Answers 3

2 Comments

3 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related