C++实现的委托机制
2017-04-24 18:32
495 查看
1.引言
下面的委托实现使用的MyGUI里面的委托实现,MyGUI是一款强大的GUI库,想理解更多的MyGUI信息,猛击这里http://mygui.info/
最终的代码可以在这里下载:http://download.csdn.net/detail/gouki04/3641328 我们的目标是要实现一个跟.NET几乎完全一样的委托,使用简单,支持多播,可以添加删除委托。同时支持C++的普通函数、模板函数、类成员函数,类的静态成员函数,并且支持多态。使用方式如下:
view plain
// 普通函数
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++中,普通函数指针和类成员函数指针是完全不一样的。如下例子
view plain
class CMyClass
{
public:
void func(int);
};
// 定义一个指向CMyClass类型,参数列表为(int),返回值为void的函数指针
typedef void (CMyClass::*ClassMethod) (int); // 注意定义时使用了特殊的运算符::*
那么此函数指针只能指向CMyClass类型的成员函数,不能指向其他类或者普通函数
类成员函数指针不能直接调用,要通过一个类实例来调用,如下
view plain
CMyClass *object = new CMyClass;
ClassMethod method = CMyClass::func;
(object->*method)(5); // 注意调用时使用了特殊运算符->*
那么如何封装呢?我们先来定义下接口吧
(为了简单起见,下面的实现都是以无参函数为例,后续会讲到如何支持任意参数)
view plain
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函数来进行相等判断。
下面是封装的普通函数指针
view plain
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)
好了,注意了,下面开始封装类成员函数指针
view plain
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来创建委托使用的函数
view plain
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++函数指针的封装就完成了,不难吧。
下面就是委托的实现了
view plain
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容器使用了。
这里要重点说明的一点是,大家仔细看 += 函数的实现中
view plain
if ((*iter) && (*iter)->compare(_delegate))
{
delete _delegate; // 如果该委托函数已经被添加了,则delete掉外部的_delegate
return *this;
}
为什么要delete掉外部的指针呢?
因为C++的内存泄露一直是个麻烦事,所以MyUGI的委托里,所有的委托函数统一由Delegate本身管理
外部不要自己new或delete委托函数,也不要保存一个委托函数,Delegate本身会管理好的。
建议像如下使用:
view plain
CMultiDelegate myDelegate;
myDelegate += newDelegate(normalFunc);
myDelegate -= newDelegate(normalFunc);
而不建议像如下使用:
view plain
CMultiDelegate myDelegate;
IDelegate* delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
myDelegate -= delegateFunc;
上面2种方法都没错,都不会造成内存泄露
你可能会觉得第2种方法减少new的次数,比第一种方法更好。其实不然,因为第2种方法有个很大的隐患
view plain
myDelegate -= delegateFunc; // 在这一步,delegateFunc所指向的空间已经被释放掉了(在-=函数里面)
所以如果你后面又想将delegateFunc添加到myDelegate里面时,你就不能再这样用了
view plain
myDelegate += delegateFunc; // 错误,因为delegateFunc的空间已经被释放了
你得重新new一个
delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
相信你不会愿意这样做的,因为这种方法很容易造成内存泄露或者崩溃
现在你应该可以明白 -= 函数是怎么释放委托函数内存了吧。
1.实现任意参数的函数委托
按上一篇文章的方法,你已经可以使用无参数的函数委托了。当然,这远远不够。要实现任意参数的函数委托,这里的任意参数包括任意个数和任意类型。任意类型这个容易解决,使用模板就行,但任意参数个数呢?
注:最终的实现代码可以在这里下载:http://download.csdn.net/detail/gouki04/3641328
只能不同个数各实现一个类,如
view plain
// 单参函数委托
template<typename TP1>
class CMultiDelegate1{};
// 双参函数委托
template<typename TP1, typename TP2>
class CMultiDelegate2{};
注意类名是不一样的,分别为CMultiDelegate1和CMultiDelegate2
C++里面,类名相同但模板参数个数不同是会当成一个类对待的,所以那样编译不过的
这样是不是很麻烦呢?
不是很麻烦,是相当麻烦。因为不单单是CMultiDelegate要实现多个参数的版本
连IDelegate、CStaticDelegate和CMethodDelegate都要实现对应的多个参数的版本!
其实所有版本的内部实现几乎一样,下面给出双参函数的版本
view plain
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;
//MYGUI_ASSERT(false, "dublicate delegate");
}
}
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的解决方法,一个利用预编译和头文件重复编译的方法(很有意思的)
我们一般写头文件时,都会加上防止头文件重复编译的代码,如
view plain
#ifndef __XXX_H__
#define __XXX_H__
// ..类声明等
#endif
这里我们就要反其道而行,去掉防止重复编译的代码,然后重复包含这个头文件,但每次其编译的都是不同参数个数的版本
第一次编译的是无参的,第二次是单参的,第三次是双参.....一直到你想要支持的参数个数
那怎么让其每次编译的都不同呢?
答案就是使用强大的预编译:宏
下面给出单参的IDelegate的例子
首先定义以下宏:
view plain
#define DELEGATE_TEMPLATE template
#define DELEGATE_TEMPLATE_PARAMS <typename TP1>
#define DELEGATE_TEMPLATE_ARGS TP1 p1
#define MYGUI_I_DELEGATE IDelegate1
那么下面这段代码就会编译出单参的IDelegate版本
view plain
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掉,如
view plain
#undef DELEGATE_TEMPLATE
#undef DELEGATE_TEMPLATE_PARAMS
#undef DELEGATE_TEMPLATE_ARGS
#undef MYGUI_I_DELEGATE
再重新定义双参版本的,如
view plain
#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.单委托
view plain
// 无参的单委托实现
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.断开委托
view plain
// 断开委托的基类
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.测试
view plain
/* 测试Delegate对不同函数的支持
* 可以参考下不同函数的使用方式
*/
#include "delegate.h"
#include <iostream>
using namespace std;
// 普通函数1
void func(int a, int b)
{
cout << "func(" << a << ", " << b << ")" << endl;
}
// 普通函数2
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;
}
};
// 实现了IDelegateUnlink的类
class BaseUnlinkClass : public delegates::IDelegateUnlink
{
public:
// 类的虚函数
virtual void virFunc(int a, int b)
{
cout << "BaseUnlinkClass::virFunc(" << a << ", " << b << ")" << endl;
}
// 类的普通成员函数
void normalFunc(int a, int b)
{
cout << "BaseUnlinkClass::normalFunc(" << a << ", " << b << ")" << endl;
}
};
class DerivedClass : public BaseUnlinkClass
{
public:
// 类的虚函数
virtual void virFunc(int a, int b)
{
cout << "DerivedClass::virFunc(" << a << ", " << b << ")" << endl;
}
// 类的静态成员函数
static void staticFunc(int a, int b)
{
cout << "DerivedClass::staticFunc(" << a << ", " << b << ")" << endl;
}
};
// 模板函数
template<class T>
void TFunc(T a, T b)
{
cout << "TFunc(" << a << ", " << b << ")" << endl;
}
int main()
{
BaseUnlinkClass *baseUnlinkClass = new BaseUnlinkClass;
DerivedClass *derivedClass = new DerivedClass;
NormalClass *normalClass = new NormalClass;
// 定义委托
typedef delegates::CMultiDelegate2<int, int> EvenetHandler;
EvenetHandler event;
// 添加普通函数
event += newDelegate(func);
event += newDelegate(func2);
// 添加类的普通成员函数
event += newDelegate(normalClass, &NormalClass::normalFunc);
event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::normalFunc);
// 添加类的虚函数
event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::virFunc);
event += newDelegate(derivedClass, &DerivedClass::virFunc);
// 注意在多态下,使用基类指针时,函数指针要用基类的函数指针,不能用派生类的
// 但是在调用时会响应多态,也就是会调用派生类的虚函数
event += newDelegate((BaseUnlinkClass*)derivedClass, &BaseUnlinkClass::virFunc);
// 添加类的静态成员函数
event += newDelegate(&DerivedClass::staticFunc);
// 添加模板函数
event += newDelegate(TFunc<int>);
// 触发事件
event(1, 2);
cout << endl;
// 去掉函数
event -= newDelegate(func);
// 去掉baseUnlinkClass所有的函数
event.clear(baseUnlinkClass);
// 去掉derivedClass所有的函数
// 注意静态成员函数staticFunc不会去掉
event.clear(derivedClass);
//event.clear(normalClass);
// 错误调用,normalClass不是IDelegateUnlink的派生类
// 不能使用clear去掉自身的函数
// 应该使用如下方法
event -= newDelegate(normalClass, &NormalClass::normalFunc);
// 触发事件
event(2, 3);
cout << endl;
return 0;
}
下面的委托实现使用的MyGUI里面的委托实现,MyGUI是一款强大的GUI库,想理解更多的MyGUI信息,猛击这里http://mygui.info/
最终的代码可以在这里下载:http://download.csdn.net/detail/gouki04/3641328 我们的目标是要实现一个跟.NET几乎完全一样的委托,使用简单,支持多播,可以添加删除委托。同时支持C++的普通函数、模板函数、类成员函数,类的静态成员函数,并且支持多态。使用方式如下:
view plain
// 普通函数
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++中,普通函数指针和类成员函数指针是完全不一样的。如下例子
view plain
class CMyClass
{
public:
void func(int);
};
// 定义一个指向CMyClass类型,参数列表为(int),返回值为void的函数指针
typedef void (CMyClass::*ClassMethod) (int); // 注意定义时使用了特殊的运算符::*
那么此函数指针只能指向CMyClass类型的成员函数,不能指向其他类或者普通函数
类成员函数指针不能直接调用,要通过一个类实例来调用,如下
view plain
CMyClass *object = new CMyClass;
ClassMethod method = CMyClass::func;
(object->*method)(5); // 注意调用时使用了特殊运算符->*
那么如何封装呢?我们先来定义下接口吧
(为了简单起见,下面的实现都是以无参函数为例,后续会讲到如何支持任意参数)
view plain
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函数来进行相等判断。
下面是封装的普通函数指针
view plain
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)
好了,注意了,下面开始封装类成员函数指针
view plain
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来创建委托使用的函数
view plain
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++函数指针的封装就完成了,不难吧。
下面就是委托的实现了
view plain
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容器使用了。
这里要重点说明的一点是,大家仔细看 += 函数的实现中
view plain
if ((*iter) && (*iter)->compare(_delegate))
{
delete _delegate; // 如果该委托函数已经被添加了,则delete掉外部的_delegate
return *this;
}
为什么要delete掉外部的指针呢?
因为C++的内存泄露一直是个麻烦事,所以MyUGI的委托里,所有的委托函数统一由Delegate本身管理
外部不要自己new或delete委托函数,也不要保存一个委托函数,Delegate本身会管理好的。
建议像如下使用:
view plain
CMultiDelegate myDelegate;
myDelegate += newDelegate(normalFunc);
myDelegate -= newDelegate(normalFunc);
而不建议像如下使用:
view plain
CMultiDelegate myDelegate;
IDelegate* delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
myDelegate -= delegateFunc;
上面2种方法都没错,都不会造成内存泄露
你可能会觉得第2种方法减少new的次数,比第一种方法更好。其实不然,因为第2种方法有个很大的隐患
view plain
myDelegate -= delegateFunc; // 在这一步,delegateFunc所指向的空间已经被释放掉了(在-=函数里面)
所以如果你后面又想将delegateFunc添加到myDelegate里面时,你就不能再这样用了
view plain
myDelegate += delegateFunc; // 错误,因为delegateFunc的空间已经被释放了
你得重新new一个
delegateFunc = newDelegate(normalFunc);
myDelegate += delegateFunc;
相信你不会愿意这样做的,因为这种方法很容易造成内存泄露或者崩溃
现在你应该可以明白 -= 函数是怎么释放委托函数内存了吧。
1.实现任意参数的函数委托
按上一篇文章的方法,你已经可以使用无参数的函数委托了。当然,这远远不够。要实现任意参数的函数委托,这里的任意参数包括任意个数和任意类型。任意类型这个容易解决,使用模板就行,但任意参数个数呢?
注:最终的实现代码可以在这里下载:http://download.csdn.net/detail/gouki04/3641328
只能不同个数各实现一个类,如
view plain
// 单参函数委托
template<typename TP1>
class CMultiDelegate1{};
// 双参函数委托
template<typename TP1, typename TP2>
class CMultiDelegate2{};
注意类名是不一样的,分别为CMultiDelegate1和CMultiDelegate2
C++里面,类名相同但模板参数个数不同是会当成一个类对待的,所以那样编译不过的
这样是不是很麻烦呢?
不是很麻烦,是相当麻烦。因为不单单是CMultiDelegate要实现多个参数的版本
连IDelegate、CStaticDelegate和CMethodDelegate都要实现对应的多个参数的版本!
其实所有版本的内部实现几乎一样,下面给出双参函数的版本
view plain
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;
//MYGUI_ASSERT(false, "dublicate delegate");
}
}
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的解决方法,一个利用预编译和头文件重复编译的方法(很有意思的)
我们一般写头文件时,都会加上防止头文件重复编译的代码,如
view plain
#ifndef __XXX_H__
#define __XXX_H__
// ..类声明等
#endif
这里我们就要反其道而行,去掉防止重复编译的代码,然后重复包含这个头文件,但每次其编译的都是不同参数个数的版本
第一次编译的是无参的,第二次是单参的,第三次是双参.....一直到你想要支持的参数个数
那怎么让其每次编译的都不同呢?
答案就是使用强大的预编译:宏
下面给出单参的IDelegate的例子
首先定义以下宏:
view plain
#define DELEGATE_TEMPLATE template
#define DELEGATE_TEMPLATE_PARAMS <typename TP1>
#define DELEGATE_TEMPLATE_ARGS TP1 p1
#define MYGUI_I_DELEGATE IDelegate1
那么下面这段代码就会编译出单参的IDelegate版本
view plain
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掉,如
view plain
#undef DELEGATE_TEMPLATE
#undef DELEGATE_TEMPLATE_PARAMS
#undef DELEGATE_TEMPLATE_ARGS
#undef MYGUI_I_DELEGATE
再重新定义双参版本的,如
view plain
#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.单委托
view plain
// 无参的单委托实现
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.断开委托
view plain
// 断开委托的基类
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.测试
view plain
/* 测试Delegate对不同函数的支持
* 可以参考下不同函数的使用方式
*/
#include "delegate.h"
#include <iostream>
using namespace std;
// 普通函数1
void func(int a, int b)
{
cout << "func(" << a << ", " << b << ")" << endl;
}
// 普通函数2
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;
}
};
// 实现了IDelegateUnlink的类
class BaseUnlinkClass : public delegates::IDelegateUnlink
{
public:
// 类的虚函数
virtual void virFunc(int a, int b)
{
cout << "BaseUnlinkClass::virFunc(" << a << ", " << b << ")" << endl;
}
// 类的普通成员函数
void normalFunc(int a, int b)
{
cout << "BaseUnlinkClass::normalFunc(" << a << ", " << b << ")" << endl;
}
};
class DerivedClass : public BaseUnlinkClass
{
public:
// 类的虚函数
virtual void virFunc(int a, int b)
{
cout << "DerivedClass::virFunc(" << a << ", " << b << ")" << endl;
}
// 类的静态成员函数
static void staticFunc(int a, int b)
{
cout << "DerivedClass::staticFunc(" << a << ", " << b << ")" << endl;
}
};
// 模板函数
template<class T>
void TFunc(T a, T b)
{
cout << "TFunc(" << a << ", " << b << ")" << endl;
}
int main()
{
BaseUnlinkClass *baseUnlinkClass = new BaseUnlinkClass;
DerivedClass *derivedClass = new DerivedClass;
NormalClass *normalClass = new NormalClass;
// 定义委托
typedef delegates::CMultiDelegate2<int, int> EvenetHandler;
EvenetHandler event;
// 添加普通函数
event += newDelegate(func);
event += newDelegate(func2);
// 添加类的普通成员函数
event += newDelegate(normalClass, &NormalClass::normalFunc);
event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::normalFunc);
// 添加类的虚函数
event += newDelegate(baseUnlinkClass, &BaseUnlinkClass::virFunc);
event += newDelegate(derivedClass, &DerivedClass::virFunc);
// 注意在多态下,使用基类指针时,函数指针要用基类的函数指针,不能用派生类的
// 但是在调用时会响应多态,也就是会调用派生类的虚函数
event += newDelegate((BaseUnlinkClass*)derivedClass, &BaseUnlinkClass::virFunc);
// 添加类的静态成员函数
event += newDelegate(&DerivedClass::staticFunc);
// 添加模板函数
event += newDelegate(TFunc<int>);
// 触发事件
event(1, 2);
cout << endl;
// 去掉函数
event -= newDelegate(func);
// 去掉baseUnlinkClass所有的函数
event.clear(baseUnlinkClass);
// 去掉derivedClass所有的函数
// 注意静态成员函数staticFunc不会去掉
event.clear(derivedClass);
//event.clear(normalClass);
// 错误调用,normalClass不是IDelegateUnlink的派生类
// 不能使用clear去掉自身的函数
// 应该使用如下方法
event -= newDelegate(normalClass, &NormalClass::normalFunc);
// 触发事件
event(2, 3);
cout << endl;
return 0;
}
相关文章推荐
- C++实现的委托机制(一)
- C++实现的委托机制(3)
- C++实现委托机制(二)
- C++实现委托机制(三)——lambda表达式封装
- C++实现的委托机制(二)
- C++实现委托机制(一)
- C++实现委托机制之完整代码实现(一)
- C++实现委托机制(三)——lambda表达式封装
- 杂货边角(9):C++实现事件委托机制
- C++实现的委托机制(1)
- 实现C++中的事件委托机制
- C++实现的委托机制
- 转载 C++实现的委托机制
- C#的委托机制的C++的一种实现DIY版
- C++实现的委托机制(2)
- C++ 0x 使用可变参数模板类 实现 C# 的委托机制
- 实现C++中的事件委托机制
- C++实现委托机制(一)
- C++实现委托机制(二)
- C++实现事件委托机制