|
1.引言
下面的委托实现使用的MyGUI里面的委托实现，MyGUI是一款强大的GUI库，想理解更多的MyGUI信息，猛击这里http://mygui.info/
最终的代码可以在这里下载：http://download.csdn.net/detail/gouki04/3641328 我们的目标是要实现一个跟.NET几乎完全一样的委托，使用简单，支持多播，可以添加删除委托。同时支持C++的普通函数、模板函数、类成员函数，类的静态成员函数，并且支持多态。使用方式如下：
-
- 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();
- myDelegate -= newDelegate(&b, &Base::classFunc);
- myDelegate();
- return 0;
- }
2.实现无参函数委托
要实现委托，首先要解决的是封装C++中的函数指针。因为在C++中，普通函数指针和类成员函数指针是完全不一样的。如下例子
- class CMyClass
- {
- public:
- void func(int);
- };
-
- typedef void (CMyClass::*ClassMethod) (int);
那么此函数指针只能指向CMyClass类型的成员函数，不能指向其他类或者普通函数
类成员函数指针不能直接调用，要通过一个类实例来调用，如下
- CMyClass *object = new CMyClass;
- ClassMethod method = CMyClass::func;
- (object->*method)(5);
那么如何封装呢？我们先来定义下接口吧
（为了简单起见，下面的实现都是以无参函数为例，后续会讲到如何支持任意参数）
- 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函数来进行相等判断。
下面是封装的普通函数指针
- 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）
好了，注意了，下面开始封装类成员函数指针
- 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来创建委托使用的函数
- 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++函数指针的封装就完成了，不难吧。
下面就是委托的实现了
- 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容器使用了。
这里要重点说明的一点是，大家仔细看 += 函数的实现中
- if ((*iter) && (*iter)->compare(_delegate))
- {
- delete _delegate;
- return *this;
- }
为什么要delete掉外部的指针呢？
因为C++的内存泄露一直是个麻烦事，所以MyUGI的委托里，所有的委托函数统一由Delegate本身管理
外部不要自己new或delete委托函数，也不要保存一个委托函数，Delegate本身会管理好的。
建议像如下使用：
- CMultiDelegate myDelegate;
- myDelegate += newDelegate(normalFunc);
- myDelegate -= newDelegate(normalFunc);
而不建议像如下使用：
- CMultiDelegate myDelegate;
- IDelegate* delegateFunc = newDelegate(normalFunc);
- myDelegate += delegateFunc;
- myDelegate -= delegateFunc;
上面2种方法都没错，都不会造成内存泄露
你可能会觉得第2种方法减少new的次数，比第一种方法更好。其实不然，因为第2种方法有个很大的隐患
- myDelegate -= delegateFunc;
所以如果你后面又想将delegateFunc添加到myDelegate里面时，你就不能再这样用了
- myDelegate += delegateFunc;
你得重新new一个
delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
相信你不会愿意这样做的，因为这种方法很容易造成内存泄露或者崩溃
现在你应该可以明白 -= 函数是怎么释放委托函数内存了吧。
1.实现任意参数的函数委托
按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？
注：最终的实现代码可以在这里下载：http://download.csdn.net/detail/gouki04/3641328
只能不同个数各实现一个类，如
-
- template<typename TP1>
- class CMultiDelegate1{};
-
- template<typename TP1, typename TP2>
- class CMultiDelegate2{};
注意类名是不一样的，分别为CMultiDelegate1和CMultiDelegate2
C++里面，类名相同但模板参数个数不同是会当成一个类对待的，所以那样编译不过的
这样是不是很麻烦呢？
不是很麻烦，是相当麻烦。因为不单单是CMultiDelegate要实现多个参数的版本
连IDelegate、CStaticDelegate和CMethodDelegate都要实现对应的多个参数的版本！
其实所有版本的内部实现几乎一样，下面给出双参函数的版本
- template<typename TP1, typename TP2>
- class IDelegate2
- {
- public:
- virtual ~IDelegate2() { }
- virtual bool isType( const std::type_info& _type) = 0;
- virtual void invoke( TP1 p1, TP2 p2 ) = 0;
- virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const = 0;
- };
- template<typename TP1, typename TP2>
- class CStaticDelegate2 : public IDelegate2<typename TP1, typename TP2>
- {
- public:
- typedef void (*Func)( TP1 p1, TP2 p2 );
- CStaticDelegate2 (Func _func) : mFunc(_func) { }
- virtual bool isType( const std::type_info& _type) { return typeid( CStaticDelegate2<typename TP1, typename TP2> ) == _type; }
- virtual void invoke( TP1 p1, TP2 p2 )
- {
- mFunc( p1, p2 );
- }
- virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const
- {
- if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate2 <typename TP1, typename TP2>)) ) return false;
- CStaticDelegate2 <typename TP1, typename TP2> * cast = static_cast<CStaticDelegate2 <typename TP1, typename TP2> *>(_delegate);
- return cast->mFunc == mFunc;
- }
- virtual bool compare(IDelegateUnlink * _unlink) const { return false; }
- private:
- Func mFunc;
- };
- template <typename T, typename TP1, typename TP2>
- class CMethodDelegate2 : public IDelegate2 <typename TP1, typename TP2>
- {
- public:
- typedef void (T::*Method)( TP1 p1, TP2 p2 );
- CMethodDelegate2(T * _object, Method _method) : mObject(_object), mMethod(_method) { }
- virtual bool isType( const std::type_info& _type) { return typeid( CMethodDelegate2 <T, TP1, TP2> ) == _type; }
- virtual void invoke( TP1 p1, TP2 p2 )
- {
- (mObject->*mMethod)( p1, p2 );
- }
- virtual bool compare( IDelegate2 <typename TP1, typename TP2> * _delegate) const
- {
- if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate2 <T, TP1, TP2>)) ) return false;
- CMethodDelegate2 <T, TP1, TP2> * cast = static_cast< CMethodDelegate2 <T, TP1, TP2> * >(_delegate);
- return cast->mObject == mObject && cast->mMethod == mMethod;
- }
- private:
- T * mObject;
- Method mMethod;
- };
- template <typename TP1, typename TP2>
- inline delegates::IDelegate2 <typename TP1, typename TP2> * newDelegate( void (*_func)( TP1 p1, TP2 p2 ) )
- {
- return new delegates::CStaticDelegate2 <typename TP1, typename TP2> (_func);
- }
- template <typename T, typename TP1, typename TP2>
- inline delegates::IDelegate2 <typename TP1, typename TP2> * newDelegate( T * _object, void (T::*_method)( TP1 p1, TP2 p2 ) )
- {
- return new delegates::CMethodDelegate2 <T, TP1, TP2> (_object, _method);
- }
- template <typename TP1, typename TP2>
- class CMultiDelegate2
- {
- public:
- typedef IDelegate2 <typename TP1, typename TP2> IDelegate;
- typedef typename std::list<IDelegate*> ListDelegate;
- typedef typename ListDelegate::iterator ListDelegateIterator;
- typedef typename ListDelegate::const_iterator ConstListDelegateIterator;
- CMultiDelegate2 () { }
- ~CMultiDelegate2 () { 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;
- }
- }
- }
- CMultiDelegate2 <typename TP1, typename TP2> & 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;
- }
- CMultiDelegate2 <typename TP1, typename TP2> & 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()( TP1 p1, TP2 p2 )
- {
- ListDelegateIterator iter = mListDelegates.begin();
- while (iter != mListDelegates.end())
- {
- if (0 == (*iter))
- {
- iter = mListDelegates.erase(iter);
- }
- else
- {
- (*iter)->invoke( p1, p2 );
- ++iter;
- }
- }
- }
- private:
- CMultiDelegate2 (const CMultiDelegate2 <typename TP1, typename TP2> & _event);
- CMultiDelegate2<typename TP1, typename TP2> & operator=(const CMultiDelegate2<typename TP1, typename TP2> & _event);
- private:
- ListDelegate mListDelegates;
- };
当然放心啦，不会让大家将不同参数的版本各写一遍的
下面要介绍的是MyGUI的解决方法，一个利用预编译和头文件重复编译的方法（很有意思的）
我们一般写头文件时，都会加上防止头文件重复编译的代码，如
- #ifndef __XXX_H__
- #define __XXX_H__
-
- #endif
这里我们就要反其道而行，去掉防止重复编译的代码，然后重复包含这个头文件，但每次其编译的都是不同参数个数的版本
第一次编译的是无参的，第二次是单参的，第三次是双参.....一直到你想要支持的参数个数
那怎么让其每次编译的都不同呢？
答案就是使用强大的预编译：宏
下面给出单参的IDelegate的例子
首先定义以下宏：
- #define DELEGATE_TEMPLATE template
- #define DELEGATE_TEMPLATE_PARAMS <typename TP1>
- #define DELEGATE_TEMPLATE_ARGS TP1 p1
- #define MYGUI_I_DELEGATE IDelegate1
那么下面这段代码就会编译出单参的IDelegate版本
- DELEGATE_TEMPLATE DELEGATE_TEMPLATE_PARAMS
- class MYGUI_I_DELEGATE
- {
- public:
- virtual ~MYGUI_I_DELEGATE() { }
- virtual bool isType( const std::type_info& _type) = 0;
- virtual void invoke( DELEGATE_PARAMS ) = 0;
- virtual bool compare( MYGUI_I_DELEGATE DELEGATE_TEMPLATE_ARGS * _delegate) const = 0;
- };
神奇吧，这里使用的可以说是宏实现的多态。
在这段代码编译完了之后，将所有宏都undefine掉，如
- #undef DELEGATE_TEMPLATE
- #undef DELEGATE_TEMPLATE_PARAMS
- #undef DELEGATE_TEMPLATE_ARGS
- #undef MYGUI_I_DELEGATE
再重新定义双参版本的，如
- #define DELEGATE_TEMPLATE template
- #define DELEGATE_TEMPLATE_PARAMS <typename TP1, typename TP2>
- #define DELEGATE_TEMPLATE_ARGS TP1 p1, TP2 p2
- #define MYGUI_I_DELEGATE IDelegate2
那么编译出来的就是双参的版本了！
使用这种方法就可以将其他的如CStaticDelegate、CMethodDelegate和CMultiDelegate的各种版本都实现了，
而你要做的仅是重新define下那些宏就行了，够方便了吧。
下一篇文章将会介绍MyGUI实现的一些辅助类，如单委托和DelegateUnlink。并给出一个测试例子，测试该委托机制对C++各种函数的支持。
1.引言
按上一篇文章的方法，你已经可以使用任意参数的函数委托了。这里介绍下MyGUI实现的两个辅助类，CDelegate类和IDelegateUnlink。如果你不为了深入了解MyGUI的委托实现，可以跳过此处。CDelegate即为单委托，实际效果跟函数指针差不多，于CMultiDelegate的区别在于其不支持多播。而IDelegateUnlink类主要是在CMultiDelegate中使用，在多播下一次性去掉自身的所有委托。
2.单委托
-
- class CDelegate
- {
- public:
- typedef CDelegate IDelegate;
-
-
- CDelegate () : mDelegate(0) { }
- CDelegate (const CDelegate& _event)
- {
-
- mDelegate = _event.mDelegate;
- const_cast<CDelegate&>(_event).mDelegate = 0;
- }
- ~CDelegate () { clear(); }
-
-
- bool empty() const { return mDelegate == 0; }
-
-
- void clear()
- {
- if (mDelegate)
- {
- delete mDelegate;
- mDelegate = 0;
- }
- }
-
-
- CDelegate & operator=(IDelegate* _delegate)
- {
- delete mDelegate;
- mDelegate = _delegate;
- return *this;
- }
-
-
- CDelegate & operator=(const CDelegate& _event)
- {
-
- delete mDelegate;
- mDelegate = _event.mDelegate;
- const_cast<CDelegate&>(_event).mDelegate = 0;
-
-
- return *this;
- }
-
-
- void operator()( )
- {
- if (mDelegate == 0) return;
- mDelegate->invoke( );
- }
-
-
- private:
- IDelegate * mDelegate;
- };
可以看到，单委托只实现了 = 运算符，没有实现 += 运算符。
而且在赋值时会将原委托去掉，确保只有一份委托。
其实单委托跟普通函数指针差不多，在使用单委托的地方可以换成使用普通函数指针。
3.断开委托
-
- class IDelegateUnlink
- {
- public:
- virtual ~IDelegateUnlink() { }
-
-
- IDelegateUnlink() { m_baseDelegateUnlink = this; }
- bool compare(IDelegateUnlink * _unlink) const { return m_baseDelegateUnlink == _unlink->m_baseDelegateUnlink; }
-
-
- private:
- IDelegateUnlink * m_baseDelegateUnlink;
- };
所谓断开委托，只能用在多重委托，即CMultiDelegate中，可以断开自身与其相连的所有委托。
使用方法就在将自身的类从IDelegateUnlink派生，然后使用CMultiDelegate中的clear函数即可断开委托。
在下面会有例子说明。
4.测试
-
-
-
- #include "delegate.h"
- #include <iostream>
-
-
- using namespace std;
-
-
-
- void func(int a, int b)
- {
- cout << "func(" << a << ", " << b << ")" << endl;
- }
-
-
-
- void func2(int a, int b)
- {
- cout << "func2(" << a << ", " << b << ")" << endl;
- }
-
-
-
- class NormalClass
- {
- public:
-
- void normalFunc(int a, int b)
- {
- cout << "NormalClass::normalFunc(" << a << ", " << b << ")" << endl;
- }
- };
-
-
| 
客服电话
APP下载
官方微信
请发表评论