在不使用 std::bind 的情况下获取成员函数的 c++11 函数包装器

Question

我正在尝试实现一个基本的信号/插槽系统。一切都已启动并正在运行，但我正在努力提高我的实现的可用性。

目前这是连接信号的方式：

struct X
{
    void memberFunction(int a, int b)
    {
         // do something
    }
};

void globalStaticFunction(int a, int b)
{
    // do something
}

// this is what the signal::connect function looks like at the moment
ConnectionHandle connect(std::function<RetType(Args...)> func);


int main()
{
    // test instance
    X x;

    // example signal
    Signal<void(int, int)> mySignal;


    // connect a static function to the signal
    mySignal.connect(&globalStaticFunction);

    // connect a member function
    // here we have to use std::bind to get a std::function
    mySignal.connect(std::bind(&X::memberFunction, &x, _1, _2));
}

我想为用户提供一种更简单的方法来绑定成员函数。我有这样的想法（类似于 Qt 的做法）：

// prefered member function connect
// connect(instance_ptr, function_ptr)
mySignal.connect(&x, &X::memberFunction);

是否可以在不使用 std::bind 的情况下为成员函数获取 std::function 对象？如果没有，是否有一种简单的方法可以只使用成员函数的 instance_ptr 和 function_ptr 生成 std​​::bind 调用？

Answer 1

作为Signal的成员：

template<typename C>
ConnectionHandle connect( C* c, RetType(C::*func)(Args...)) {
  return connect( [c,func](Args&&...args) {
    return (c->*func)( std::forward<Args>(args)... );
  });
}

template<typename C, typename Method, typename... Unused>
ConnectionHandle connect( C* c, Method* m, Unused&&...) {
  return connect( [c,func](Args&&...args) {
    return (c->*m)( std::forward<Args>(args)... );
  });
}

第一个重载使您能够区分重载方法。

第二个，如果第一个失败，让你使用签名兼容的方法。

... 部分确保第一个是更好的匹配，如果它们都匹配（我希望！）

Args&&... 应该与std::function 一起使用，假设std::function 正确地完美转发。如果不是，请替换为Args...。

我认为不需要bind 或变体，因为无论如何我们都会立即将其填充到std::function 中。创建一个 lambda，它们非常适合这项任务。

Answer 2

这个技巧在 C++03 中很好，但是对于 C++11，请使用 Yakk 的答案。

类似的东西可能会起作用。

首先：制作一个简单版本的bind，它只绑定this。

template<class T, class RetType, class...Args>
RetType CallMemFn(T* obj, RetType(T::*func)(Args...), Args...args)
{return ((*obj).*(func))(std::forward<Args>(args)...);}

template<class T, class RetType, class...Args>
struct boundthis {
    typedef RetType result_type;
    typedef T* thistype;
    typedef RetType(*signature)(Args...);
    boundthis(T* self, RetType(T::*func)(Args...)) :self(self), func(func) {}
    RetType operator()(Args...args) {return CallMemFn(self,func,std::forward<Args>(args)...);}
private:
    T* self;
    RetType(T::*func)(Args...);
};
template<class T, class RetType, class...Args>
boundthis<T,RetType,Args...> bindthis(T* self, RetType(T::*func)(Args...))
{return boundthis<T,RetType,Args...>(self, func);}

最后，你想要的包装器：

template<class T, class RetType, class...Args>
ConnectionHandle connect(T* obj, RetType(T::*func)(Args...))
{return connect(std::function<RetType(Args...)>(bindthis(obj, func)));}

http://ideone.com/a2rze0