C++ 获取可变模板可变模板参数可变模板参数可变参数

对

假设我有一个简单的变量结构，它包含一个typedef：

template<typename... TArgs> struct TupleTypeHolder {
    using TupleType = std::tuple<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)};  

#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{
使用TupleType=std:：tuple；
};
模板静态int getSomeValue（）{return 42；}
//主模板：
模板
结构元组生成器；
//部分专业化：
模板
结构元组生成器
{ 
std：：对值；
使用TupleType1=typename TT1:：TupleType；
使用TupleType2=typename TT2:：TupleType；
TupleMaker（）：someValues{getSomeValue（），
getSomeValue（）}{}
};
结构MyTupleMaker:TupleMaker
{ };
MyTupleMaker:：TupleType1 tuple1{newint（1），newchar（'a'）}；
MyTupleMaker:：TupleType2 tuple2{new int（35），new float（12.f）}；
int main（）{}

在传递类型时，主模板采用两种类型

TupleTypeHolder

是一种类型，是模板的专门化，而不是模板本身。但是，模板模板参数将模板作为参数（而不是类型），例如：

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

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

模板
结构条
{
使用type=Foo；
};
Barb；//注意：“std:：tuple”没有模板参数！

---

使用部分专用化，您可以将模板专用化拆分为模板和参数，这就是上面的工作方式。

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

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
};

其使用示例如下：

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

使用my_types=TupleTypeHolder；
使用my_tuple_type=typename tuple_maker:：tuple_type；

---

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

1）

t TupleTypeHolder

是一个模板，而不是一个类型。2） 您无法访问

A

（您传递的模板没有参数，因此没有可推断的参数）。在您的代码中

A

没有任何意义。它不是一个参数。它只是一个名字，没有任何意义。它更像是模板参数签名的一部分。请给出一个用法示例（一个

TupleMaker

的预期用法示例）。标题+1，如果没有其他内容的话（也是一个有趣的问题）。需要更多变量。回答得很好！我甚至不知道您可以使用部分模板专门化传递两个可变类型包这样的技巧，因为在主模板类型上，可变参数必须位于末尾，并且编译器不允许两个包。我真的开悟了！。。。然而，我觉得我应该变得非常开明，但却在中途睡着了+1.

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;