如何在一个可变模板中拥有多个参数包

以下是使用模板模板参数获得多个参数包的另一种方法：

#include <iostream>
template <typename... Types>
struct foo {};
template < typename... Types1, template <typename...> class T
         , typename... Types2, template <typename...> class V
         , typename U >
void
bar(const T<Types1...>&, const V<Types2...>&, const U& u)
{
  std::cout << sizeof...(Types1) << std::endl;
  std::cout << sizeof...(Types2) << std::endl;
  std::cout << u << std::endl;
}
int
main()
{
  foo<char, int, float> f1;
  foo<char, int> f2;
  bar(f1, f2, 9);
  return 0;
}

我找到了一个解决方案。将每个参数包包裹在一个元组中。使用结构进行部分专门化。这里有一个演示，通过将一个元组作为列表并累积另一个元组，将参数转发到函子。好吧，这个是通过复制转发的。元组用于类型推导，但函数参数中没有使用元组，我认为这很巧妙。

#include <iostream>
#include <tuple>
template < typename ... >
struct two_impl {};
// Base case
template < typename F,
           typename ...Bs >
struct two_impl < F, std::tuple <>, std::tuple< Bs... > >  {
  void operator()(F f, Bs... bs) {
    f(bs...);
  }
};
// Recursive case
template < typename F,
           typename A,
           typename ...As,
           typename ...Bs >
struct two_impl < F, std::tuple< A, As... >, std::tuple< Bs...> >  {
  void operator()(F f, A a, As... as, Bs... bs) {
    auto impl = two_impl < F, std::tuple < As... >, std::tuple < Bs..., A> >();
    impl(f, as..., bs..., a);
  }
};
template < typename F, typename ...Ts >
void two(F f, Ts ...ts) {
  auto impl = two_impl< F, std::tuple < Ts... >, std::tuple <> >();
  impl(f, ts...);
}
struct Test {
  void operator()(int i, float f, double d) {
    std::cout << i << std::endl << f << std::endl << d << std::endl;
  }
};
int main () {
  two(Test(), 1, 1.5f, 2.1);
}

元组是一个非常好的编译时列表。

如果模板参数包后面的每个模板参数都有默认值或可以推导，则函数模板（如skypjack的示例）以及类和变量模板的部分专门化可以具有多个参数包。我唯一想补充/指出的是，对于类和变量模板，您需要部分专业化。（参见：C++模板，完整指南，Vandevoorde，Josuttis，Gregor 12.2.4，第二版）

// A template to hold a parameter pack
template < typename... >
struct Typelist {};
// Declaration of a template
template< typename TypeListOne 
        , typename TypeListTwo
        > 
struct SomeStruct;
// Specialization of template with multiple parameter packs
template< typename... TypesOne 
        , typename... TypesTwo
        >
struct SomeStruct< Typelist < TypesOne... >
                 , Typelist < TypesTwo... >
                 >
{
        // Can use TypesOne... and TypesTwo... how ever
        // you want here. For example:
        typedef std::tuple< TypesOne... > TupleTypeOne;
        typedef std::tuple< TypesTwo... > TupleTypeTwo;
};      

编译器需要一种方法来知道两个可变模板之间的屏障在哪里。一个干净的方法是为对象定义一组参数，为静态成员函数定义第二组参数。这可以通过在彼此中嵌套多个结构来应用于两个以上的可变模板。（保持最后一级功能）

#include <iostream>
template<typename... First>
struct Obj
{
    template<typename... Second>
    static void Func()
    {
        std::cout << sizeof...(First) << std::endl;
        std::cout << sizeof...(Second) << std::endl;
    }
};
int main()
{
    Obj<char, char>::Func<char, char, char, char>();
    return 0;
}