对于一个类，我想在一个存储std::function对象的映射中存储一些指向同一类的成员函数的函数指针。但我一开始就写错了这段代码:
#include <functional>
class Foo {
public:
void doSomething() {}
void bindFunction() {
// ERROR
std::function<void(void)> f = &Foo::doSomething;
}
};
我收到错误C2064: term没有在xxcallobj中计算为一个接受0参数的函数，并结合了一些奇怪的模板实例化错误。目前我正在用Visual Studio 2010/2011在Windows 8上工作，用VS10在Win 7上工作，它也失败了。这个错误一定是基于我没有遵循的一些奇怪的c++规则
当前回答
如果你需要存储一个没有类实例的成员函数，你可以这样做:
class MyClass
{
public:
void MemberFunc(int value)
{
//do something
}
};
// Store member function binding
auto callable = std::mem_fn(&MyClass::MemberFunc);
// Call with late supplied 'this'
MyClass myInst;
callable(&myInst, 123);
如果没有auto，存储类型会是什么样子? 就像这样:
std::_Mem_fn_wrap<void,void (__cdecl TestA::*)(int),TestA,int> callable
还可以将此函数存储传递给标准函数绑定
std::function<void(int)> binding = std::bind(callable, &testA, std::placeholders::_1);
binding(123); // Call
过去和将来的注意事项:存在一个较旧的接口std::mem_func，但已弃用。在c++ 17之后，存在一个提议，将指向成员函数的指针设为可调用的。这将是最受欢迎的。
其他回答
如果您希望在底层实现不那么通用的、更精确的控制，则可以使用函子。示例与我的win32 api转发api消息从一个类到另一个类。
IListener.h
#include <windows.h>
class IListener {
public:
virtual ~IListener() {}
virtual LRESULT operator()(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) = 0;
};
Listener.h
#include "IListener.h"
template <typename D> class Listener : public IListener {
public:
typedef LRESULT (D::*WMFuncPtr)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
private:
D* _instance;
WMFuncPtr _wmFuncPtr;
public:
virtual ~Listener() {}
virtual LRESULT operator()(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) override {
return (_instance->*_wmFuncPtr)(hWnd, uMsg, wParam, lParam);
}
Listener(D* instance, WMFuncPtr wmFuncPtr) {
_instance = instance;
_wmFuncPtr = wmFuncPtr;
}
};
Dispatcher.h
#include <map>
#include "Listener.h"
class Dispatcher {
private:
//Storage map for message/pointers
std::map<UINT /*WM_MESSAGE*/, IListener*> _listeners;
public:
virtual ~Dispatcher() { //clear the map }
//Return a previously registered callable funtion pointer for uMsg.
IListener* get(UINT uMsg) {
typename std::map<UINT, IListener*>::iterator itEvt;
if((itEvt = _listeners.find(uMsg)) == _listeners.end()) {
return NULL;
}
return itEvt->second;
}
//Set a member function to receive message.
//Example Button->add<MyClass>(WM_COMMAND, this, &MyClass::myfunc);
template <typename D> void add(UINT uMsg, D* instance, typename Listener<D>::WMFuncPtr wmFuncPtr) {
_listeners[uMsg] = new Listener<D>(instance, wmFuncPtr);
}
};
使用原则
class Button {
public:
Dispatcher _dispatcher;
//button window forward all received message to a listener
LRESULT onMessage(HWND hWnd, UINT uMsg, WPARAM w, LPARAM l) {
//to return a precise message like WM_CREATE, you have just
//search it in the map.
return _dispatcher[uMsg](hWnd, uMsg, w, l);
}
};
class Myclass {
Button _button;
//the listener for Button messages
LRESULT button_listener(HWND hWnd, UINT uMsg, WPARAM w, LPARAM l) {
return 0;
}
//Register the listener for Button messages
void initialize() {
//now all message received from button are forwarded to button_listener function
_button._dispatcher.add(WM_CREATE, this, &Myclass::button_listener);
}
};
祝大家好运，感谢大家分享知识。
如果你需要存储一个没有类实例的成员函数，你可以这样做:
class MyClass
{
public:
void MemberFunc(int value)
{
//do something
}
};
// Store member function binding
auto callable = std::mem_fn(&MyClass::MemberFunc);
// Call with late supplied 'this'
MyClass myInst;
callable(&myInst, 123);
如果没有auto，存储类型会是什么样子? 就像这样:
std::_Mem_fn_wrap<void,void (__cdecl TestA::*)(int),TestA,int> callable
还可以将此函数存储传递给标准函数绑定
std::function<void(int)> binding = std::bind(callable, &testA, std::placeholders::_1);
binding(123); // Call
过去和将来的注意事项:存在一个较旧的接口std::mem_func，但已弃用。在c++ 17之后，存在一个提议，将指向成员函数的指针设为可调用的。这将是最受欢迎的。
非静态成员函数必须与对象一起调用。也就是说，它总是隐式地传递“this”指针作为参数。
因为你的std::function签名指定你的函数不接受任何参数(<void(void)>)，你必须绑定第一个(也是唯一的)参数。
std::function<void(void)> f = std::bind(&Foo::doSomething, this);
如果你想用参数绑定一个函数，你需要指定占位符:
using namespace std::placeholders;
std::function<void(int,int)> f = std::bind(&Foo::doSomethingArgs, this, std::placeholders::_1, std::placeholders::_2);
或者，如果你的编译器支持c++ 11 lambdas:
std::function<void(int,int)> f = [=](int a, int b) {
this->doSomethingArgs(a, b);
}
(我现在手头没有c++ 11的编译器，所以我不能检查这个。)
你可以避免std::bind这样做:
std::function<void(void)> f = [this]-> {Foo::doSomething();}
要么你需要
std::function<void(Foo*)> f = &Foo::doSomething;
所以你可以在任何实例上调用它，或者你需要绑定一个特定的实例，比如这个
std::function<void(void)> f = std::bind(&Foo::doSomething, this);
