说我有
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)
,这主要是明确指定这些占位符的丑陋之处。
将 lambda 用作 [=](std::string str){callbackNHandler(str);}
也很丑陋,因为您必须指定回调接受的每个变量。
如果我可以只使用 &Main::callback1Handler
就好了,就像在 Main
类示例中一样,或者 &Main::callback1Handler,this
,这更灵活一些,因为您可以指定 Main
的实例指针。
请注意,Foo
构造函数必须保持不变,callback1
&callback2
成员变量也必须保持不变。但是,您可以重载 Foo
构造函数,使重载转换方法指针(或您将接受的任何其他内容)为 std::function
并将它们存储在 callback1
&callback2
.
最佳答案
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)...);
};
}
和第一个一样简短,和第二个一样强大。
关于c++ - 如何使构造函数接受 std::function 也接受方法指针,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/28975945/