Extract template template parameter and variadic template parameter from class template

Question

Given the following class template:

template <template <typename... Args> class Container, typename... Args>
struct container_type_holder {};

I would like to extract its template template parameter and its variadic parameter to reuse in another context. Example:

using c1 = container_type_holder<std::map, std::string, int>;
using c2 = container_type_holder<tt_parameter<c1>, vt_parameter<c1>>;

Where tt_parameter<c1> is some magic trick to extract the template template parameter from c1 and vt_parameter<c1> to extract its variadic template parameter.

In order to extract the template template parameter I tried to add an alias inside container_type_holder, but that didn't work because it is not a complete type. To extract the variadic template parameter I tried the same strategy but with no success.

template <template <typename... Args> class Container, typename... Args>
struct container_type_holder 
{
    using container = Container; // doesnt work
    using args = Args...; // ???
};

I don't know if this is possible or not, I'm a begginer in the template world.

The `using` directive only works on a single type, but here `Container` is an uninstantiated template and `Args...` is a parameter pack. — Henri Menke, Aug 04 '18 at 06:59

score 2 · Accepted Answer · answered Aug 04 '18 at 06:52

You might use those aliases to be allowed to retrieve template parameters:

template <template <typename... Args> class Container,
          typename... Args>
struct container_type_holder 
{
    template <typename ... Ts>
    using container = Container<Ts...>;

    constexpr std::size arg_count = sizeof...(Args);

    using args_as_tuple = std::tuple<Args...>;

    template <std::size_t I>
    using get_arg = typename std::tuple_element<I, std::tuple<Args...>::type;

// And possibly helpers, such as

    template <template <typename ...> OtherContainer>
    using template_rebind = container_type_holder<OtherContainer, Args...>;
};

and then, usage might be:

using c1 = container_type_holder<std::map, std::string, int>;
using c2 = c1::template_rebind<std::unordered_map>;
using c3 = container_type_holder<std::vector, std::pair<c1::get_arg<0>, c1::get_arg<1>>>;

score 1 · Answer 2 · answered Aug 03 '18 at 21:16

I don't think it's possible what you ask but... are you sure you can't write the container_type_holder simply receiving a type

template <typename>
struct container_type_holder;

and develop your struct as a partial specialization ?

template <template <typename... Args> class Container, typename... Args>
struct container_type_holder<Container<Args...>> 
 {
   // ...
 };

This way is the container_type_holder specialization itself that extract the template-template paramenter and variadic list

I mean: if you declare an object

container_type_holder<std::map<std::string, int>>  obj;

in the specialization you have that Container is std::map and that Args... is std::string, int.

Extract template template parameter and variadic template parameter from class template

2 Answers2

Linked