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

转载 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. }