回调函数的使用封装（支持全局函数，类静态函数，类成员函数）

 

回调函数的使用封装在了callback.h中，main.cpp用于测试回调。

Ref  CEGUI。。。

 

callback.h （回调封装）

#######################################

/*
**FileName: callback.h
**Description: 回调函数机制封装（支持类成员函数与全局函数）
**Autor: by Roobt
**Create Time: 2012/11/26   10:34
*/

#ifndef __CALLBACK_H__
#define __CALLBACK_H__

#include <map>
using std::map;
using std::make_pair;

typedef int EventArgs;
typedef int EventID;

//回调基类
class SlotFunctorBase
{
public:
 virtual ~SlotFunctorBase() {};

 //使用操作符来调用函数
 virtual bool operator()(const EventArgs& args) = 0;
};

//全局函数、静态函数或类的静态成员函数做回调
class FreeFunctionSlot : public SlotFunctorBase
{
public:
 //定义回调函数的格式
 typedef bool (SlotFunction)(const EventArgs&);  //函数指针

public:
 FreeFunctionSlot(SlotFunction* func) : d_function(func)
 {}

 virtual bool operator()(const EventArgs& args)
 {
  return d_function(args);
 }

private:
 SlotFunction* d_function;
};

//类的普通成员函数做回调
template<typename T>
class MemberFunctionSlot : public SlotFunctorBase
{
public:
 //!成员变量的回调函数定义
 typedef bool (T::*MemberFunctionType)(const EventArgs&);  //类的成员函数指针的类型

public:
 MemberFunctionSlot(MemberFunctionType func, T* obj) :
 d_function(func), d_object(obj)
 {}

 virtual bool operator()(const EventArgs& args)
 {
  return (d_object->*d_function)(args);  //调用类的成员函数
 }

private:
 MemberFunctionType d_function;
 T* d_object;
};

//对上面2种实现的封装
class SubscriberSlot
{
public:
 //默认构造函数
 SubscriberSlot()
 {
  d_functor_impl = NULL;
 }

 //标准析构函数
 ~SubscriberSlot()
 {
  delete d_functor_impl;
  d_functor_impl = NULL;
 }

 //调用函数的()重载，具体由第一类Functor实现
 bool operator()(const EventArgs& args) const
 {
  return (*d_functor_impl)(args);
 }

 //返回成员是否有效，是否已经连接到一个具体的Functor实现
 bool connected() const
 {
  return d_functor_impl != NULL;
 }

 //FreeFunctionSlot，自由函数的封装类
 SubscriberSlot(FreeFunctionSlot::SlotFunction* func) :
 d_functor_impl(new FreeFunctionSlot(func))
 {}

 // 模板构造函数，以成员函数的封装为参数，MemberFunctionSlot。
 template<typename T>
 SubscriberSlot(bool (T::*function)(const EventArgs&), T* obj) :
 d_functor_impl(new MemberFunctionSlot<T>(function, obj))
 {}

private:
 //内部基本Functor的指针，SlotFunctorBase基类的优势在这里用到了
 SlotFunctorBase* d_functor_impl;
};

// 注册函数宏
// 注册全局函数、类静态成员函数作为回调函数
#define  REGISTER_FUNC(id, subscribeSlot, func, q) \
 SubscriberSlot* subscribeSlot = new SubscriberSlot((FreeFunctionSlot::SlotFunction*)&func);\
 q->subscribe(id, subscribeSlot);

// 注册类成员函数作为回调函数
// param0: 事件id
// param1: psubscribeSlot, 随便一个变量名
// param2: func, 要注册的类的普通成员函数（即：回调函数）
// param3: p, func所在类的一个实例指针
// param4: q, 注册类（调用注册函数的类）的一个实例指针
#define REGISTER_OBJFUNC(id, subscribeSlot, func, p, q) \
 SubscriberSlot* subscribeSlot = new SubscriberSlot(&func, p);\
 q->subscribe(id, subscribeSlot);

// 回调
class Callback
{
public:
 typedef map<EventID, SubscriberSlot*> EventMap;
 
public:
 Callback() {eventList.clear();}
 ~Callback() {eventList.clear();}

 bool subscribe(EventID id, SubscriberSlot* subscriberSlot)
 {
  if (NULL == subscriberSlot)
   return false;
  EventMap::iterator iter = eventList.find(id);
  if (iter != eventList.end())
   return false;
  eventList.insert(make_pair(id, subscriberSlot));
  return true;
 }

 bool evoke(EventID id)
 {
  EventMap::iterator iter = eventList.find(id);
  if(iter == eventList.end())
   return false;
  SubscriberSlot* subscribeSlot = eventList[id];
  if (subscribeSlot)
  {
   EventArgs args = 0;
   (*subscribeSlot)(args);
   return true;
  }
  return false;
 }

private:
 EventMap eventList;
};

#endif

 

#######################################

 

main.cpp （测试）

 ######################################

#include "stdafx.h"
#include "callback.h"
#include <iostream>
using namespace std;

class A
{
public:
 bool Test1(const EventArgs&)
 {
  cout<<"Test1..."<<endl;
  return true;
 }
 static bool Test2(const EventArgs&)
 {
  cout<<"Test2..."<<endl;
  return true;
 }
};

class B : public Callback
{
public:
 enum EVENT_TYPE
 {
  EVENT_TYPE_INVALID = -1,
  EVENT_TYPE1,
  EVENT_TYPE2,
  EVENT_TYPE_NUMBER,
 };

public:
 B(A *pA) : m_pAObj(pA)
 {}

 void registerCallback()
 {
  // 类成员函数
  REGISTER_OBJFUNC(EVENT_TYPE1, subscribeSlot, A::Test1, m_pAObj, this);
  // 类静态函数
  REGISTER_FUNC(EVENT_TYPE2, subscribeSlot2, A::Test2, this);
 }
 void evoke()
 {
  Callback::evoke(EVENT_TYPE1);
  Callback::evoke(EVENT_TYPE2);
 }

private:
 A *m_pAObj;
};

// 主函数
int _tmain(int argc, _TCHAR* argv[])
{
 A *pA = new A();
 B *pB = new B(pA);
 if (pB)
 {
  pB->registerCallback();
  pB->evoke();
 }

 system("pause");
 return 0;
}

######################################