1.引言
下面的委托實現使用的MyGUI裡面的委托實現，MyGUI是一款強大的GUI庫，想理解更多的MyGUI信息，猛擊這裡mygui.info
最終的代碼可以在這裡下載:http://www.BkJia.com/uploadfile/2011/1009/20111009023128248.rar
我們的目標是要實現一個跟.NET幾乎完全一樣的委托，使用簡單，支持多播，可以添加刪除委托。同時支持C++的普通函數、模板函數、類成員函數，類的靜態成員函數，並且支持多態。使用方式如下：
copy to clipboardprint?// 普通函數
void normalFunc(){ cout << "func1" << endl; }
class Base
{
public:
// 類成員函數
void classFunc(){ cout << "Base func1" << endl; }
};
int main() www.2cto.com
{
Base b;
CMultiDelegate myDelegate;
myDelegate += newDelegate(normalFunc);
myDelegate += newDelegate(&b, &Base::classFunc);
myDelegate(); // 此時會調用normalFunc和classFunc
myDelegate -= newDelegate(&b, &Base::classFunc);
myDelegate(); // 此時會調用normalFunc
return 0;
}
// 普通函數
void normalFunc(){ cout << "func1" << endl; }
class Base
{
public:
// 類成員函數
void classFunc(){ cout << "Base func1" << endl; }
};
int main()
{
Base b;
CMultiDelegate myDelegate;
myDelegate += newDelegate(normalFunc);
myDelegate += newDelegate(&b, &Base::classFunc);
myDelegate(); // 此時會調用normalFunc和classFunc
myDelegate -= newDelegate(&b, &Base::classFunc);
myDelegate(); // 此時會調用normalFunc
return 0;
}
2.實現無參函數委托
要實現委托，首先要解決的是封裝C++中的函數指針。因為在C++中，普通函數指針和類成員函數指針是完全不一樣的。如下例子
copy to clipboardprint?class CMyClass
{
public:
void func(int);
};
// 定義一個指向CMyClass類型，參數列表為(int)，返回值為void的函數指針
typedef void (CMyClass::*ClassMethod) (int); // 注意定義時使用了特殊的運算符::*
class CMyClass
{
public:
void func(int);
};
// 定義一個指向CMyClass類型，參數列表為(int)，返回值為void的函數指針
typedef void (CMyClass::*ClassMethod) (int); // 注意定義時使用了特殊的運算符::*
那麼此函數指針只能指向CMyClass類型的成員函數，不能指向其他類或者普通函數
類成員函數指針不能直接調用，要通過一個類實例來調用，如下
copy to clipboardprint?CMyClass *object = new CMyClass;
ClassMethod method = CMyClass::func;
(object->*method)(5); // 注意調用時使用了特殊運算符->*
CMyClass *object = new CMyClass;
ClassMethod method = CMyClass::func;
(object->*method)(5); // 注意調用時使用了特殊運算符->*
那麼如何封裝呢？我們先來定義下接口吧
（為了簡單起見，下面的實現都是以無參函數為例，後續會講到如何支持任意參數）
copy to clipboardprint?class IDelegate
{
public:
virtual ~IDelegate() { }
virtual bool isType(const std::type_info& _type) = 0;
virtual void invoke() = 0;
virtual bool compare(IDelegate *_delegate) const = 0;
};
class IDelegate
{
public:
virtual ~IDelegate() { }
virtual bool isType(const std::type_info& _type) = 0;
virtual void invoke() = 0;
virtual bool compare(IDelegate *_delegate) const = 0;
};
IDelegate類的接口很少，也很簡單，必要接口只有一個，就是invoke，用於觸發函數
但為了可以方便管理，使用了isType和compare函數來進行相等判斷。
下面是封裝的普通函數指針
copy to clipboardprint?class CStaticDelegate : public IDelegate
{
public:
typedef void (*Func)();
CStaticDelegate(Func _func) : mFunc(_func) { }
virtual bool isType( const std::type_info& _type) { return typeid(CStaticDelegate) == _type; }
virtual void invoke() { mFunc(); }
virtual bool compare(IDelegate *_delegate) const
{
if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate)) ) return false;
CStaticDelegate * cast = static_cast<CStaticDelegate*>(_delegate);
return cast->mFunc == mFunc;
}
private:
Func mFunc;
};
class CStaticDelegate : public IDelegate
{
public:
typedef void (*Func)();
CStaticDelegate(Func _func) : mFunc(_func) { }
virtual bool isType( const std::type_info& _type) { return typeid(CStaticDelegate) == _type; }
virtual void invoke() { mFunc(); }
virtual bool compare(IDelegate *_delegate) const
{
if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate)) ) return false;
CStaticDelegate * cast = static_cast<CStaticDelegate*>(_delegate);
return cast->mFunc == mFunc;
}
private:
Func mFunc;
};
可以看到，CStaticDelegate只是簡單地封裝了普通函數指針，代碼也非常簡單
（類的某些成員函數，如isType和compare使用了RTTI，
對C++的動態類型判斷不熟的可以猛擊這裡http://blog.csdn.net/gouki04/article/details/6796173）
好了，注意了，下面開始封裝類成員函數指針
copy to clipboardprint?template<class T>
class CMethodDelegate : public IDelegate
{
public:
typedef void (T::*Method)();
CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
virtual bool isType( const std::type_info& _type) { return typeid(CMethodDelegate) == _type; }
virtual void invoke()
{
(mObject->*mMethod)();
}
virtual bool compare(IDelegate *_delegate) const
{
if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate)) ) return false;
CMethodDelegate* cast = static_cast<CMethodDelegate* >(_delegate);
return cast->mObject == mObject && cast->mMethod == mMethod;
}
private:
T * mObject;
Method mMethod;
};
template<class T>
class CMethodDelegate : public IDelegate
{
public:
typedef void (T::*Method)();
CMethodDelegate(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
virtual bool isType( const std::type_info& _type) { return typeid(CMethodDelegate) == _type; }
virtual void invoke()
{
(mObject->*mMethod)();
}
virtual bool compare(IDelegate *_delegate) const
{
if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate)) ) return false;
CMethodDelegate* cast = static_cast<CMethodDelegate* >(_delegate);
return cast->mObject == mObject && cast->mMethod == mMethod;
}
private:
T * mObject;
Method mMethod;
};
首先解釋一下：因為類成員函數指針與類的類型有關，不同類的成員函數指針是不一樣的。
要解決類型不同，很簡單，使用模板就行。
代碼跟CStaticDelegate基本一樣，下面稍微解釋一下：
CMethodDelegate類主要封裝了一個類實例指針以及類成員函數的指針
這樣在invoke時就不要額外的通過一個類實例了
要注意一點，compare函數的實現中，相等判定是類實例以及類函數指針都一樣。
也就是說就算是指針同一個成員函數，但實例不同，委托就不同
為了方便使用，定義函數newDelegate來創建委托使用的函數
copy to clipboardprint?inline IDelegate* newDelegate( void (*_func)() )
{
return new CStaticDelegate(_func);
}
template<class T>
inline IDelegate* newDelegate( T * _object, void (T::*_method)() )
{
return new CMethodDelegate<T>(_object, _method);
}
inline IDelegate* newDelegate( void (*_func)() )
{
return new CStaticDelegate(_func);
}
template<class T>
inline IDelegate* newDelegate( T * _object, void (T::*_method)() )
{
return new CMethodDelegate<T>(_object, _method);
}
至此，對C++函數指針的封裝就完成了，不難吧。
下面就是委托的實現了
copy to clipboardprint?class CMultiDelegate
{
public:
typedef std::list<IDelegate*> ListDelegate;
typedef ListDelegate::iterator ListDelegateIterator;
typedef ListDelegate::const_iterator ConstListDelegateIterator;
CMultiDelegate () { }
~CMultiDelegate () { clear(); }
bool empty() const
{
for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if (*iter) return false;
}
return true;
}
void clear()
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if (*iter)
{
delete (*iter);
(*iter) = 0;
}
}
}
CMultiDelegate& operator+=(IDelegate* _delegate)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_delegate))
{
delete _delegate;
return *this;
}
}
mListDelegates.push_back(_delegate);
return *this;
}
CMultiDelegate& operator-=(IDelegate* _delegate)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_delegate))
{
if ((*iter) != _delegate) delete (*iter);
(*iter) = 0;
break;
}
}
delete _delegate;
return *this;
}
void operator()( )
{
ListDelegateIterator iter = mListDelegates.begin();
while (iter != mListDelegates.end())
{
if (0 == (*iter))
{
iter = mListDelegates.erase(iter);
}
else
{
(*iter)->invoke();
++iter;
}
}
}
private:
CMultiDelegate (const CMultiDelegate& _event);
CMultiDelegate& operator=(const CMultiDelegate& _event);
private:
ListDelegate mListDelegates;
};
class CMultiDelegate
{
public:
typedef std::list<IDelegate*> ListDelegate;
typedef ListDelegate::iterator ListDelegateIterator;
typedef ListDelegate::const_iterator ConstListDelegateIterator;
CMultiDelegate () { }
~CMultiDelegate () { clear(); }
bool empty() const
{
for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if (*iter) return false;
}
return true;
}
void clear()
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if (*iter)
{
delete (*iter);
(*iter) = 0;
}
}
}
CMultiDelegate& operator+=(IDelegate* _delegate)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_delegate))
{
delete _delegate;
return *this;
}
}
mListDelegates.push_back(_delegate);
return *this;
}
CMultiDelegate& operator-=(IDelegate* _delegate)
{
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
{
if ((*iter) && (*iter)->compare(_delegate))
{
if ((*iter) != _delegate) delete (*iter);
(*iter) = 0;
break;
}
}
delete _delegate;
return *this;
}
void operator()( )
{
ListDelegateIterator iter = mListDelegates.begin();
while (iter != mListDelegates.end())
{
if (0 == (*iter))
{
iter = mListDelegates.erase(iter);
}
else
{
(*iter)->invoke();
++iter;
}
}
}
private:
CMultiDelegate (const CMultiDelegate& _event);
CMultiDelegate& operator=(const CMultiDelegate& _event);
private:
ListDelegate mListDelegates;
};
仔細理解下CMultiDelegate類的實現，代碼都不深奧。
比較重要的是3個函數 ：+=，-=，()運算符的重載函數
+= 用於添加一個委托函數
-= 用於去掉一個委托函數
() 用於觸發委托函數
差不多就是普通的stl容器使用了。
這裡要重點說明的一點是，大家仔細看 += 函數的實現中
copy to clipboardprint?if ((*iter) && (*iter)->compare(_delegate))
{
delete _delegate; // 如果該委托函數已經被添加了，則delete掉外部的_delegate
return *this;
}
if ((*iter) && (*iter)->compare(_delegate))
{
delete _delegate; // 如果該委托函數已經被添加了，則delete掉外部的_delegate
return *this;
}
為什麼要delete掉外部的指針呢？
因為C++的內存洩露一直是個麻煩事，所以MyUGI的委托裡，所有的委托函數統一由Delegate本身管理
外部不要自己new或delete委托函數，也不要保存一個委托函數，Delegate本身會管理好的。
建議像如下使用：
copy to clipboardprint?CMultiDelegate myDelegate;
myDelegate += newDelegate(normalFunc);
myDelegate -= newDelegate(normalFunc);
CMultiDelegate myDelegate;
myDelegate += newDelegate(normalFunc);
myDelegate -= newDelegate(normalFunc);
而不建議像如下使用：
copy to clipboardprint?CMultiDelegate myDelegate;
IDelegate* delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
myDelegate -= delegateFunc;
CMultiDelegate myDelegate;
IDelegate* delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
myDelegate -= delegateFunc;
上面2種方法都沒錯，都不會造成內存洩露
你可能會覺得第2種方法減少new的次數，比第一種方法更好。其實不然，因為第2種方法有個很大的隱患
copy to clipboardprint?myDelegate -= delegateFunc; // 在這一步，delegateFunc所指向的空間已經被釋放掉了（在-=函數裡面）
myDelegate -= delegateFunc; // 在這一步，delegateFunc所指向的空間已經被釋放掉了（在-=函數裡面）
所以如果你後面又想將delegateFunc添加到myDelegate裡面時，你就不能再這樣用了
copy to clipboardprint?myDelegate += delegateFunc; // 錯誤，因為delegateFunc的空間已經被釋放了
myDelegate += delegateFunc; // 錯誤，因為delegateFunc的空間已經被釋放了
你得重新new一個
delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
相信你不會願意這樣做的，因為這種方法很容易造成內存洩露或者崩潰
現在你應該可以明白 -= 函數是怎麼釋放委托函數內存了吧。
按上面的方法，你已經可以使用無參數的函數委托了。下一篇文章將會介紹如何實現任意參數的函數委托
