Question

我正在尝试构建一个静态绑定的委托类，其中成员函数在编译时绑定，从而帮助优化。

我有以下代码，它完全符合我的要求：

#include <iostream>

namespace thr {

template<typename T, T func>
struct delegate;

template<typename R,
         typename C,
         typename... A,
         R  (C::* mem_fun)(A...)>
struct delegate<R(C::*)(A...), mem_fun>
{ 
  delegate(C* obj_)
    : _obj(obj_)
  {}

  R operator()(A... a)
  {
    return (_obj->*mem_fun)(a...);
  }
 private:
  C* _obj;
};

} // namespace thr

struct foo
{
  double bar(int i, int j)
  { 
    return (double)i / (double)j;
  } 
};

int main()
{
  foo f;

  typedef thr::delegate<decltype(&foo::bar), &foo::bar> cb;      
  cb c(&f);

  std::cout << c(4, 3);
  return 0;
}

然而，使用不是很优雅：

thr::delegate<decltype(&foo::bar), &foo::bar>

我想使用一个函数模板来推导模板参数并返回一个委托实例;一些事情（这段代码不能编译）：

template<typename C, typename T, T func>
thr::delegate<T, func> bind(T func, C* obj)
{
  return thr::delegate<decltype(func), func>(obj);
}

这将允许更优雅的语法：

auto cb = bind(&foo::bar, &f);

是否可以在函数模板中推导出非类型参数？

我正在努力实现的目标是什么？

Answer 1

std :: function会有帮助吗？ http://www2.research.att.com/~bs/C++0xFAQ.html#std-function你的例子非常接近。

我认为编译器提供的STL做了非常可怕的事情，以使其顺利运行。在放弃之前，你可能想看一个例子。

编辑：我出去尝试了你想要完成的事情。我的结论是编译错误：

bind（委托）的返回类型必须将指针命名为member，因为这是你自己的要求。
bind应该接受指向成员的指针的名称（即你的要求）
编译器要求您不要使用函数参数隐藏模板参数，或者在参数和返回类型中使用名称。

因此，您的要求必须符合您的要求。

编辑2：我冒昧地改变了你的委托，所以bind可以按你的意愿工作。绑定可能不是你的首要任务。

#include <iostream>

namespace thr {


template<typename C,typename R,typename... A>
struct delegate
{ 
 private:
  C* _obj;
  R(C::*_f)(A...);
  public:
  delegate(C* obj_,R(C::*f)(A...))
    : _obj(obj_),_f(f)
  {}

  R operator()(A... a)
  {
    return (_obj->*_f)(a...);
  }

};

} // namespace thr

template<class C,typename R,typename... A> thr::delegate<C,R,A...> bind(R(C::*f)(A...),C* obj){
    return thr::delegate<C,R,A...>(obj,f);
}

struct foo
{
  double bar(int i, int j)
  { 
    return (double)i / (double)j;
  }
};

int main()
{
  foo f;
  auto c = bind(&foo::bar, &f);
  std::cout << c(4, 6);
  return 0;
}

Answer 2

可以在函数签名中推导出除类型之外的其他实体，但函数参数本身不能用作模板参数。

假设：

template <size_t I> struct Integral { static size_t const value = I; };

你可以：

template <size_t N>
Integral<N> foo(char const (&)[N]);

但你不能拥有：

Integral<N> bar(size_t N);

在前一种情况下，N作为数组的大小是参数类型的一部分，在后一种情况下，N是参数本身。可以注意到，在前一种情况下，N出现在类型签名的模板参数列表中。

因此，如果你想要的确是可能的，那么成员指针 value 必须作为函数签名的模板参数列表的一部分出现。

使用constexpr可能会有一个保存宽限，可以将常规值转换为模板参数的常量值：

constexpr size_t fib(size_t N) { return N <= 1 ? 1 : fib(N-1) + fib(N-2); }

Integral<fib(4)> works;

但我不够精明，不能走那条路......

但我有一个简单的问题：为什么你认为这会加快速度？编译器非常擅长于常量传播和内联，以便能够在编译时评估变量的动态类型时内联调用虚函数。你确定值得大汗淋漓吗？

模板参数推导指向成员函数的指针？

2 个答案: