转载 C++实现的委托机制

1.引言

下面的委托实现使用的MyGUI里面的委托实现，MyGUI是一款强大的GUI库，想理解更多的MyGUI信息，猛击这里http://mygui.info/

最终的代码可以在这里下载：http://download.csdn.net/detail/gouki04/3641328  我们的目标是要实现一个跟.NET几乎完全一样的委托，使用简单，支持多播，可以添加删除委托。同时支持C++的普通函数、模板函数、类成员函数，类的静态成员函数，并且支持多态。使用方式如下：

  1. // 普通函数
  2. void normalFunc(){ cout << "func1" << endl; }
  3. class Base
  4. {
  5. public:
  6. // 类成员函数
  7. void classFunc(){ cout << "Base func1" << endl; }
  8. };
  9. int main()
  10. {
  11. Base b;
  12. CMultiDelegate myDelegate;
  13. myDelegate += newDelegate(normalFunc);
  14. myDelegate += newDelegate(&b, &Base::classFunc);
  15. myDelegate(); // 此时会调用normalFunc和classFunc
  16. myDelegate -= newDelegate(&b, &Base::classFunc);
  17. myDelegate(); // 此时会调用normalFunc
  18. return 0;
  19. }

2.实现无参函数委托

要实现委托，首先要解决的是封装C++中的函数指针。因为在C++中，普通函数指针和类成员函数指针是完全不一样的。如下例子

  1. class CMyClass
  2. {
  3. public:
  4. void func(int);
  5. };
  6. // 定义一个指向CMyClass类型，参数列表为(int)，返回值为void的函数指针
  7. typedef void (CMyClass::*ClassMethod) (int); // 注意定义时使用了特殊的运算符::*

那么此函数指针只能指向CMyClass类型的成员函数，不能指向其他类或者普通函数

类成员函数指针不能直接调用，要通过一个类实例来调用，如下

  1. CMyClass *object = new CMyClass;
  2. ClassMethod method = CMyClass::func;
  3. (object->*method)(5); // 注意调用时使用了特殊运算符->*

那么如何封装呢？我们先来定义下接口吧

（为了简单起见，下面的实现都是以无参函数为例，后续会讲到如何支持任意参数）

  1. class IDelegate
  2. {
  3. public:
  4. virtual ~IDelegate() { }
  5. virtual bool isType(const std::type_info& _type) = 0;
  6. virtual void invoke() = 0;
  7. virtual bool compare(IDelegate *_delegate) const = 0;
  8. };

IDelegate类的接口很少，也很简单，必要接口只有一个，就是invoke，用于触发函数

但为了可以方便管理，使用了isType和compare函数来进行相等判断。

下面是封装的普通函数指针

  1. class CStaticDelegate : public IDelegate
  2. {
  3. public:
  4. typedef void (*Func)();
  5. CStaticDelegate(Func _func) : mFunc(_func) { }
  6. virtual bool isType( const std::type_info& _type) { return typeid(CStaticDelegate) == _type; }
  7. virtual void invoke() { mFunc(); }
  8. virtual bool compare(IDelegate *_delegate) const
  9. {
  10. if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate)) ) return false;
  11. CStaticDelegate * cast = static_cast<CStaticDelegate*>(_delegate);
  12. return cast->mFunc == mFunc;
  13. }
  14. private:
  15. Func mFunc;
  16. };

可以看到，CStaticDelegate只是简单地封装了普通函数指针，代码也非常简单

（类的某些成员函数，如isType和compare使用了RTTI，

对C++的动态类型判断不熟的可以猛击这里http://blog.csdn.net/gouki04/article/details/6796173）

好了，注意了，下面开始封装类成员函数指针

  1. template<class T>
  2. class CMethodDelegate : public IDelegate
  3. {
  4. public:
  5. typedef void (T::*Method)();
  6. CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
  7. virtual bool isType( const std::type_info& _type) { return typeid(CMethodDelegate) == _type; }
  8. virtual void invoke()
  9. {
  10. (mObject->*mMethod)();
  11. }
  12. virtual bool compare(IDelegate *_delegate) const
  13. {
  14. if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate)) ) return false;
  15. CMethodDelegate* cast = static_cast<CMethodDelegate* >(_delegate);
  16. return cast->mObject == mObject && cast->mMethod == mMethod;
  17. }
  18. private:
  19. T * mObject;
  20. Method mMethod;
  21. };

首先解释一下：因为类成员函数指针与类的类型有关，不同类的成员函数指针是不一样的。

要解决类型不同，很简单，使用模板就行。

代码跟CStaticDelegate基本一样，下面稍微解释一下：

CMethodDelegate类主要封装了一个类实例指针以及类成员函数的指针

这样在invoke时就不要额外的通过一个类实例了

要注意一点，compare函数的实现中，相等判定是类实例以及类函数指针都一样。

也就是说就算是指针同一个成员函数，但实例不同，委托就不同

为了方便使用，定义函数newDelegate来创建委托使用的函数

  1. inline IDelegate* newDelegate( void (*_func)() )
  2. {
  3. return new CStaticDelegate(_func);
  4. }
  5. template<class T>
  6. inline IDelegate* newDelegate( T * _object, void (T::*_method)() )
  7. {
  8. return new CMethodDelegate<T>(_object, _method);
  9. }

至此，对C++函数指针的封装就完成了，不难吧。

下面就是委托的实现了

  1. class CMultiDelegate
  2. {
  3. public:
  4. typedef std::list<IDelegate*> ListDelegate;
  5. typedef ListDelegate::iterator ListDelegateIterator;
  6. typedef ListDelegate::const_iterator ConstListDelegateIterator;
  7. CMultiDelegate () { }
  8. ~CMultiDelegate () { clear(); }
  9. bool empty() const
  10. {
  11. for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  12. {
  13. if (*iter) return false;
  14. }
  15. return true;
  16. }
  17. void clear()
  18. {
  19. for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  20. {
  21. if (*iter)
  22. {
  23. delete (*iter);
  24. (*iter) = 0;
  25. }
  26. }
  27. }
  28. CMultiDelegate& operator+=(IDelegate* _delegate)
  29. {
  30. for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  31. {
  32. if ((*iter) && (*iter)->compare(_delegate))
  33. {
  34. delete _delegate;
  35. return *this;
  36. }
  37. }
  38. mListDelegates.push_back(_delegate);
  39. return *this;
  40. }
  41. CMultiDelegate& operator-=(IDelegate* _delegate)
  42. {
  43. for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  44. {
  45. if ((*iter) && (*iter)->compare(_delegate))
  46. {
  47. if ((*iter) != _delegate) delete (*iter);
  48. (*iter) = 0;
  49. break;
  50. }
  51. }
  52. delete _delegate;
  53. return *this;
  54. }
  55. void operator()( )
  56. {
  57. ListDelegateIterator iter = mListDelegates.begin();
  58. while (iter != mListDelegates.end())
  59. {
  60. if (0 == (*iter))
  61. {
  62. iter = mListDelegates.erase(iter);
  63. }
  64. else
  65. {
  66. (*iter)->invoke();
  67. ++iter;
  68. }
  69. }
  70. }
  71. private:
  72. CMultiDelegate (const CMultiDelegate& _event);
  73. CMultiDelegate& operator=(const CMultiDelegate& _event);
  74. private:
  75. ListDelegate mListDelegates;
  76. };

仔细理解下CMultiDelegate类的实现，代码都不深奥。

比较重要的是3个函数 ：+=，-=，()运算符的重载函数

+= 用于添加一个委托函数

-= 用于去掉一个委托函数

() 用于触发委托函数

差不多就是普通的stl容器使用了。

这里要重点说明的一点是，大家仔细看 += 函数的实现中

  1. if ((*iter) && (*iter)->compare(_delegate))
  2. {
  3. delete _delegate; // 如果该委托函数已经被添加了，则delete掉外部的_delegate
  4. return *this;
  5. }

为什么要delete掉外部的指针呢？

因为C++的内存泄露一直是个麻烦事，所以MyUGI的委托里，所有的委托函数统一由Delegate本身管理

外部不要自己new或delete委托函数，也不要保存一个委托函数，Delegate本身会管理好的。

建议像如下使用：

  1. CMultiDelegate myDelegate;
  2. myDelegate += newDelegate(normalFunc);
  3. myDelegate -= newDelegate(normalFunc);

而不建议像如下使用：

  1. CMultiDelegate myDelegate;
  2. IDelegate* delegateFunc = newDelegate(normalFunc);
  3. myDelegate += delegateFunc;
  4. myDelegate -= delegateFunc;

上面2种方法都没错，都不会造成内存泄露

你可能会觉得第2种方法减少new的次数，比第一种方法更好。其实不然，因为第2种方法有个很大的隐患

  1. myDelegate -= delegateFunc; // 在这一步，delegateFunc所指向的空间已经被释放掉了（在-=函数里面）

所以如果你后面又想将delegateFunc添加到myDelegate里面时，你就不能再这样用了

  1. myDelegate += delegateFunc; // 错误，因为delegateFunc的空间已经被释放了

你得重新new一个

delegateFunc = newDelegate(normalFunc);

myDelegate += delegateFunc;

相信你不会愿意这样做的，因为这种方法很容易造成内存泄露或者崩溃

现在你应该可以明白 -= 函数是怎么释放委托函数内存了吧。

1.实现任意参数的函数委托

按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？

注：最终的实现代码可以在这里下载：http://download.csdn.net/detail/gouki04/3641328

只能不同个数各实现一个类，如

  1. // 单参函数委托
  2. template<typename TP1>
  3. class CMultiDelegate1{};
  4. // 双参函数委托
  5. template<typename TP1, typename TP2>
  6. class CMultiDelegate2{};

注意类名是不一样的，分别为CMultiDelegate1和CMultiDelegate2

C++里面，类名相同但模板参数个数不同是会当成一个类对待的，所以那样编译不过的

这样是不是很麻烦呢？

不是很麻烦，是相当麻烦。因为不单单是CMultiDelegate要实现多个参数的版本

连IDelegate、CStaticDelegate和CMethodDelegate都要实现对应的多个参数的版本！

其实所有版本的内部实现几乎一样，下面给出双参函数的版本

  1. template<typename TP1, typename TP2>
  2. class IDelegate2
  3. {
  4. public:
  5. virtual ~IDelegate2() { }
  6. virtual bool isType( const std::type_info& _type) = 0;
  7. virtual void invoke( TP1 p1, TP2 p2 ) = 0;
  8. virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const = 0;
  9. };
  10. template<typename TP1, typename TP2>
  11. class CStaticDelegate2 : public  IDelegate2<typename TP1, typename TP2>
  12. {
  13. public:
  14. typedef void (*Func)( TP1 p1, TP2 p2 );
  15. CStaticDelegate2 (Func _func) : mFunc(_func) { }
  16. virtual bool isType( const std::type_info& _type) { return typeid( CStaticDelegate2<typename TP1, typename TP2> ) == _type; }
  17. virtual void invoke( TP1 p1, TP2 p2 )
  18. {
  19. mFunc( p1, p2 );
  20. }
  21. virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const
  22. {
  23. if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate2 <typename TP1, typename TP2>)) ) return false;
  24. CStaticDelegate2 <typename TP1, typename TP2> * cast = static_cast<CStaticDelegate2 <typename TP1, typename TP2> *>(_delegate);
  25. return cast->mFunc == mFunc;
  26. }
  27. virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
  28. private:
  29. Func mFunc;
  30. };
  31. template <typename T, typename TP1, typename TP2>
  32. class CMethodDelegate2 : public  IDelegate2 <typename TP1, typename TP2>
  33. {
  34. public:
  35. typedef void (T::*Method)( TP1 p1, TP2 p2 );
  36. CMethodDelegate2(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
  37. virtual bool isType( const std::type_info& _type) { return typeid( CMethodDelegate2 <T, TP1, TP2> ) == _type; }
  38. virtual void invoke( TP1 p1, TP2 p2 )
  39. {
  40. (mObject->*mMethod)( p1, p2 );
  41. }
  42. virtual bool compare(  IDelegate2 <typename TP1, typename TP2>  * _delegate) const
  43. {
  44. if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate2 <T, TP1, TP2>)) ) return false;
  45. CMethodDelegate2 <T, TP1, TP2>  * cast = static_cast<  CMethodDelegate2 <T, TP1, TP2>  * >(_delegate);
  46. return cast->mObject == mObject && cast->mMethod == mMethod;
  47. }
  48. private:
  49. T * mObject;
  50. Method mMethod;
  51. };
  52. template   <typename TP1, typename TP2>
  53. inline  delegates::IDelegate2 <typename TP1, typename TP2>  * newDelegate( void (*_func)( TP1 p1, TP2 p2 ) )
  54. {
  55. return new delegates::CStaticDelegate2 <typename TP1, typename TP2>  (_func);
  56. }
  57. template <typename T, typename TP1, typename TP2>
  58. inline  delegates::IDelegate2 <typename TP1, typename TP2>  * newDelegate( T * _object, void (T::*_method)( TP1 p1, TP2 p2 ) )
  59. {
  60. return new delegates::CMethodDelegate2  <T, TP1, TP2>  (_object, _method);
  61. }
  62. template   <typename TP1, typename TP2>
  63. class CMultiDelegate2
  64. {
  65. public:
  66. typedef IDelegate2 <typename TP1, typename TP2>  IDelegate;
  67. typedef typename std::list<IDelegate*> ListDelegate;
  68. typedef typename ListDelegate::iterator ListDelegateIterator;
  69. typedef typename ListDelegate::const_iterator ConstListDelegateIterator;
  70. CMultiDelegate2 () { }
  71. ~CMultiDelegate2 () { clear(); }
  72. bool empty() const
  73. {
  74. for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  75. {
  76. if (*iter) return false;
  77. }
  78. return true;
  79. }
  80. void clear()
  81. {
  82. for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  83. {
  84. if (*iter)
  85. {
  86. delete (*iter);
  87. (*iter) = 0;
  88. }
  89. }
  90. }
  91. CMultiDelegate2  <typename TP1, typename TP2> & operator+=(IDelegate* _delegate)
  92. {
  93. for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  94. {
  95. if ((*iter) && (*iter)->compare(_delegate))
  96. {
  97. delete _delegate;
  98. return *this;
  99. //MYGUI_ASSERT(false, "dublicate delegate");
  100. }
  101. }
  102. mListDelegates.push_back(_delegate);
  103. return *this;
  104. }
  105. CMultiDelegate2  <typename TP1, typename TP2> & operator-=(IDelegate* _delegate)
  106. {
  107. for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  108. {
  109. if ((*iter) && (*iter)->compare(_delegate))
  110. {
  111. if ((*iter) != _delegate) delete (*iter);
  112. (*iter) = 0;
  113. break;
  114. }
  115. }
  116. delete _delegate;
  117. return *this;
  118. }
  119. void operator()( TP1 p1, TP2 p2 )
  120. {
  121. ListDelegateIterator iter = mListDelegates.begin();
  122. while (iter != mListDelegates.end())
  123. {
  124. if (0 == (*iter))
  125. {
  126. iter = mListDelegates.erase(iter);
  127. }
  128. else
  129. {
  130. (*iter)->invoke( p1, p2 );
  131. ++iter;
  132. }
  133. }
  134. }
  135. private:
  136. CMultiDelegate2 (const CMultiDelegate2  <typename TP1, typename TP2> & _event);
  137. CMultiDelegate2<typename TP1, typename TP2> & operator=(const CMultiDelegate2<typename TP1, typename TP2> & _event);
  138. private:
  139. ListDelegate mListDelegates;
  140. };

当然放心啦，不会让大家将不同参数的版本各写一遍的

下面要介绍的是MyGUI的解决方法，一个利用预编译和头文件重复编译的方法（很有意思的）

我们一般写头文件时，都会加上防止头文件重复编译的代码，如

  1. #ifndef __XXX_H__
  2. #define __XXX_H__
  3. // ..类声明等
  4. #endif

这里我们就要反其道而行，去掉防止重复编译的代码，然后重复包含这个头文件，但每次其编译的都是不同参数个数的版本

第一次编译的是无参的，第二次是单参的，第三次是双参.....一直到你想要支持的参数个数

那怎么让其每次编译的都不同呢？

答案就是使用强大的预编译：宏

下面给出单参的IDelegate的例子

首先定义以下宏：

  1. #define DELEGATE_TEMPLATE template
  2. #define DELEGATE_TEMPLATE_PARAMS <typename TP1>
  3. #define DELEGATE_TEMPLATE_ARGS TP1 p1
  4. #define MYGUI_I_DELEGATE IDelegate1

那么下面这段代码就会编译出单参的IDelegate版本

  1. DELEGATE_TEMPLATE   DELEGATE_TEMPLATE_PARAMS
  2. class MYGUI_I_DELEGATE
  3. {
  4. public:
  5. virtual ~MYGUI_I_DELEGATE() { }
  6. virtual bool isType( const std::type_info& _type) = 0;
  7. virtual void invoke( DELEGATE_PARAMS ) = 0;
  8. virtual bool compare(  MYGUI_I_DELEGATE DELEGATE_TEMPLATE_ARGS  * _delegate) const = 0;
  9. };

神奇吧，这里使用的可以说是宏实现的多态。

在这段代码编译完了之后，将所有宏都undefine掉，如

  1. #undef DELEGATE_TEMPLATE
  2. #undef DELEGATE_TEMPLATE_PARAMS
  3. #undef DELEGATE_TEMPLATE_ARGS
  4. #undef MYGUI_I_DELEGATE

再重新定义双参版本的，如

  1. #define DELEGATE_TEMPLATE template
  2. #define DELEGATE_TEMPLATE_PARAMS <typename TP1, typename TP2>
  3. #define DELEGATE_TEMPLATE_ARGS TP1 p1, TP2 p2
  4. #define MYGUI_I_DELEGATE IDelegate2

那么编译出来的就是双参的版本了！

使用这种方法就可以将其他的如CStaticDelegate、CMethodDelegate和CMultiDelegate的各种版本都实现了，

而你要做的仅是重新define下那些宏就行了，够方便了吧。

下一篇文章将会介绍MyGUI实现的一些辅助类，如单委托和DelegateUnlink。并给出一个测试例子，测试该委托机制对C++各种函数的支持。

1.引言

按上一篇文章的方法，你已经可以使用任意参数的函数委托了。这里介绍下MyGUI实现的两个辅助类，CDelegate类和IDelegateUnlink。如果你不为了深入了解MyGUI的委托实现，可以跳过此处。CDelegate即为单委托，实际效果跟函数指针差不多，于CMultiDelegate的区别在于其不支持多播。而IDelegateUnlink类主要是在CMultiDelegate中使用，在多播下一次性去掉自身的所有委托。

2.单委托

  1. // 无参的单委托实现
  2. class CDelegate
  3. {
  4. public:
  5. typedef CDelegate IDelegate;
  6. CDelegate () : mDelegate(0) { }
  7. CDelegate (const CDelegate& _event)
  8. {
  9. // 在拷贝构造时，将被拷贝的委托去掉，即委托只存在一份
  10. mDelegate = _event.mDelegate;
  11. const_cast<CDelegate&>(_event).mDelegate = 0;
  12. }
  13. ~CDelegate () { clear(); }
  14. bool empty() const { return mDelegate == 0; }
  15. void clear()
  16. {
  17. if (mDelegate)
  18. {
  19. delete mDelegate;
  20. mDelegate = 0;
  21. }
  22. }
  23. CDelegate & operator=(IDelegate* _delegate)
  24. {
  25. delete mDelegate;
  26. mDelegate = _delegate;
  27. return *this;
  28. }
  29. CDelegate & operator=(const CDelegate& _event)
  30. {
  31. // 在赋值时，将右值的委托去掉，即委托只存在一份
  32. delete mDelegate;
  33. mDelegate = _event.mDelegate;
  34. const_cast<CDelegate&>(_event).mDelegate = 0;
  35. return *this;
  36. }
  37. void operator()( )
  38. {
  39. if (mDelegate == 0) return;
  40. mDelegate->invoke( );
  41. }
  42. private:
  43. IDelegate * mDelegate;
  44. };

可以看到，单委托只实现了 = 运算符，没有实现 += 运算符。
而且在赋值时会将原委托去掉，确保只有一份委托。
其实单委托跟普通函数指针差不多，在使用单委托的地方可以换成使用普通函数指针。

3.断开委托

  1. // 断开委托的基类
  2. class IDelegateUnlink
  3. {
  4. public:
  5. virtual ~IDelegateUnlink() { }
  6. IDelegateUnlink() { m_baseDelegateUnlink = this; }
  7. bool compare(IDelegateUnlink * _unlink) const { return m_baseDelegateUnlink == _unlink->m_baseDelegateUnlink; }
  8. private:
  9. IDelegateUnlink * m_baseDelegateUnlink;
  10. };

所谓断开委托，只能用在多重委托，即CMultiDelegate中，可以断开自身与其相连的所有委托。
使用方法就在将自身的类从IDelegateUnlink派生，然后使用CMultiDelegate中的clear函数即可断开委托。
在下面会有例子说明。

4.测试

  1. /* 测试Delegate对不同函数的支持
  2. * 可以参考下不同函数的使用方式
  3. */
  4. #include "delegate.h"
  5. #include <iostream>
  6. using namespace std;
  7. // 普通函数1
  8. void func(int a, int b)
  9. {
  10. cout << "func(" << a << ", " << b << ")" << endl;
  11. }
  12. // 普通函数2
  13. void func2(int a, int b)
  14. {
  15. cout << "func2(" << a << ", " << b << ")" << endl;
  16. }
  17. // 普通类
  18. class NormalClass
  19. {
  20. public:
  21. // 类的普通成员函数
  22. void normalFunc(int a, int b)
  23. {
  24. cout << "NormalClass::normalFunc(" << a << ", " << b << ")" << endl;
  25. }
  26. };
  27. // 实现了IDelegateUnlink的类
  28. class BaseUnlinkClass : public delegates::IDelegateUnlink
  29. {
  30. public:
  31. // 类的虚函数
  32. virtual void virFunc(int a, int b)
  33. {
  34. cout << "BaseUnlinkClass::virFunc(" << a << ", " << b << ")" << endl;
  35. }
  36. // 类的普通成员函数
  37. void normalFunc(int a, int b)
  38. {
  39. cout << "BaseUnlinkClass::normalFunc(" << a << ", " << b << ")" << endl;
  40. }
  41. };
  42. class DerivedClass : public BaseUnlinkClass
  43. {
  44. public:
  45. // 类的虚函数
  46. virtual void virFunc(int a, int b)
  47. {
  48. cout << "DerivedClass::virFunc(" << a << ", " << b << ")" << endl;
  49. }
  50. // 类的静态成员函数
  51. static void staticFunc(int a, int b)
  52. {
  53. cout << "DerivedClass::staticFunc(" << a << ", " << b << ")" << endl;
  54. }
  55. };
  56. // 模板函数
  57. template<class T>
  58. void TFunc(T a, T b)
  59. {
  60. cout << "TFunc(" << a << ", " << b << ")" << endl;
  61. }
  62. int main()
  63. {
  64. BaseUnlinkClass *baseUnlinkClass = new BaseUnlinkClass;
  65. DerivedClass *derivedClass = new DerivedClass;
  66. NormalClass *normalClass = new NormalClass;
  67. // 定义委托
  68. typedef delegates::CMultiDelegate2<int, int> EvenetHandler;
  69. EvenetHandler event;
  70. // 添加普通函数
  71. event += newDelegate(func);
  72. event += newDelegate(func2);
  73. // 添加类的普通成员函数
  74. event += newDelegate(normalClass, &NormalClass::normalFunc);
  75. event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::normalFunc);
  76. // 添加类的虚函数
  77. event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::virFunc);
  78. event += newDelegate(derivedClass, &DerivedClass::virFunc);
  79. // 注意在多态下，使用基类指针时，函数指针要用基类的函数指针，不能用派生类的
  80. // 但是在调用时会响应多态，也就是会调用派生类的虚函数
  81. event += newDelegate((BaseUnlinkClass*)derivedClass, &BaseUnlinkClass::virFunc);
  82. // 添加类的静态成员函数
  83. event += newDelegate(&DerivedClass::staticFunc);
  84. // 添加模板函数
  85. event += newDelegate(TFunc<int>);
  86. // 触发事件
  87. event(1, 2);
  88. cout << endl;
  89. // 去掉函数
  90. event -= newDelegate(func);
  91. // 去掉baseUnlinkClass所有的函数
  92. event.clear(baseUnlinkClass);
  93. // 去掉derivedClass所有的函数
  94. // 注意静态成员函数staticFunc不会去掉
  95. event.clear(derivedClass);
  96. //event.clear(normalClass);
  97. // 错误调用，normalClass不是IDelegateUnlink的派生类
  98. // 不能使用clear去掉自身的函数
  99. // 应该使用如下方法
  100. event -= newDelegate(normalClass, &NormalClass::normalFunc);
  101. // 触发事件
  102. event(2, 3);
  103. cout << endl;
  104. return 0;
  105. }

转载 C++实现的委托机制相关推荐

  1. java 委托机制_通过反射实现Java下的委托机制代码详解

    简述 一直对Java没有现成的委托机制耿耿于怀,所幸最近有点时间,用反射写了一个简单的委托模块,以供参考. 模块API public Class Delegater()//空参构造,该类管理委托实例并 ...

  2. java委托机制教程_通过反射实现Java下的委托机制代码详解

    简述 一直对java没有现成的委托机制耿耿于怀,所幸最近有点时间,用反射写了一个简单的委托模块,以供参考. 模块api public class delegater()//空参构造,该类管理委托实例并 ...

  3. Kotlin的委托机制

    Kotlin 的委托机制在语言层面自动实现了 Java 的组合代理.Kotlin 的委托包括委托类.委托属性,使用 by 关键字表示委托. 委托类 假设有一个接口类 Db,用来保存数据. interf ...

  4. 转载：Lock锁机制的原理及与Synchronized的比较——源码解说

    文章转载自:https://blog.csdn.net/Luxia_24/article/details/52403033(为了简化阅读难度,本文只挑选了大部分内容进行转载,并对代码进行了注释,更加详 ...

  5. [转载]Node.js模块化机制原理探究

    转载地址:https://segmentfault.com/a/1190000008371376 前言 Node应用是由模块组成的,Node遵循了CommonJS的模块规范,来隔离每个模块的作用域,使 ...

  6. [转载]Python垃圾回收机制--完美讲解!

    虽然是自己转载的但是是真的好的一篇图文并茂的对垃圾回收机制的讲解!!! 先来个概述,第二部分的画述才是厉害的. Garbage collection(GC) 现在的高级语言如java,c#等,都采用了 ...

  7. [转载]Linux 线程实现机制分析

    自从多线程编程的概念出现在 Linux 中以来,Linux 多线应用的发展总是与两个问题脱不开干系:兼容性.效率.本文从线程模型入手,通过分析目前 Linux 平台上最流行的 LinuxThreads ...

  8. C++ 0x 使用可变参数模板类 实现 C# 的委托机制

    1 #ifndef _ZTC_DELEGATE_H_ 2 #define _ZTC_DELEGATE_H_ 3 4 #include <vector> 5 #include <fun ...

  9. 【转载】Java重试机制

    重试机制在分布式系统中,或者调用外部接口中,都是十分重要的. 重试机制可以保护系统减少因网络波动.依赖服务短暂性不可用带来的影响,让系统能更稳定的运行的一种保护机制. 为了方便说明,先假设我们想要进行 ...

最新文章

  1. 单片机教学视频讲得好
  2. OVS对VXLAN解封包（二）
  3. AI：基于计算机视觉和语音识别案例项目打包过程记录20181226-19
  4. AD18 KeepOut不能打孔，转成3D不显示孔的位置
  5. 使用Jexus 容器化您的 Blazor 应用程序
  6. mongodb简单的增删改查
  7. Java StringBuilder reverse（）方法与示例
  8. 24 MM配置-采购-配额管理-定义编码范围
  9. 原创 | 职场二十年（一）电话风波
  10. esp8266WIFI模块教程：正点原子ATK-ESP8266进行网络通信，单片机与电脑，单片机与手机发送数据
  11. WPS2003排版位置错误一例(转)
  12. 无人机成测绘界“全能战士”
  13. 恶搞视频聊天偷拍源码
  14. 测试人，测试魂，3年测遍32个城，主管的一句话给予了他源源不断的动力
  15. PHP开发的H5即时通讯聊天系统源码 带群聊 可封装APP
  16. 统计学习导论之R语言应用（四）：分类算法R语言代码实战
  17. 酚酸靶向助力组合消毒剂在新鲜农产品中的应用研究
  18. Gizmo for Linux 1.1.0.39
  19. 『统计学』第五部分：方差分析和F检验
  20. Elasticsearch的这几个概念你还不知道啥意思呢？

热门文章

  1. Kotlin极简教程：第9章 轻量级线程：协程
  2. Android 测试教程
  3. workbench设置单元坐标系_Workbench菜单选项中英文对照
  4. WEB中get请求和post请求的区别
  5. 认识Python(day01)
  6. 悬镜 linux防黑加固平台,悬镜答疑丨悬镜服务器防护CC效果如何？
  7. php提示行号,在php中使用trigger_错误时如何获得正确的行号?
  8. 星外主机管理系统可以装到内网_智慧消防管理系统_消防物联网远程管理平台...
  9. redis配置密码_Redis数据库概述
  10. 温度自动调节 c语言编写,室内温度自动调节控制系统课程设计（26页）-原创力文档...