C++實現的委托機制

1.引言

下面的委托實現使用的MyGUI裡面的委托實現，MyGUI是一款強大的GUI庫，想理解更多的MyGUI信息，猛擊這裡。

我們的目標是要實現一個跟.NET幾乎完全一樣的委托，使用簡單，支持多播，可以添加刪除委托。同時支持C++的普通函數、模板函數、類成員函數，類的靜態成員函數，並且支持多態。

最終的代碼可以在這裡下載：

免費下載地址在 http://linux.linuxidc.com/

用戶名與密碼都是www.linuxidc.com

具體下載目錄在 /2012年資料/8月/19日/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://www.linuxidc.com/Linux/2012-08/68655.htm ）

好了，注意��，下面開始封裝類成員函數指針

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的空間已經被釋放了

delegateFunc = newDelegate(normalFunc);

myDelegate += delegateFunc;

相信你不會願意這樣做的，因為這種方法很容易造成內存洩露或者崩潰

現在你應該可以明白 -= 函數是怎麼釋放委托函數內存了吧。

按上面的方法，你已經可以使用無參數的函數委托了。下一篇文章將會介紹如何實現任意參數的函數委托。