Given a template class (A) and a parameter pack of types (T1, T2...), convert to a tuple like A, A, A

Question

How do you implement this:

template <class A, class ... T> struct wrapper {
   template <int depth>
   A<depth>& get(); // returns a reference to the Nth item wrapped in A;
};

e.g.

wrapper<vector, int, double, string> example;

int x=example.get<0>[7];       // return the vector of `int` at position 0 and call operator[]
auto y=example.get<1>.size();  // return the vector of `double` at position 1 and get it's size

This is what I tried:

template<class A, class ... T>
struct wrapper {
    using WRAPPED=decl_type(std::apply(
        [](auto ...x){
             std::make_tuple(A[x], ...);
        },
        T...));
    WRAPPED elems;

    template <int depth>
    decl_type(std::get<depth>(elems))& get() { return std::get<depth>(elems); }
};

But the compiler was not happy:

<source>:71:23: error: expected type-specifier before 'decl_type'
   71 |         using WRAPPED=decl_type(std::apply(
      |                       ^~~~~~~~~
<source>:74:14: error: expected unqualified-id before ',' token
   74 |             },
      |              ^
<source>:76:9: error: 'WRAPPED' does not name a type
   76 |         WRAPPED elems;
      |         ^~~~~~~
<source>:79:24: error: 'std::get' is not a type
   79 |         decl_type(std::get<depth>(elems))& get() { return std::get<depth>(elems); }
      |                        ^~~~~~~~~~
<source>:79:44: error: expected constructor, destructor, or type conversion before 'get'
   79 |         decl_type(std::get<depth>(elems))& get() { return std::get<depth>(elems); }
      |                                            ^~~
Compiler returned: 1

You are looking for [template template](https://stackoverflow.com/questions/213761/what-are-some-uses-of-template-template-parameters). — Raymond Chen, May 27 '22 at 22:07

Jarod42 · Accepted Answer · 2022-05-29T18:02:42.467

You need template-template parameter.

std::tuple might help too:

template <template <typename, typename...> class C, typename... Ts>
struct wrapper
{
    template <std::size_t I>
    std::tuple_element_t<I, std::tuple<C<Ts>...>>& get()
    {
        return std::get<I>(data);
    }

    std::tuple<C<Ts>...> data;
};

// Possible usage
void test(wrapper<std::vector, int, double, std::string>& example)
{
    [[maybe_unused]]int x = example.get<0>()[7];      // vector of `int`
    [[maybe_unused]]auto y = example.get<1>().size(); // vector of `double`
}

Demo

Note: std::vector has more than 1 template parameter (there is allocator which is defaulted).

great, thanks. btw, get can return `auto`. – Glenn Teitelbaum May 29 '22 at 16:54 — Glenn Teitelbaum, May 29 '22 at 16:54

Given a template class (A) and a parameter pack of types (T1, T2...), convert to a tuple like A, A, A

1 Answers1