如何将模板参数重复附加到类型中

How can I append template arguments repeatedly to a type?

本文关键字：类型 参数      更新时间：2023-10-16

我想创建一个元函数Append，它采用模板化类型，并将N个类型为T的参数添加到模板中，例如，如果我调用Append<2, int, std::tuple<>>，我想获得std::tuple<int, int>。

以下是我尝试过的：

#include <tuple>                                                                
template <int N, typename T, template <class> class Seq, typename... Args>      
struct Append;                                                                  
template <int N, typename T, template <class> class Seq, typename... Args>      
struct Append<N, T, Seq<Args...>>                                               
{                                                                               
    using type = Append<N-1, T, Seq<Args..., T>>::type;                         
};                                                                              
template <typename T, template<class> class Seq, typename... Args>              
struct Append<0, T, Seq<Args...>>                                               
{                                                                               
    using type = Seq<Args...>;                                                  
};                                                                              
// create a big tuple with N number of "int" types in it                           
using T = Append<2, int, std::tuple<>>::type;                                      
int main()                                                                         
{                                                                                  
    return 0;                                                                      
}

然而，当我试图编译这个时，我得到了：

错误：模板参数列表中参数3的类型/值不匹配对于"template class Seq，class…"。。。Args>结构体附加'

我错过了什么？

下面我将解释一些小错误。这项工作：

#include <tuple>                                                                
template <int N, typename T, typename SeqWithArgs>      
struct Append;                                                                  
template <int N, typename T, template <typename...> class Seq, typename... Args >      
struct Append<N, T, Seq<Args...> >                                               
{                                                                               
    using type = typename Append<N-1, T, Seq<T,Args...> >::type;                         
};                                                                              
template <typename T, template<typename...> class Seq, typename... Args>              
struct Append<0, T, Seq<Args...> >                                               
{                                                                               
    using type = Seq<Args...>;                                                  
};                                                                              
// create a big tuple with N number of "int" types in it                           
using T = Append<2, int, std::tuple<> >::type;                                      
static_assert(std::is_same<T,std::tuple<int,int>>::value,"Didn't work");
int main()                                                                         
{                                                                                  
    return 0;                                                                      
}

一个问题出现在您的非专用模板类中：您希望它有三个参数，其中第三个实际上是一个类型，而不是模板类（将您的调用与tuple<>进行比较）。这就是出现错误的原因，因为您传递了一个类型，而编译器需要一个模板。

然后，对于专业化，您现在想要推导模板-模板参数，因此模板及其模板参数分为Seq和Args的四个模板参数实际上是正确的。然而，它必须是一个可变的模板类（而不仅仅是问题中的template <class> class Seq），因为否则，在第二次迭代中一个接一个地添加模板参数将失败。

最后，在从属名称Append<[...]>::type前面需要一个typename。

相关文章：