说我有
class Foo
{
public:
Foo(std::function<void(std::string)> callback1,
std::function<void(int)> callback2) :
callback1(callback1), callback2(callback2)
{
}
private:
std::function<void(std::string)> callback1;
std::function<void(int)> callback2
}
我可以在使用普通函数
的情况下轻松构建它void callback1Handler(std::string)
{
// i'm a potato
}
void callback2Handler(int)
{
// i'm a teapot
}
int main()
{
Foo foo(callback1Handler, callback2Handler);
return 0;
}
但如果我使用课程,那么事情会变得复杂。
我希望能够做the Addendum of this answer does
之类的事情class Main
{
public:
Main()
{
Foo foo(&Main::callback1Handler, &Main::callback2Handler);
}
void callback1Handler(std::string)
{
// i'm a potato
}
void callback2Handler(int)
{
// i'm a teapot
}
}
但显然不会编译。为了使其工作,需要使用std::bind
或lambdas,或其他。
我想尽量避免std::bind(&Main::callbackNHandler, this, std::placeholders::_1, ..., std::placeholders::_N)
的丑陋,这主要是明确规定这些占位符的丑陋。
将lambdas用作[=](std::string str){callbackNHandler(str);}
也很难看,因为你必须指定回调接受的每个变量。
如果我可以使用&Main::callback1Handler
,就像在Main
类示例中那样,或者&Main::callback1Handler, this
,这会更灵活,因为您可以指定实例指针Main
。
请注意,Foo
构造函数必须保持不变,callback1
和callback2
成员变量也必须保持不变。但是,您可以重载Foo
构造函数,将重载转换方法指针(或其他任何您要接受的内容)指向std::function
并将它们存储在callback1
&amp; {{1 }}
答案 0 :(得分:4)
template<class T, class R, class...Args>
std::function<R(Args...)> method( T* t, R(T::*m)(Args...) ){
return [=](Args&&...args)->R{
return (t->*m)(std::forward<Args>(args)...);
};
}
然后method( instance, &Main::callback1Handler )
应该有效,直到拼写错误。
在C ++ 14中变得更简单。
上面做了不必要的类型擦除:辅助类型而不是lambda可以避免这种情况。
template<class T, class Sig>
struct method_t;
template<class T, class R, class... Args>
struct method_t<T,R(Args...)> {
T* t;
R(T::*m)(Args...);
template<class...Ts>
R operator()(Ts&&...ts)const{
return (t->*m)(std::forward<Ts>(ts)...);
}
};
template<class T, class R, class...Args>
method_t<T, R(Args...)> method( T* t, R(T::*m)(Args...) ){
return {t, m};
}
具有相同的签名。它甚至可以存储在std::function<R(Args...)>
中。上述优点是,如果std::function
的签名不完全匹配,或者根本不使用std::function
,则不会产生不必要的开销。
缺点是代码的3倍。
在C ++ 14中我们可以做到:
template<class T, class R, class...Args>
auto method( T* t, R(T::*m)(Args...) ){
return [=](auto&&...args)->R{
return (t->*m)(decltype(args)(args)...);
};
}
与第一个一样简短,与第二个一样强大。
答案 1 :(得分:2)
将lambdas用作
[=](std::string str){callbackNHandler(str);}
也很难看,因为你必须指定回调接受的每个变量。
C ++ 14泛型lambdas解决了这个问题:
[this](auto... args){ callback1Handler(args...); }
对于C ++ 11,您可以编写一个可以像这样使用的简单实用程序:
Foo foo(simple_bind(&Main::callback1Handler, this),
simple_bind(&Main::callback2Handler, this));
这将被定义为这样的函数模板:
template<typename T, typename F>
SimpleBinder<T, F>
simple_bind(F T::* memfn, T* that)
{ return { that, memfn }; }
类型SimpleBinder<T, F>
只是:
template<typename T, typename F>
struct SimpleBinder
{
T* m_this;
F T::* m_memfn;
template<typename... Args>
void operator()(Args&&... args)
{ (m_this->*m_memfn)(std::forward<Args>(args)...); }
};
这不是完全通用的实用程序(例如,它不会对成员函数的返回类型执行任何操作,始终返回void
,但这可以满足您的要求,其中这两个std::function
对象都返回void
,但它解决了将任意成员函数与this
指针相关联,然后用一组参数调用它的问题。
虽然SimpleBind
对象似乎接受任何参数,但实际上如果你试图用不与它绑定的成员函数兼容的参数调用它,你会得到一个讨厌的编译器错误。同样,这不是问题,因为您存储它的std::function
对象将确保只传递正确类型的参数。