具有静态绑定成员函数指针的可变参数模板的多重特化？

Question

是否可以对可变参数模板进行多个特化，其中模板参数之一是静态绑定的成员函数指针？

我正在尝试构建一个委托，其中回调函数是编译时常量，从而帮助优化器超越函数指针边界。

我有以下代码，其中将成员函数指针作为模板参数传递，并且由于函数指针是在编译时已知的常量，因此我的期望是优化器将能够通过函数指针边界进行工作。

我创建了 2 个委托， delegate0 和 delegate1，分别用于具有 0 和 1 个参数的成员函数。

#include <iostream>

template<class class_t, void (class_t::*mem_func_t)()>
struct delegate0
{
  delegate0( class_t *obj_ )
      : _obj(obj_)
  { }

  void operator()()
  {
    (_obj->*mem_func_t)();
  }

 private:
  class_t *_obj;
};

template<class class_t, typename arg0, void (class_t::*mem_func_t)(arg0)>
struct delegate1
{
  delegate1( class_t *obj_, arg0 a0_ )
      : _obj(obj_)
      , _a0(a0_)
  { }

  void operator()()
  {
    (_obj->*mem_func_t)(_a0);
  }

 private:
  class_t *_obj;
  arg0 _a0;
};

struct app
{
  void cb()
  {
    std::cout << "hello world\n";
  }
  void cb1(int i)
  {
    std::cout << "hello world " << i << "\n";
  }
};

int main()
{
  app* foo = new app;

  delegate0<app, &app::cb> f(foo);
  f();

  delegate1<app, int, &app::cb1> f1(foo, 5);
  f1();
}

但是，我想通过两种方式对此进行改进：

1. 参数数量的所有排列都是可变参数委托模板的专业化。
2. 使用模板参数推导，这样声明诸如 delegate<&app::cb> （当 cb 明确时）、class_t、mem_func_t、arg0、arg1 等...都是从app::cb 的签名。

我意识到成员函数指针不是类型，但就像您可以传递特定整数作为模板参数（元编程中使用的模板递归）一样，我认为您可以将特定的成员函数指针作为参数 - 从而允许静态绑定到该函数。

我所追求的可能吗？ 如果不行的话，上面的1或者2可以吗？ 我真的很感激一个有效的例子，因为我一直在用头撞键盘，但到目前为止还没有成功。

我有以下悲惨的尝试。这显然不是我想要的，但为了表明我一直在努力的方向，我认为包含它可能有用。

template<typename...>
struct delegate;

template<class class_t, void (class_t::*mem_func_t)()>
struct delegate<class_t, decltype(mem_func_t)> 
{
  delegate( class_t *obj_ )
      : _obj(obj_)
  { }

  void operator()(mem_func_t f)
  {
    (_obj->*f)();
  }

  class_t *_obj;
};

template<class class_t, typename arg0, void (class_t::*mem_func_t)(arg0)>
struct delegate<class_t, arg0, decltype(mem_func_t)>
{
  delegate( class_t *obj_, arg0 a0_ )
      : _obj(obj_)
      , _a0(a0_)
  { }

  void operator()()
  {
    (_obj->*mem_func_t)(_a0);
  }

  class_t *_obj;
  arg0 _a0;
};

Answer 1

声明一个采用任何类型的模板：

template <typename T, T value>
struct Delegate;

然后将其专门用于成员函数对象（为每个 cv 限定符执行 4 次）：

template <typename R, typename C, typename... A, R (C::* value)(A...) const>
struct Delegate<R(C::*)(A...) const, value>
{
   // do whatever you like with R, C, A... .
};

正如我之前回答的那样，您需要 decltype：

Delegate<decltype(&SomeClass::method), &SomeClass::method> del;

或者，您可以使用我的function_traits类能直接从 T 中提取 R、C 和 A...，因此您不需要专门化，但是仍然需要 decltype 并重复该方法。