获取可变参数模板可变参数模板参数可变参数参数答案

【问题标题】：Get variadic template variadic template parameter variadic parameters获取可变参数模板可变参数模板参数可变参数参数
【发布时间】：2013-10-10 14:22:27
【问题描述】：

是的。

假设我有一个包含 typedef 的简单可变参数结构：

template<typename... TArgs> struct TupleTypeHolder {
    using TupleType = std::tuple<TArgs*...>;
};

我想将TupleTypeHolder<something> 作为模板参数传递给另一个类，并获取该类型定义。

我所有的尝试都没有编译。

// None of these is valid
template<template<typename...> class TTupleTypeHolder> struct TupleMaker {
     using MyTupleType = TTupleTypeHolder::TupleType; // Not valid
     using MyTupleType = typename TTupleTypeHolder::TupleType; // Not valid
};

 template<template<typename... A> class TTupleTypeHolder> struct TupleMaker2 {
     // A is not a valid name here
     using MyTupleType = TTupleTypeHolder<A...>::TupleType; // Not valid
     using MyTupleType = typename TTupleTypeHolder<A...>::TupleType; // Not valid
};

有没有办法从使用上述类作为模板可变参数模板参数的类中使用可变参数模板类的可变参数模板参数（在本例中为TupleTypeHolder 的TArgs...）？

使用示例：

template<typename... TArgs> struct TupleTypeHolder {
    using TupleType = std::tuple<TArgs*...>;
};

template<typename... TArgs> static int getSomeValue() { ... }

template<??? T1, ??? T2> class TupleMaker 
{ 
    std::pair<int, int> someValues;

    using TupleType1 = T1::TupleType;
    using TupleType2 = T2::TupleType;

    TupleMaker() : someValues{getSomeValue<T1's TArgs...>(), 
                             getSomeValue<T2's TArgs...>()} { }
};

class MyTupleMaker : TupleMaker<TupleTypeHolder<int, char>, 
                                TupleTypeHolder<int, float>> 
{ };

MyTupleMaker::TupleType1 tuple1{new int(1), new char('a')};  
MyTupleMaker::TupleType2 tuple1{new int(35), new float(12.f)};

【问题讨论】：

1) TTupleTypeHolder 是一个模板，而不是一个类型。 2）您无权访问A（您传递了一个没有参数的模板，因此没有要推断的参数）。
在您的代码中A 没有任何意义。它不是一个参数。这只是一个名字，没有任何意义。它更像是模板模板参数的签名的一部分。
请显示一个用法示例（TupleMaker 的预期用法示例）。
标题+1，如果没有别的（但也很有趣的问题）。
需要更多可变铃。

标签： c++ templates c++11 variadic-templates template-templates

【解决方案1】：

工作使用示例：

#include <tuple>

template<typename... TArgs> struct TupleTypeHolder {
    using TupleType = std::tuple<TArgs*...>;
};

template<typename... TArgs> static int getSomeValue() { return 42; }

// primary template:
template<class T1, class T2>
struct TupleMaker;

// partial specialization:
template<template<class...> class TT1, template<class...> class TT2,
         class... T1, class... T2>
struct TupleMaker < TT1<T1...>, TT2<T2...> >
{ 
    std::pair<int, int> someValues;

    using TupleType1 = typename TT1<T1...>::TupleType;
    using TupleType2 = typename TT2<T2...>::TupleType;

    TupleMaker() : someValues{getSomeValue<T1...>(), 
                              getSomeValue<T2...>()} { }
};

struct MyTupleMaker : TupleMaker<TupleTypeHolder<int, char>, 
                                TupleTypeHolder<int, float>> 
{ };

MyTupleMaker::TupleType1 tuple1{new int(1), new char('a')};  
MyTupleMaker::TupleType2 tuple2{new int(35), new float(12.f)};  

int main() {}

当您传递类型时，主模板有两种类型。 TupleTypeHolder<int, char> 是一种类型，是模板的特化，而不是模板本身。但是模板 template-parameters 将 templates 作为参数（不是类型），例如：

template<template<class...> class Foo>
struct Bar
{
    using type = Foo<int, double, char>;
};

Bar< std::tuple > b; // note: no template arguments for `std::tuple`!

通过部分特化，您可以将模板特化拆分为模板和参数，这就是上面的工作原理。

【讨论】：

很好的答案！我什至不知道您可以使用部分模板专业化传递两个可变参数类型包这样的技巧，因为在主模板类型上存在可变参数必须位于末尾的限制，并且编译器不允许两个包。我真的开悟了！
...虽然我觉得我应该已经变得非常开明，但中途却睡着了。 +1

【解决方案2】：

模板模板参数不是真正的类型参数，是指定模板的参数。这意味着您通过模板模板参数传递的不是类型，而是模板：

template<template<typename> class TPARAM>
struct give_me_a_template
{
    using param = TPARAM; //Error TPARAM is not a type, is a template.
    using param_bool = TPARAM<bool>; //OK, thats a type
};

如您所见，第一个别名无效，因为 TPARAM 不是类型，是模板。但第二个是一个类型（是模板的一个实例）。

也就是说，检查您的问题：您所谓的TupleTypeHolder 可以被视为可变参数模板类型列表。所以你的目标是制作类型列表指定类型的元组，对吧？

您可以使用部分特化来提取类型列表的内容：

template<typename TupleTypeHolder>
struct tuple_maker;

template<typename... Ts>
struct tuple_maker<TupleTypeHolder<Ts...>>
{
    using tuple_type = std::tuple<Ts...>;
};

其用法示例如下：

using my_types = TupleTypeHolder<int,int,int>;
using my_tuple_type = typename tuple_maker<my_types>::tuple_type;

当然，这不是您实现的确切解决方案，您需要将概念扩展到多个类型列表（如您的问题所示）。我提供的是理解问题及其解决方案的指南。

【讨论】：