我有一个接受多个 bool 模板参数的函数:

template<bool par1, bool par2, bool par2>
void function(int arg1, int arg2, int arg3);

我想在编译时(使用任何模板魔术，如果需要使用 C++11)自动生成一个函数指针表(或类似于 C++ 元编程的有趣结构的东西)到所有组合模板参数 par* 的值，这样我就可以构造一个函数，将这些模板参数作为运行时参数并转发到正确的模板实例化:

void runtime_function(bool par1, bool par2, bool par3, int arg1, int arg2, int arg3);

我认为如果不是模板函数而是想对类做同样的事情，我认为这是可以做到的，这要归功于模板模板参数:

template<template<bool> class T> class CombinationsOfTemplateParameters;
template<template<bool, bool> class T> class CombinationsOfTemplateParameters;
template<template<bool, bool, bool> class T> class CombinationsOfTemplateParameters;
//and so on, up to some implementation defined hard limit.

但据我所知，没有办法指向一个通用的模板函数，而不指定它的模板参数。因此，我一开始就不知道如何将它传递给模板参数列表中的某个辅助类。

有没有办法解决这个问题？

最佳答案

第一步，为了理解问题，我将在每个实例化时构造一个函数指针数组:

template<bool, bool, bool> void function(int, int, int);

typedef void (*func_type)(int, int, int);

func_type funcs[] = {
    &function<false, false, false>,
    &function<false, false, true>,
    &function<false, true,  false>,
    &function<false, true,  true >,
    &function<true,  false, false>,
    &function<true,  false, true >,
    &function<true,  true,  false>,
    &function<true,  true,  true >
};

注意它看起来像一个 3 位二进制数表:

0 0 0  == 0
0 0 1  == 1
0 1 0  == 2
0 1 1  == 3
// etc...

因此您可以使用按位运算形成的整数索引到数组中:

void runtime_function(bool par1, bool par2, bool par3, int arg1, int arg2, int arg3)
{
  func_type f = funcs[ int(par1)<<2 | int(par2)<<1 | int(par3) ];
  f(arg1, arg2, arg3);
};

第二步，既然我已经了解了如何构建数组并使用它，我将使用可变参数模板自动生成数组，而不是手动写出来。

首先使用创建整数参数包的类型(使用 Johannes Schaub 的 seq 模板):

template<int ...>
struct seq { };

template<int N, int ...S>
struct gens : gens<N-1, N-1, S...> { };

template<int ...S>
struct gens<0, S...> {
  typedef seq<S...> type;
};

然后在包扩展中使用它来生成每个可能的实例:

template<bool, bool, bool> void function(int, int, int);

typedef void (*func_type)(int, int, int);

template<typename> struct make_table;

template<int... N>
  struct make_table<seq<N...>>
  {
    static const func_type funcs[sizeof...(N)];
  };

template<int... N>
  const func_type make_table<seq<N...>>::funcs[sizeof...(N)] = {
    &function< bool(N&4), bool(N&2), bool(N&1) >...
  };

现在你可以像这样使用它了:

void runtime_function(bool par1, bool par2, bool par3, int arg1, int arg2, int arg3)
{
  typedef gens<8>::type seq8;

  func_type f = make_table<seq8>::funcs[ (par1<<2) | (par2<<1) | par3 ];

  f(arg1, arg2, arg3);

}

神奇的数字8是2的3次方(bool参数个数。)

第三步，测试。我相当有信心，如果我弄错了核心逻辑，它甚至不会编译，因为编译器会检查所有类型和包扩展，但我可能弄错了按位运算。

#include <iostream>

template<bool b1, bool b2, bool b3>
  void function(int i1, int i2, int i3){
    std::cout << std::boolalpha << "f<"
      << b1 << ", " << b2 << ", " << b2
      << ">("
      << i1 << ", " << i2 << ", " << i3
      << ")\n";
}

int main()
{
  runtime_function(false, true, true, 1, 2, 3);
  runtime_function(true, false, false, 4, 5, 6);
}

它打印:

f<false, true, true>(1, 2, 3)
f<true, false, false>(4, 5, 6)

完全通用的版本

要为具有四个 bool 模板参数的函数模板执行此操作，您需要使用 gens<16>并更改包扩展

template<int... N>
  const func_type make_table<seq<N...>>::funcs[] = {
    &function< bool(N&8), bool(N&4), bool(N&2), bool(N&1) >...
  };

这不是很方便，所以通过引入另一个整数参数包 seq<3,2,1,0> 应该可以将其泛化为处理任意数量的参数并像这样使用它:

template<int... N, int... Bits>
  const func_type make_table<seq<N...>, seq<Bits...>>::funcs[] = {
    &function< /* some bitwise op using N & (1<<Bits) ... */ > ...
  };

但这行不通，因为我们想要使用 Bits 进行包扩展但我们不希望它扩展N同时(包有不同的大小，所以它无论如何都行不通，)所以我们需要使用一个间接级别来允许包单独扩展。

下面的最终版本使用了一个函数 gen_func<N>获取索引 N 处的函数指针:

template<unsigned N, int... Mask>
  static constexpr func_type gen_func(seq<Mask...>)
  { return &function<(N&(1<<Mask))...>; }

并添加 genrevs创建整数的反向序列，seq<2,1,0> , 它被传递给该函数用作 Mask参数包:

gen_func<I>(typename genrevs<NParams>::type()) ...

有了这个改变 make_table类模板可以处理任何数量的函数，所以最后一步是通过函数类型对其进行参数化(并让它推断出参数的数量，并从中推断出可能的函数特化数量)并向 make_table 添加一个访问器。获得正确的功能:

void runtime_function(bool par1, bool par2, bool par3, int arg1, int arg2, int arg3)
{
  auto f = make_table<void(int, int, int)>::get(par1, par2, par3);

  f(arg1, arg2, arg3);
}

这是完整的最终版本。昨晚写完这段代码后，我意识到它假定函数参数的数量 (int, int, int)与模板参数个数相同<bool, bool, bool> ，如果那不是真的那么你需要添加一个额外的非类型模板参数到 make_table , 指定模板参数的数量(在下面的代码中是 NParams 并推导出来):

#include <type_traits>

template<int ...>
struct seq { };

template<int N, int ...S>
struct gens : gens<N-1, N-1, S...> { };

template<int ...S>
struct gens<0, S...> {
  typedef seq<S...> type;
};

template<int N, int ...S>
struct genrevs : genrevs<N-1, S..., N-1> { };

template<int ...S>
struct genrevs<0, S...> {
  typedef seq<S...> type;
};

template<bool, bool, bool> void function(int, int, int);

template<unsigned N>
  struct pow2
  {
    static constexpr unsigned value = 2*pow2<N-1>::value;
  };

template<> struct pow2<0> { static constexpr unsigned value = 1; };

template<typename Signature> struct make_table_seq;

template<typename Res, typename... Params>
  struct make_table_seq<Res(Params...)>
  : gens<pow2<sizeof...(Params)>::value>
  { };

template<typename Signature, typename = typename make_table_seq<Signature>::type>
struct make_table;

template<typename Res, typename... Params, int... I>
  class make_table<Res(Params...), seq<I...>>
  {
    static const unsigned NParams = sizeof...(Params);

  public:
    typedef Res (*func_type)(Params...);

    template<typename... Bool>
      static typename std::enable_if<sizeof...(Bool)==NParams, func_type>::type
      get(Bool... b)
      { return funcs[ shift_or(0, b...) ]; }

  private:
    template<unsigned N, int... Mask>
      static constexpr func_type gen_func(seq<Mask...>)
      { return &function<(bool(N&(1<<Mask)))...>; }

    template<typename... Bool>
      static int shift_or(int i, bool b0, Bool... b)
      {
        return shift_or((i<<1) | int(b0), b...);
      }

    static int shift_or(int i) { return i; }

    static const func_type funcs[sizeof...(I)];
  };

template<typename Res, typename... Params, int... I>
  const typename make_table<Res(Params...), seq<I...>>::func_type
  make_table<Res(Params...), seq<I...>>::funcs[] = {
    gen_func<I>(typename genrevs<NParams>::type()) ...
  };

// specialise for function pointer types as well as function types
template<typename Res, typename... Params>
  struct make_table_seq<Res(*)(Params...)>
  : make_table_seq<Res(Params...)>
  { };

template<typename Res, typename... Params, typename T>
  class make_table<Res(*)(Params...), T>
  : make_table<Res(Params...)>
  { };

关于c++ - 使用模板元编程将模板函数 bool 参数转置为运行时函数参数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11023384/