在C++中，有需要将类的成员函数作为某一个组件/API的回调函数的需求，应对这种需求，可以使用：

1、C++ 11里面的  std::function  和 std::bind 代替回调函数；

	class EventArgs
	{
	public:
		EventArgs(){}
		virtual ~EventArgs(){}
	};

	typedef std::function<void(void* sender, EventArgs* args)> EventHandler;

class Wnd
{
public:
	Input::EventHandler  Event_Init;

	void Dosth()
	{
		if (Event_Init)
		{
			EventArgs args;
			Event_Init(this, &args);
		}
	}
};


class APP
{
public:
	APP()
	{
		m_wnd.Event_Init = EVENT_SLOT(&APP::OnEvent_Init);
	}

	~APP(){}

	void OnEvent_Init(void* _sender, EventArgs* _args)
	{

	}

	Wnd m_wnd;
};

如果是调用系统API之类的接口，就不能用这种方式了；

2、使用命令模式的变种：

class Event
{
public:
	Event(){}

	virtual ~Event(){}

	virtual void Invoke(void* _sender, EventArgs* _args) = 0;
};



template <class Receiver>
class EventSTD : public Event
{
public:
	//事件处理函数签名
	typedef void (Receiver:: * Action)(void* _sender, EventArgs* _args);

	//构造器
	EventSTD(Receiver* r, Action a) : _receiver(r), _action(a){}

	virtual void Invoke(void* _sender, EventArgs* _args)
	{
		(_receiver->*_action)(_sender, _args);
	}

private:
	Action _action;
	Receiver* _receiver;
};

应用：

class EventArgs_Btn : public EventArgs
{
public:
	EventArgs_Btn(){}
	~EventArgs_Btn(){}

public:
	int x;
	int y;

	bool IsPress;
};

class ButtonEx
{
public:
	//所有事件都可以使用该模型定义(可以使用智能指针，隐藏释放过程)
	Event*   Event_Init;  

	ButtonEx() : Event_Init(nullptr){}

	~ButtonEx()
	{
		//release 
		delete Event_Init; 
		Event_Init = nullptr;
	}

	void DoSth()
	{
		if (Event_Init == nullptr)
			return;//error 

		EventArgs_Btn args;
		args.x = 10;
		args.y = 20;
		args.IsPress = false;

		Event_Init->Invoke(this, &args);

		if (args.IsPress)
		{
			//feedback ...
			cout << "btn press!" << endl;
		}
	}
private:	
};

class Wnd
{
public:
	Wnd()
	{
		m_Btn.Event_Init = new EventSTD<Wnd>(this, &Wnd::Init);
	}

	~Wnd()
	{

	}

	void Init(void* _sender, EventArgs* _args)
	{
		//use and convert sender;
		
		//
		auto pArgs = reinterpret_cast<EventArgs_Btn*>(_args);
		if (pArgs == nullptr){
			//error handler
			return;
		}

		int x = pArgs->x;
		int y = pArgs->y;

		pArgs->IsPress = true;
	}


	void Proc()
	{
		m_Btn.DoSth();
	}

private:
	ButtonEx     m_Btn;
};

int _tmain(int argc, _TCHAR* argv[])
{
	Wnd wnd;

	wnd.Proc();

	return 0;
}

这种方式是借鉴了C#中的事件模型，所有的事件响应函数签名如下：

void OnEvent(void* _sender, EventArgs* _args)

事件的入参和出参都放在事件参数对象EventArgs里面，你可以派生生成不同的参数对象，如例子中的EventArgs_Btn;

这种签名可以实现一对多的订阅，即一个OnEvent函数可以订阅多个事件，然后通过sender来区分不同的触发源。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

附命令模型代码：

class Command
{
public:
	virtual ~Command();

	virtual void Execute() = 0;

	virtual void UnExecute();
protected:
	Command();
};


template <class Receiver>
class SimpleCommand : public Command
{
public:
	typedef void (Receiver:: * Action)();

	SimpleCommand(Receiver* r, Action a) : _receiver(r), _action(a){}

	virtual void Execute(){
		(_receiver->*_action)();
	}

private:
	Action _action;
	Receiver* _receiver;
};

class Button
{
public:
	void Click()
	{
		_BtnClick->Execute();
	}
public:
	Command*  _BtnClick;
};

class Client
{
public:
	Client()
	{
	      _btn._BtnClick = new SimpleCommand<Client>(this, &Client::OnBtnClick);
	}

	//Receiver
	void OnBtnClick()
	{
		cout<<"Client::OnBtnClick"<<endl;
	}

	void OnBtnClick2()
	{

	}
public:
	Button _btn;
};

类成员函数作为回调函数/事件模型