在C++中模拟委托事件的方法（上篇）

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量573 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ null windows 工作 delphi callback

出处：http://blog.csdn.net/gogogo/article/details/6996290

作者：gogogo

关键字：C++、事件、指向函数的指针、静态方法、接口、多重继承、模板

 

如果对C#、Delphi等语言熟悉，都知道这些语言支持委托事件的方法使用起来非常方便，并且能够较好的降低类的依赖关系，而C++语言没有集成这种语法，所以要想在C++使用这种事件模式需要开发人员自己来模拟，本文将提供多种模拟的方案，并会分析各自的优缺点，可以在需要的时候有选择的使用。

委托事件模式的具体是什么样子的，可以举个例子，类A的实例a使用类B的实例b，当a工作时调用b的一个方法bf来操作，比如b的这个方法bf是个长时间操作，方法bf每工作一段就通过事件的方式通知a进度情况，类A的一个事件接收方法ae接收到事件后就会执行一些比如界面更新的工作，这里本质上来看就是bf方法会调用ae方法，对于a对象看起来就是被事件通知了。

值得注意的是这里的委托事件模式与Windows的消息循环体系是不同的，通常Windows的消息是放到消息队列中，应用程序进程从队列中得到消息，然后调用消息处理过程来处理消息，这里是真正的消息通知，并且消息处理过程是有固定的函数声明的，不能更改成其他的格式，但是委托事件模式实际上就是一次函数调用，整个事件触发与调用处理结束通常都是在一个Windows消息处理过程中完成的，并不会发送真正的Windows消息，并且事件接收处理函数可以是任意的类B预定义函数声明格式函数，种类可以非常多。

委托事件模式的使用，其好处是在开发中可以像真正的消息事件体系一样来理解整个体系模式，可以做到很好的接口分离，最大程度上分离开了类B对于类A的依赖，类B在开发时完全可以不需要知道类A的存在，同时类A在开发时可以有选择的选取接收类B的事件进行处理。

对于C++的开发人员看到这里很快就可以联想到指向函数的指针，b持有a的函数指针就可以调用了，很类似Windows中的CALLBACK函数，确实指向函数的指针是模拟实现的一种方法或者说是基础，但是直接使用C语法中指向函数的指针的方法在处理C++类时还是会碰到很多问题，C++类的成员函数的定义是跟具体的类直接相关的（每个函数都有一个指向这个类this指针的参数），所以函数的声明不固定，所以目前的通常做法都是定义类静态成员函数的方法来实现，但是静态函数成员在处理不同的对象实例的调用时如果没有对象实例的指针就不能直接访问类的实例成员，所以这里会有很多问题，最明显的就是对于类A只能使用静态方法来作为回调的函数，当有A的多个实例时就会有些麻烦，为了排除这些麻烦或者说规范这些问题，本文后续章节会提供多种方式来模拟委托事件方式。

本文谈到的所有例子代码我都已经上传，具体下载地址是http://download.csdn.net/detail/gogogo/3830459，所有程序在Visual studio 2005平台调试通过，对于本文及例子中提到的一些主要类如下：事件触发对象类叫做CNotifyClass，事件接收对象类或事件处理对象类叫做CRecvEventClass、CRecvEventClassOne等等。

例子代码被修正过，新的下载地址被更新了，并且是免资源分下载的了


下边来看具体的实现方案

 

一、静态函数模拟事件

对应的例子工程名StaticFunctionEvent

1、  具体的实现方法

(1)、事件触发对象类CNotifyClass的类定义如下：

view plain
  1. typedef void (*PEVENT_NOPARAM_NORETURN)(void *);  
  2. typedef int (*PEVENT_NOPARAM_RETURN)(void *);  
  3. typedef void (*PEVENT_PARAM_NORETURN)(void *, int);  
  4. typedef int (*PEVENT_PARAM_RETURN)(void *, int);  
  5.   
  6. class CNotifyClass  
  7. {  
  8. public:  
  9.     CNotifyClass(void);  
  10.     ~CNotifyClass(void);  
  11.   
  12. public:  
  13.     bool RegisterEvent(PEVENT_NOPARAM_NORETURN pFunc1, PEVENT_NOPARAM_RETURN pFunc2,  
  14.         PEVENT_PARAM_NORETURN pFunc3, PEVENT_PARAM_RETURN pFunc4, void *pParameter);  
  15.     void UnRegisterEvent();  
  16.   
  17.     void DoNotifyEventWork();  
  18.   
  19. protected:  
  20.     PEVENT_NOPARAM_NORETURN m_pNoParam_NoReturn_EventHandler;  
  21.     PEVENT_NOPARAM_RETURN m_pNoParam_Return_EventHandler;  
  22.     PEVENT_PARAM_NORETURN m_pParam_NoReturn_EventHandler;  
  23.     PEVENT_PARAM_RETURN m_pParam_Return_EventHandler;  
  24.   
  25. protected:  
  26.     void *m_pEventParameter;  
  27. };  

类实现如下：

view plain
  1. #include "NotifyClass.h"  
  2.   
  3. CNotifyClass::CNotifyClass(void)  
  4.     : m_pEventParameter(NULL)  
  5.     , m_pNoParam_NoReturn_EventHandler(NULL)  
  6.     , m_pNoParam_Return_EventHandler(NULL)  
  7.     , m_pParam_NoReturn_EventHandler(NULL)  
  8.     , m_pParam_Return_EventHandler(NULL)  
  9. {  
  10. }  
  11.   
  12. CNotifyClass::~CNotifyClass(void)  
  13. {  
  14.     UnRegisterEvent();  
  15. }  
  16.   
  17. bool  
  18. CNotifyClass::RegisterEvent(PEVENT_NOPARAM_NORETURN pFunc1, PEVENT_NOPARAM_RETURN pFunc2,  
  19.     PEVENT_PARAM_NORETURN pFunc3, PEVENT_PARAM_RETURN pFunc4, void *pParameter)  
  20. {  
  21.     if (NULL != m_pNoParam_NoReturn_EventHandler)  
  22.         return false;  
  23.     m_pEventParameter = pParameter;  
  24.     m_pNoParam_NoReturn_EventHandler = pFunc1;  
  25.     m_pNoParam_Return_EventHandler = pFunc2;  
  26.     m_pParam_NoReturn_EventHandler = pFunc3;  
  27.     m_pParam_Return_EventHandler = pFunc4;  
  28.     return true;  
  29. }  
  30.   
  31. void  
  32. CNotifyClass::UnRegisterEvent()  
  33. {  
  34.     m_pEventParameter = NULL;  
  35.     m_pNoParam_NoReturn_EventHandler = NULL;  
  36.     m_pNoParam_Return_EventHandler = NULL;  
  37.     m_pParam_NoReturn_EventHandler = NULL;  
  38.     m_pParam_Return_EventHandler = NULL;  
  39. }  
  40.   
  41. void  
  42. CNotifyClass::DoNotifyEventWork()  
  43. {  
  44.     int iResult = 0;  
  45.     if (m_pNoParam_NoReturn_EventHandler != NULL)  
  46.         m_pNoParam_NoReturn_EventHandler(m_pEventParameter);  
  47.     if (m_pNoParam_Return_EventHandler != NULL)  
  48.         iResult = m_pNoParam_Return_EventHandler(m_pEventParameter);  
  49.   
  50.     iResult = iResult + 10;  
  51.     if (m_pParam_Return_EventHandler != NULL)  
  52.         iResult = m_pParam_Return_EventHandler(m_pEventParameter, iResult);  
  53.     iResult = iResult + 10;  
  54.     if (m_pParam_NoReturn_EventHandler != NULL)  
  55.         m_pParam_NoReturn_EventHandler(m_pEventParameter, iResult);  
  56. }  

类CNotifyClass声明时要提供类似如下的事件处理函数声明，所有接收事件的对象都要使用如下的函数声明来定义函数

view plain
  1. typedef void (*PEVENT_NOPARAM_NORETURN)(void*);  

事件接收对象类通过调用RegisterEvent和UnRegisterEvent注册接收消息或取消注册不再接收消息，当会触发消息的工作方法DoNotifyEventWork被调用时，会检测哪些事件被注册了，被注册了就调用，就如同进行了事件通知。


(2)、事件接收对象类或事件处理对象类CRecvEventClass的类定义如下：

view plain
  1. class CRecvEventClass  
  2. {  
  3. public:  
  4.     CRecvEventClass(void);  
  5.     ~CRecvEventClass(void);  
  6.   
  7. public:  
  8.     int DoWork(int iArg);  
  9.   
  10. protected:  
  11.     static void OnNoParamNoReturnEvent(void *pvParam);  
  12.     static int OnNoParamReturnEvent(void *pvParam);  
  13.     static void OnParamNoReturnEvent(void *pvParam, int iArg);  
  14.     static int OnParamReturnEvent(void *pvParam, int iArg);  
  15.   
  16. protected:  
  17.     CNotifyClass m_ncNotify;  
  18.     int m_nNum;  
  19. };  

类实现如下：

view plain
  1. #include "RecvEventClass.h"  
  2.   
  3. CRecvEventClass::CRecvEventClass(void)  
  4. {  
  5.     m_ncNotify.RegisterEvent(OnNoParamNoReturnEvent, OnNoParamReturnEvent, OnParamNoReturnEvent, OnParamReturnEvent, this);  
  6. }  
  7.   
  8. CRecvEventClass::~CRecvEventClass(void)  
  9. {  
  10.     m_ncNotify.UnRegisterEvent();  
  11. }  
  12.   
  13. int  
  14. CRecvEventClass::DoWork(int iArg)  
  15. {  
  16.     m_nNum = iArg;  
  17.     m_ncNotify.DoNotifyEventWork();  
  18.     return m_nNum;  
  19. }  
  20.   
  21. void  
  22. CRecvEventClass::OnNoParamNoReturnEvent(void *pvParam)  
  23. {  
  24.     _tprintf(_T("Run OnNoParamNoReturnEvent\n"));  
  25.     if (pvParam != NULL)  
  26.     {  
  27.         CRecvEventClass *p = reinterpret_cast<CRecvEventClass *>(pvParam);  
  28.         p->m_nNum = p->m_nNum + 10;  
  29.     }  
  30. }  
  31.   
  32. int  
  33. CRecvEventClass::OnNoParamReturnEvent(void *pvParam)  
  34. {  
  35.     _tprintf(_T("Run OnNoParamReturnEvent\n"));  
  36.     if (pvParam != NULL)  
  37.     {  
  38.         CRecvEventClass *p = reinterpret_cast<CRecvEventClass *>(pvParam);  
  39.         p->m_nNum = p->m_nNum + 10;  
  40.         return p->m_nNum;  
  41.     }  
  42.     else  
  43.         return 0;  
  44. }  
  45.   
  46. void  
  47. CRecvEventClass::OnParamNoReturnEvent(void *pvParam, int iArg)  
  48. {  
  49.     _tprintf(_T("Run OnParamNoReturnEvent\n"));  
  50.     if (pvParam != NULL)  
  51.     {  
  52.         CRecvEventClass *p = reinterpret_cast<CRecvEventClass *>(pvParam);  
  53.         p->m_nNum = iArg + 10;  
  54.     }  
  55. }  
  56.   
  57. int  
  58. CRecvEventClass::OnParamReturnEvent(void *pvParam, int iArg)  
  59. {  
  60.     _tprintf(_T("Run OnParamReturnEvent\n"));  
  61.     int iRet = iArg + 10;  
  62.     return iRet;  
  63. }  

这里事件接收对象类或事件处理对象类CRecvEventClass在定义时一定要定义同事件触发类CNotifyClass提供的方法声明相同的方法来接收处理事件，由于CNotifyClass定义的方法声明是普通的指向函数指针，不包含对象的this指针传递，所以这种方法不能是实例成员函数，只能是静态成员方法，就如同

view plain
  1. static void OnNoParamNoReturnEvent(void *pvParam);  

当定义了事件处理方法后，可以通过调用类CNotifyClass的方法RegisterEvent和UnRegisterEvent注册接收消息或取消注册不再接收消息，本例是在构造和析构函数中调用的，当CNotifyClass类的DoNotifyEventWork方法被调用时，就会通过函数指针事件通知到类CRecvEventClass，在事件处理方法中为了能区分CRecvEventClass的不同实例，所以要在类CNotifyClass的方法RegisterEvent中提供了pParameter参数，通常CRecvEventClass在调用RegisterEvent时传递对象本身的this指针，这样在事件处理方法中就可以通过pvParam参数得到这个指针的类实例的this指针，就像OnNoParamNoReturnEvent中的代码

view plain
  1. CRecvEventClass::OnNoParamNoReturnEvent(void *pvParam)  
  2. {  
  3.     _tprintf(_T("Run OnNoParamNoReturnEvent\n"));  
  4.     if (pvParam != NULL)  
  5.     {  
  6.         CRecvEventClass *p = reinterpret_cast<CRecvEventClass *>(pvParam);  
  7.         p->m_nNum = p->m_nNum + 10;  
  8.     }  
  9. }  

可以直接将pvParam参数转化为CRecvEventClass类实例的指针，然后就像成员方法一样访问类实例的其他方法和成员了。

(3)、使用的例子及输出

view plain
  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.     //2个对象，虽然类里用的静态方法，但是不会影响到不同对象的调用，互相不会干扰其他的对象的状态  
  4.     CRecvEventClass rec1, rec2;  
  5.     int iIn, iOut;  
  6.   
  7.     iIn = 10;  
  8.     iOut = rec1.DoWork(iIn);  
  9.     _tprintf(_T("StaticFunctionEvent test 1, Init:%d, Result:%d\n"), iIn, iOut);  
  10.     iIn = 30;  
  11.     iOut = rec1.DoWork(iIn);  
  12.     _tprintf(_T("StaticFunctionEvent test 2, Init:%d, Result:%d\n"), iIn, iOut);  
  13.     iIn = 60;  
  14.     iOut = rec2.DoWork(iIn);  
  15.     _tprintf(_T("StaticFunctionEvent test 3, Init:%d, Result:%d\n"), iIn, iOut);  
  16.   
  17.     TCHAR c;  
  18.     _tscanf(_T("%c"), &c);  
  19.     return 0;  
  20. }  

输出结果为：

view plain
  1. Run OnNoParamNoReturnEvent  
  2. Run OnNoParamReturnEvent  
  3. Run OnParamReturnEvent  
  4. Run OnParamNoReturnEvent  
  5. StaticFunctionEvent test 1, Init:10, Result:70  
  6. Run OnNoParamNoReturnEvent  
  7. Run OnNoParamReturnEvent  
  8. Run OnParamReturnEvent  
  9. Run OnParamNoReturnEvent  
  10. StaticFunctionEvent test 2, Init:30, Result:90  
  11. Run OnNoParamNoReturnEvent  
  12. Run OnNoParamReturnEvent  
  13. Run OnParamReturnEvent  
  14. Run OnParamNoReturnEvent  
  15. StaticFunctionEvent test 3, Init:60, Result:120  

从输出结果上看事件是被顺次调用了，至于程序中的变量值，主要表明这些事件执行的而动作是对应于实例的，不是因为是静态方法就是对应于类的。

2、  实现的要点

 (1)、事件触发类的实现要点

a、  事件触发类必须要定义要处理事件的函数声明

b、  事件触发类要定义相应函数声明类型的成员变量

view plain
  1. PEVENT_NOPARAM_NORETURN m_pNoParam_NoReturn_EventHandler;  

c、  为了能传递事件接收类的实例，要定义事件接收类的实例指针

view plain
  1. void *m_pEventParameter;  

d、  或者把上面的函数指针成员和事件接收类的实例指针直接公开被外部修改，或者使用类似RegisterEvent和UnRegisterEvent的方法提供对这些成员的修改，外部事件接收类才能接收事件

e、  在工作时，需要触发事件的地方，通过调用函数指针成员来事件通知事件接收类

(2)、事件接收对象类或事件处理对象类的实现要点

a、  使用静态方法定义与实现满足事件接收函数声明的方法

b、  使用这些静态方法及自身作为参数调用事件触发类的RegisterEvent和UnRegisterEvent的方法，或者直接修改事件触发类的相应成员（如果提供了访问权限）

c、  在这些静态方法中，转换参数为this，然后进行工作，当有事件触发时就可以得到通知被调用。

3、  优缺点

(1)、优点

a、可以部分接收事件，如果不接收什么事件，只需要在调用RegisterEvent时传递NULL给对应的事件函数就可以

b、事件处理方法不需要必须是public的方法，任意访问类别都可以

(2)、缺点

类型安全度相对较底，需要类型转换，不容易在编译期间发现问题，这里主要是指传递的参数pParameter，对于事件处理函数的指针是类型安全的


二、接口模拟事件

对应的例子工程名InterfaceEvent

由于C++不支持接口，但是支持抽象类和多重继承，所以可以通过class或struct模拟实现接口。

1、  具体的实现方法

(1)、事件触发对象类CNotifyClass的类定义如下：

view plain
  1. class INotifyClassEvent  
  2. {  
  3. public:  
  4.     INotifyClassEvent() {};  
  5.     virtual ~INotifyClassEvent() {};  
  6. public:  
  7.     virtual void OnNoParamNoReturnEvent() = 0;  
  8.     virtual int OnNoParamReturnEvent() = 0;  
  9.     virtual void OnParamNoReturnEvent(int) = 0;  
  10.     virtual int OnParamReturnEvent(int) = 0;  
  11. };  
  12.   
  13. class CNotifyClass  
  14. {  
  15. public:  
  16.     CNotifyClass(void);  
  17.     ~CNotifyClass(void);  
  18.   
  19. public:  
  20.     bool RegisterEvent(INotifyClassEvent *pncRecvEvent);  
  21.     void UnRegisterEvent();  
  22.   
  23.     void DoNotifyEventWork();  
  24.   
  25. protected:  
  26.     INotifyClassEvent *m_pncRecvEvent;  
  27. };  

类实现如下：

view plain
  1. #include "NotifyClass.h"  
  2.   
  3. CNotifyClass::CNotifyClass(void)  
  4.     : m_pncRecvEvent(NULL)  
  5. {  
  6. }  
  7.   
  8. CNotifyClass::~CNotifyClass(void)  
  9. {  
  10.     UnRegisterEvent();  
  11. }  
  12.   
  13. bool  
  14. CNotifyClass::RegisterEvent(INotifyClassEvent *pncRecvEvent)  
  15. {  
  16.     if (NULL != m_pncRecvEvent)  
  17.         return false;  
  18.     m_pncRecvEvent = pncRecvEvent;  
  19.     return true;  
  20. }  
  21.   
  22. void  
  23. CNotifyClass::UnRegisterEvent()  
  24. {  
  25.     m_pncRecvEvent = NULL;  
  26. }  
  27.   
  28. void  
  29. CNotifyClass::DoNotifyEventWork()  
  30. {  
  31.     if (NULL == m_pncRecvEvent)  
  32.         return;  
  33.   
  34.     int iResult = 0;  
  35.     m_pncRecvEvent->OnNoParamNoReturnEvent();  
  36.     iResult = m_pncRecvEvent->OnNoParamReturnEvent();  
  37.   
  38.     iResult = iResult + 10;  
  39.     iResult = m_pncRecvEvent->OnParamReturnEvent(iResult);  
  40.     iResult = iResult + 10;  
  41.     m_pncRecvEvent->OnParamNoReturnEvent(iResult);  
  42. }  

类CNotifyClass声明时要定义事件处理函数集的接口INotifyClassEvent，所有接收事件的类都要继承并实现这个接口来接收事件。

事件接收对象类通过调用RegisterEvent和UnRegisterEvent注册接收消息或取消注册不再接收消息，当会触发事件的工作方法DoNotifyEventWork被调用时，会检测哪些事件被注册了，被注册了就调用，就如同进行了事件通知。

 

(2)、事件接收对象类或事件处理对象类CRecvEventClass的类定义如下：

view plain
  1. class CRecvEventClass : public INotifyClassEvent  
  2. {  
  3. public:  
  4.     CRecvEventClass(void);  
  5.     ~CRecvEventClass(void);  
  6.   
  7. public:  
  8.     int DoWork(int iArg);  
  9.   
  10. protected:  
  11.     virtual void OnNoParamNoReturnEvent();  
  12.     virtual int OnNoParamReturnEvent();  
  13.     virtual void OnParamNoReturnEvent(int iArg);  
  14.     virtual int OnParamReturnEvent(int iArg);  
  15.   
  16. protected:  
  17.     CNotifyClass m_ncNotify;  
  18.     int m_nNum;  
  19. };  

类实现如下：

view plain
  1. #include "RecvEventClass.h"  
  2.   
  3. CRecvEventClass::CRecvEventClass(void)  
  4. {  
  5.     m_ncNotify.RegisterEvent(this);  
  6. }  
  7.   
  8. CRecvEventClass::~CRecvEventClass(void)  
  9. {  
  10.     m_ncNotify.UnRegisterEvent();  
  11. }  
  12.   
  13. int  
  14. CRecvEventClass::DoWork(int iArg)  
  15. {  
  16.     m_nNum = iArg;  
  17.     m_ncNotify.DoNotifyEventWork();  
  18.     return m_nNum;  
  19. }  
  20.   
  21. void  
  22. CRecvEventClass::OnNoParamNoReturnEvent()  
  23. {  
  24.     _tprintf(_T("Run OnNoParamNoReturnEvent\n"));  
  25.     m_nNum = m_nNum + 10;  
  26. }  
  27.   
  28. int  
  29. CRecvEventClass::OnNoParamReturnEvent()  
  30. {  
  31.     _tprintf(_T("Run OnNoParamReturnEvent\n"));  
  32.     m_nNum = m_nNum + 10;  
  33.     return m_nNum;  
  34. }  
  35.   
  36. void  
  37. CRecvEventClass::OnParamNoReturnEvent(int iArg)  
  38. {  
  39.     _tprintf(_T("Run OnParamNoReturnEvent\n"));  
  40.     m_nNum = iArg + 10;  
  41. }  
  42.   
  43. int  
  44. CRecvEventClass::OnParamReturnEvent(int iArg)  
  45. {  
  46.     int iRet;  
  47.     _tprintf(_T("Run OnParamReturnEvent\n"));  
  48.     iRet = iArg + 10;  
  49.     return iRet;  
  50. }  

这里事件接收对象类或事件处理对象类CRecvEventClass在定义时一定要继承事件通知接口INotifyClassEvent，通过实现这个接口的成员函数来接收事件通知。

当定义了事件处理方法后，可以通过调用类CNotifyClass的方法RegisterEvent和UnRegisterEvent注册接收消息或取消注册不再接收消息，本例是在构造和析构函数中调用的，当CNotifyClass类的DoNotifyEventWork方法被调用时，就会通过接口方法直接事件通知（调用）相应的事件处理方法

view plain
  1. void  
  2. CRecvEventClass::OnNoParamNoReturnEvent()  
  3. {  
  4.     _tprintf(_T("Run OnNoParamNoReturnEvent\n"));  
  5.     m_nNum = m_nNum + 10;  
  6. }  

这里可以看到事件处理方法直接就是类成员方法，不需要传递对象的指针this。

(3)、使用的例子及输出

view plain
  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.     CRecvEventClass rec1, rec2;  
  4.     int iIn, iOut;  
  5.   
  6.     iIn = 10;  
  7.     iOut = rec1.DoWork(iIn);  
  8.     _tprintf(_T("InterfaceEvent test 1, Init:%d, Result:%d\n"), iIn, iOut);  
  9.     iIn = 30;  
  10.     iOut = rec1.DoWork(iIn);  
  11.     _tprintf(_T("InterfaceEvent test 2, Init:%d, Result:%d\n"), iIn, iOut);  
  12.     iIn = 60;  
  13.     iOut = rec2.DoWork(iIn);  
  14.     _tprintf(_T("InterfaceEvent test 3, Init:%d, Result:%d\n"), iIn, iOut);  
  15.   
  16.     TCHAR c;  
  17.     _tscanf(_T("%c"), &c);  
  18.     return 0;  
  19. }  

输出结果为：

view plain
  1. Run OnNoParamNoReturnEvent  
  2. Run OnNoParamReturnEvent  
  3. Run OnParamReturnEvent  
  4. Run OnParamNoReturnEvent  
  5. InterfaceEvent test 1, Init:10, Result:70  
  6. Run OnNoParamNoReturnEvent  
  7. Run OnNoParamReturnEvent  
  8. Run OnParamReturnEvent  
  9. Run OnParamNoReturnEvent  
  10. InterfaceEvent test 2, Init:30, Result:90  
  11. Run OnNoParamNoReturnEvent  
  12. Run OnNoParamReturnEvent  
  13. Run OnParamReturnEvent  
  14. Run OnParamNoReturnEvent  
  15. InterfaceEvent test 3, Init:60, Result:120  

从输出结果上看事件是被顺次调用了，至于程序中的变量值，主要表明这些事件执行的而动作是对应于实例的，不是对应于类的。

2、  实现的要点

(1)、事件触发类的实现要点

a、  事件触发类必须要定义接收事件处理的接口类INotifyClassEvent

b、  事件触发类要定义INotifyClassEvent接口类的成员变量

view plain
  1. INotifyClassEvent *m_pncRecvEvent;  

当需要触发事件时通过这个接口类调用相应的函数

c、  或者把上面的INotifyClassEvent接口类的成员变量直接公开被外部修改，或者使用类似RegisterEvent和UnRegisterEvent的方法提供对这些成员的修改，外部事件接收类才能接收事件

d、  在工作时，需要触发事件的地方，通过调用INotifyClassEvent接口类来事件通知事件接收类

(2)、事件接收对象类或事件处理对象类的实现要点

a、  事件接收类必须继承或多重继承自接口类INotifyClassEvent

b、  使用自身的指针this作为参数调用事件触发类的RegisterEvent和UnRegisterEvent的方法，或者直接修改事件触发类的相应成员（如果提供了访问权限）

d、  在事件处理方法中当做普通的成员函数进行编写，然后在工作中，当有事件触发时就可以得到通知被调用。

3、  优缺点

(1)、优点

a、无论事件触发类还是接收事件处理类开发简单，代码量少、简洁

b、数据安全性高，无论对于事件处理函数和接收事件处理类实例都不存在类型转换，这两个数据都可以在编译期间得到类型检查

(2)、缺点

a、不能部分接收消息事件，要实现接口类的所有函数，虽然可以实现时什么都不做，但是需要都实现，为了让事件接收类可以选择接收的事件，事件触发类开发者必须拆分分类成多个事件接口，这样事件接收类可以选择继承，就可以只接收部分消息了，但是如果量太大，事件接收类需要继承的接口列表可能很多，增加了复杂度。

b、接收事件处理方法由于是继承自接口，所以其方法属性必须是public方法，对于事件接收类的封装造成了一定的破坏。


三、静态函数方式实现多对象事件接收

对应的例子工程名MultiObjectEvent

在静态函数模拟事件方法中，如果读者细心的话，会发现类CNotifyClass只包含一个指定对象的成员变量m_pEventParameter，在使用RegisterEvent方法注册接收事件的函数时如果不接收某些事件，就把相应的函数参数设为NULL，但是接收事件的对象参数只能是一个，这样就不能有多个类CRecvEventClass的实例接收事件，但是有的时候因为类CNotifyClass是一个服务类，就可能存在多个接收类的实例同时接收不同的事件，这个时候在静态函数模拟事件方法中将无能为力，所以要实现多个类对象能接收事件，就必须分开注册方法RegisterEvent，同时允许注册不同的pParameter，这个的具体实现代码在MultiObjectEvent例子中，我们看看类CNotifyClass的声明

view plain
  1. typedef void (*PEVENT_NOPARAM_NORETURN)(void *);  
  2. typedef int (*PEVENT_NOPARAM_RETURN)(void *);  
  3. typedef void (*PEVENT_PARAM_NORETURN)(void *, int);  
  4. typedef int (*PEVENT_PARAM_RETURN)(void *, int);  
  5.   
  6. class CNotifyClass  
  7. {  
  8. public:  
  9.     CNotifyClass(void);  
  10.     ~CNotifyClass(void);  
  11.   
  12. public:  
  13.     bool RegisterEvent(PEVENT_NOPARAM_NORETURN pFunc, void *pParameter);  
  14.     void UnRegisterNoParamNoRetEvent();  
  15.     bool RegisterEvent(PEVENT_NOPARAM_RETURN pFunc, void *pParameter);  
  16.     void UnRegisterNoParamRetEvent();  
  17.     bool RegisterEvent(PEVENT_PARAM_NORETURN pFunc, void *pParameter);  
  18.     void UnRegisterParamNoRetEvent();  
  19.     bool RegisterEvent(PEVENT_PARAM_RETURN pFunc, void *pParameter);  
  20.     void UnRegisterParamRetEvent();  
  21.   
  22.     void UnRegisterAllEvent();  
  23.   
  24.     int DoNotifyEventWork();  
  25.   
  26. protected:  
  27.     PEVENT_NOPARAM_NORETURN m_pNoParam_NoReturn_EventHandler;  
  28.     PEVENT_NOPARAM_RETURN m_pNoParam_Return_EventHandler;  
  29.     PEVENT_PARAM_NORETURN m_pParam_NoReturn_EventHandler;  
  30.     PEVENT_PARAM_RETURN m_pParam_Return_EventHandler;  
  31.   
  32. protected:  
  33.     void *m_pNoParamNoRetEventParameter;  
  34.     void *m_pNoParamRetEventParameter;  
  35.     void *m_pParamNoRetEventParameter;  
  36.     void *m_pParamRetEventParameter;  
  37. };  

分开事件的注册，同时允许不同的参数传递进入，保存在多个参数成员变量中，来实现多个不同类对象接收事件的方法，可以看到存在大量的RegisterEvent和UnRegisterParamRetEvent方法，正是由于这种方法代码量比较大，书写非常麻烦，容易出错，而且后面介绍的方法更好，所以不推荐这种方法，这里就不详述了，有兴趣的读者自己去看例子程序。


读后感：在我们一个项目中，看前辈的代码，看到FastDelegate.h和FastDelegateBind.h，直接告诉我能在此中学到很多东西，也想把此种道理弄明白，会调用。但是阅读了一下代码，都是模板等，汗颜 没有看懂 ，就上网搜 一直搜到此篇文档，原来这是委托的一种实现，从而学到了很多东西。知道了什么叫“委托”，原来并不是我认为的注册回调函数可以不用static成员函数或者全局函数这么一个好处。


幺幺桃
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在C++中模拟委托事件的方法（五）
gogogo的专栏
11-22 2904
五、事件链模拟事件 对应的例子工程名DelegateChainEvent 类模板的方法已经可以比较方便的让不同的对象接收同一个事件触发类的不同事件了，大多数的开发需要都能满足了，不过如果用过C#的人就会看到其中的一些问题，就是事件链的问题，因为C#允许对事件进行”+=”和”-=”的操作，即事件触发类的一个事件是一个事件链，可以挂接多个事件处理方法，当事件触发类这一个事件触发时，可以通知多个事件
在C++中模拟委托事件方法的例子
11-22
例子中是文章《在C++中模拟委托事件方法》的例子，文章地址为http://blog.csdn.net/gogogo/article/details/6996290，详述了通过静态函数、接口、类模板、类模板事件链等不同方式实现其他语言中的委托事件模式，对于...
错误(2912) 尝试联系服务器 ********* 时发生内部错误: NO_PARAM: NO_PARAM。
weixin_34166847的博客
06-22 602
问题4错误(2912)尝试联系服务器 nssy-hy06.sznx.com.cn 时发生内部错误: NO_PARAM: NO_PARAM。WinRM: URL: [http://nssy-hy06.sznx.com.cn:5985], Verb: [INVOKE], Method: [GetError], Resource: [http://schemas.microsoft...
在C++中模拟委托事件的方法(下篇)
tiantiananan的专栏
11-26 593
转自：http://blog.csdn.net/gogogo/article/details/6999960 四、静态函数与类模板结合模拟事件 对应的例子工程名DelegateEvent 为了解决多个对象接收不同的事件的问题，同时规范化程序的编写，我们这里使用C++模板类的方法来定义一个委托类管理事件 1、  具体的实现方法 (1)、委托类模板的定义与实现
在C++中模拟委托事件的方法（一）
理性的幻想
11-26 567
转自 http://blog.csdn.net/gogogo/article/details/6996290   如果对C#、Delphi等语言熟悉，都知道这些语言支持委托事件的方法使用起来非常方便，并且能够较好的降低类的依赖关系，而C++语言没有集成这种语法，所以要想在C++使用这种事件模式需要开发人员自己来模拟，本文将提供多种模拟的方案，并会分析各自的优缺点，可以在需要的时候有选择的使用。
在C++中模拟委托事件的方法（六）
理性的幻想
11-26 556
转自 http://blog.csdn.net/gogogo/article/details/6999960 最后我们针对这4种比较可行的模拟事件方法进行一下评价，评价的标准主要考虑以下几个方面 1、  是否可以只接收事件触发类的一部分事件 2、  一个事件触发类是否支持多个事件接收类对象接收事件 3、  事件处理函数是否可以使用保护或私有的访问权限，保证事件接收类的封装特性 4、  书
在C++中模拟委托事件的方法（四）
理性的幻想
11-26 517
转自 http://blog.csdn.net/gogogo/article/details/6999477 三、静态函数方式实现多对象事件接收 对应的例子工程名MultiObjectEvent 在静态函数模拟事件方法中，如果读者细心的话，会发现类CNotifyClass只包含一个指定对象的成员变量m_pEventParameter，在使用RegisterEvent方法注册接收事件的函数时如
在C++中模拟委托事件的方法（二）
gogogo的专栏
11-22 3201
下边来看具体的实现方案   一、静态函数模拟事件 对应的例子工程名StaticFunctionEvent 1、  具体的实现方法 (1)、事件触发对象类CNotifyClass的类定义如下： typedef void (*PEVENT_NOPARAM_NORETURN)(void *); typedef int (*PEVENT_NOPARAM_RETURN)(void *); typ
C++ - 使用标准库实现事件和委托，信号和槽机制
HW140701的博客
11-02 1790
在本文中，我们对.Net的事件和委托，Qt的信号和槽进行了简单的介绍，然后通过引入Duilib中对于事件和委托的简单实现，进而扩展了自定义的简单事件类Event，此类实现的比较简单，但是包含了事件实践的核心思想，自己对于模板类，以及变参模板的使用又有了新的体会。
在C++中模拟委托事件的方法（三）
gogogo的专栏
11-22 2396
二、接口模拟事件 对应的例子工程名InterfaceEvent 由于C++不支持接口，但是支持抽象类和多重继承，所以可以通过class或struct模拟实现接口。 1、  具体的实现方法 (1)、事件触发对象类CNotifyClass的类定义如下： class INotifyClassEvent { public: INotifyClassEvent() {}; virtual ~I
在C++中模拟委托事件方法的例子免资源分
11-23
代码是文章《在C++中模拟委托事件方法》的例子，文章地址为http://blog.csdn.net/gogogo/article/details/6996290，详述了通过静态函数、接口、类模板、类模板事件链等不同方式实现其他语言中的委托事件模式，对于...
c++实现委托和事件
11-23
在C++编程中，模拟C#中的委托和事件机制是一项挑战，因为C++标准库并不直接支持这样的概念。然而，通过使用`std::function`和`std::bind`，我们可以实现类似的功能。以下是对这两个关键工具的详细解释，以及如何用...
简单的C++委托模拟
01-22
本文将详细介绍如何使用C++模拟C#中的委托。 首先，理解函数指针是关键。在C++中，函数可以被视为具有特定参数和返回值类型的值。函数指针就是一个变量，它存储了函数地址，可以用来调用该函数。例如，以下定义了一...
C++笔记5•内存管理•
qq_64446190的博客
08-12 1100
内存管理
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 158
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 212
C++ | Leetcode C++题解之第337题打家劫舍III
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 917
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++实现C#委托机制
06-10
C++ 并没有原生的委托机制，但可以通过函数指针和对象指针来模拟委托机制。 在 C++ 中，函数指针可以作为参数传递和返回值，可以使用函数指针来实现委托的功能。而对象指针可以用于保存对象的状态和数据，也可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值