c++ - 具有静态绑定(bind)成员函数指针的可变参数模板的多个特化？

Question

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

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

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

我创建了 2 个委托(delegate)，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. 参数数量的所有排列都是可变委托(delegate)模板的特化。
2. 使用模板参数推导来声明类似delegate<&app::cb> 的内容(当 cb 没有歧义时)、class_t、mem_func_t、arg0、arg1 等...都是从 app::cb 的签名推导出来的。 .

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

我所追求的是可能的吗？如果不是，上面的 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;

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