Declare member variables from variadic template parameter

Question

Obviously the code below doesn't compile in C++. But I have a case where I'd like to parameterize a class with zero or more data items based on template parameters.

Is there any way I can declare a class whose data members depend on variadic template parameters so I can access each of them? or some other way to achieve what I'd like?

This came up in a real program which I've solved an entirely different way but now I'm interested in the more abstract problem of how I might have done this.

template <typename... Types> class Data
{
    // Declare a variable of each type in the parameter pack
    // This is NOT valid C++ and won't compile...
    Types... items;
};

struct Item1
{
    int a;
};

struct Item2
{
    float x, y, z;
};

struct Item3
{
    std::string name;
}

int main()
{
    Data<Item1, Item2> data1;
    Data<Item3> data2;
}

Surprisingly enough, this does not appear to be a duplicate. — MSalters, Nov 24 '16 at 08:49

score 25 · Accepted Answer · answered Nov 24 '16 at 08:40

25

You could use a std::tuple

#include <tuple>

template <typename... Types> class Data
{
    std::tuple<Types...> items;
};

struct Item1
{
    int a;
};

struct Item2
{
    float x, y, z;
};

struct Item3
{
    std::string name;
};

int main()
{
    Data<Item1, Item2> data1;
    Data<Item3> data2;
}

Try it here

answered Nov 24 '16 at 08:40

Jonas

6,915
8
35
53

Thanks, that's great. I use tuple but somehow it didn't occur to me I could use it with the expanded parameter pack. – jcoder Nov 24 '16 at 08:54
What if you wanted each member to be a 1-bit bitfield? Are macros the only way to do it? – splicer Apr 27 '19 at 15:26
I suppose you could use a bitset, or something like it. – Jonas Apr 28 '19 at 06:32

score 11 · Answer 2 · answered Nov 24 '16 at 08:39

11

That is the purpose of std::tuple:

template <typename... Types> class Data
{
    std::tuple<Types...> items;
};

answered Nov 24 '16 at 08:39

Jarod42

203,559
14
181
302

1

Ah thank you. That's slightly embarrassing, I use tuple but somehow didn't think to use it with a parameter pack expansion here. – jcoder Nov 24 '16 at 08:53

score 9 · Answer 3 · answered Nov 24 '16 at 08:39

9

The standard has got you covered. Just declare std::tuple<Types...> items.

answered Nov 24 '16 at 08:39

MSalters

173,980
10
155
350

score 8 · Answer 4 · answered Oct 31 '18 at 02:15

I wanted to be able to use the members with fold expressions. So I ended up with:

template <class T, class... rest> class hold : hold<rest...> {
    using base = hold<rest...>;
    T v_;

public:
    hold(T v, rest... a) : base(a...), v_(v) {}

    template <class F, class... args> auto apply(F f, args... a) {
        return base::apply(f, a..., v_);
    }
};

template <class T> class hold<T> {
    T v_;

public:
    hold(T v) : v_(v) {}

    template <class F, class... args> auto apply(F f, args... a) {
        return f(a..., v_);
    }
};

This then facilitates:

template <class scalar, class... arrays> struct plus_expr {
    hold<arrays...> a_;

    plus_expr(arrays... a) : a_(a...) {}

    scalar operator[](index const i) {
        return a_.apply([i](arrays... a) { return (a[i] + ...); });
    }
};

Huge thanks! I was able to use this general structure in C++11 to make a tuple-like class that can do std::apply style behavior. I had similar need for indexing like your example too. I took a different approach though. Instead of the lambda capture, I passed it in to apply, and then instead of apply(f, a..., v_) it was apply(f, a..., _sample(v_, i)) which was overloaded for different "array-like" inputs. — kylefinn, May 13 '19 at 17:17

Declare member variables from variadic template parameter

4 Answers4

Linked