Chinaunix首页 | 论坛 | 博客

happyblog的ChinaUnix博客happyblog.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

happyblog

  • 博客访问： 100453
  • 博文数量： 32
  • 博客积分： 913
  • 博客等级： 准尉
  • 技术积分： 425
  • 用 户 组： 普通用户
  • 注册时间： 2011-08-31 18:07
文章分类

全部博文（32）

文章存档

2012年（18）

2011年（14）

我的朋友
最近访客
推荐博文
相关博文
C++实现的委托机制（二）

分类： C/C++

2011-10-05 18:47:15

C++实现的委托机制（二）

 

作者：gouki04(啊古)  撰写日期：2011-09-27

博客链接：http://blog.csdn.net/gouki04

 

1.实现任意参数的函数委托

按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？

注：最终的实现代码可以在这里下载：

只能不同个数各实现一个类，如：

点击(此处)折叠或打开

  1. // 单参函数委托
  2. template<typename TP1>
  3. class CMultiDelegate1{};

  5. // 双参函数委托
  6. template<typename TP1, typename TP2>
  7. 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. };

  11. template<typename TP1, typename TP2>
  12. class CStaticDelegate2 : public IDelegate2<typename TP1, typename TP2>
  13. {
  14. public:
  15.     typedef void (*Func)( TP1 p1, TP2 p2 );

  17.     CStaticDelegate2 (Func _func) : mFunc(_func) { }

  19.     virtual bool isType( const std::type_info& _type) { return typeid( CStaticDelegate2<typename TP1, typename TP2> ) == _type; }

  21.     virtual void invoke( TP1 p1, TP2 p2 )
  22.     {
  23.         mFunc( p1, p2 );
  24.     }

  26.     virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const
  27.     {
  28.         if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate2 <typename TP1, typename TP2>)) ) return false;
  29.         CStaticDelegate2 <typename TP1, typename TP2> * cast = static_cast<CStaticDelegate2 <typename TP1, typename TP2> *>(_delegate);
  30.         return cast->mFunc == mFunc;
  31.     }
  32.     virtual bool compare(IDelegateUnlink * _unlink) const { return false; }

  34. private:
  35.     Func mFunc;
  36. };

  38. template <typename T, typename TP1, typename TP2>
  39. class CMethodDelegate2 : public IDelegate2 <typename TP1, typename TP2>
  40. {
  41. public:
  42.     typedef void (T::*Method)( TP1 p1, TP2 p2 );

  44.     CMethodDelegate2(T * _object, Method _method) : mObject(_object), mMethod(_method) { }

  46.     virtual bool isType( const std::type_info& _type) { return typeid( CMethodDelegate2 <T, TP1, TP2> ) == _type; }

  48.     virtual void invoke( TP1 p1, TP2 p2 )
  49.     {
  50.         (mObject->*mMethod)( p1, p2 );
  51.     }

  53.     virtual bool compare( IDelegate2 <typename TP1, typename TP2> * _delegate) const
  54.     {
  55.         if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate2 <T, TP1, TP2>)) ) return false;
  56.         CMethodDelegate2 <T, TP1, TP2> * cast = static_cast< CMethodDelegate2 <T, TP1, TP2> * >(_delegate);
  57.         return cast->mObject == mObject && cast->mMethod == mMethod;
  58.     }

  60. private:
  61.     T * mObject;
  62.     Method mMethod;
  63. };

  65. template <typename TP1, typename TP2>
  66. inline delegates::IDelegate2 <typename TP1, typename TP2> * newDelegate( void (*_func)( TP1 p1, TP2 p2 ) )
  67. {
  68.     return new delegates::CStaticDelegate2 <typename TP1, typename TP2> (_func);
  69. }

  71. template <typename T, typename TP1, typename TP2>
  72. inline delegates::IDelegate2 <typename TP1, typename TP2> * newDelegate( T * _object, void (T::*_method)( TP1 p1, TP2 p2 ) )
  73. {
  74.     return new delegates::CMethodDelegate2 <T, TP1, TP2> (_object, _method);
  75. }

  77. template <typename TP1, typename TP2>
  78. class CMultiDelegate2
  79. {
  80. public:
  81.     typedef IDelegate2 <typename TP1, typename TP2> IDelegate;
  82.     typedef typename std::list<IDelegate*> ListDelegate;
  83.     typedef typename ListDelegate::iterator ListDelegateIterator;
  84.     typedef typename ListDelegate::const_iterator ConstListDelegateIterator;

  86.     CMultiDelegate2 () { }
  87.     ~CMultiDelegate2 () { clear(); }

  89.     bool empty() const
  90.     {
  91.         for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  92.         {
  93.             if (*iter) return false;
  94.         }
  95.         return true;
  96.     }

  98.     void clear()
  99.     {
  100.         for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  101.         {
  102.             if (*iter)
  103.             {
  104.                 delete (*iter);
  105.                 (*iter) = 0;
  106.             }
  107.         }
  108.     }

  110.     CMultiDelegate2 <typename TP1, typename TP2> & operator+=(IDelegate* _delegate)
  111.     {
  112.         for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  113.         {
  114.             if ((*iter) && (*iter)->compare(_delegate))
  115.             {
  116.                 delete _delegate;
  117.                 return *this;
  118.                 //MYGUI_ASSERT(false, "dublicate delegate");
  119.             }
  120.         }
  121.         mListDelegates.push_back(_delegate);
  122.         return *this;
  123.     }

  125.     CMultiDelegate2 <typename TP1, typename TP2> & operator-=(IDelegate* _delegate)
  126.     {
  127.         for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
  128.         {
  129.             if ((*iter) && (*iter)->compare(_delegate))
  130.             {
  131.                 if ((*iter) != _delegate) delete (*iter);
  132.                 (*iter) = 0;
  133.                 break;
  134.             }
  135.         }
  136.         delete _delegate;
  137.         return *this;
  138.     }

  140.     void operator()( TP1 p1, TP2 p2 )
  141.     {
  142.         ListDelegateIterator iter = mListDelegates.begin();
  143.         while (iter != mListDelegates.end())
  144.         {
  145.             if (0 == (*iter))
  146.             {
  147.                 iter = mListDelegates.erase(iter);
  148.             }
  149.             else
  150.             {
  151.                 (*iter)->invoke( p1, p2 );
  152.                 ++iter;
  153.             }
  154.         }
  155.     }

  157. private:
  158.     CMultiDelegate2 (const CMultiDelegate2 <typename TP1, typename TP2> & _event);
  159.     CMultiDelegate2<typename TP1, typename TP2> & operator=(const CMultiDelegate2<typename TP1, typename TP2> & _event);

  161. private:
  162.     ListDelegate mListDelegates;
  163. };

    当然放心啦，不会让大家将不同参数的版本各写一遍的。下面要介绍的是MyGUI的解决方法，一个利用预编译和头文件重复编译的方法（很有意思的）。我们一般写头文件时，都会加上防止头文件重复编译的代码，如：

点击(此处)折叠或打开

  1. #ifndef __XXX_H__
  2. #define __XXX_H__

  4. // ..类声明等

  6. #endif

    这里我们就要反其道而行，去掉防止重复编译的代码，然后重复包含这个头文件，但每次其编译的都是不同参数个数的版本。第一次编译的是无参的，第二次是单参的，第三次是双参.....一直到你想要支持的参数个数。那怎么让其每次编译的都不同呢？答案就是使用强大的预编译：宏！下面给出单参的IDelegate的例子：

点击(此处)折叠或打开

  1. //首先定义以下宏
  2. #define DELEGATE_TEMPLATE template
  3. #define DELEGATE_TEMPLATE_PARAMS <typename TP1>
  4. #define DELEGATE_TEMPLATE_ARGS TP1 p1
  5. #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
  5. //再重新定义双参版本的，如
  6. #define DELEGATE_TEMPLATE template
  7. #define DELEGATE_TEMPLATE_PARAMS <typename TP1, typename TP2>
  8. #define DELEGATE_TEMPLATE_ARGS TP1 p1, TP2 p2
  9. #define MYGUI_I_DELEGATE IDelegate2

    那么编译出来的就是双参的版本了！使用这种方法就可以将其他的如CStaticDelegate、CMethodDelegate和CMultiDelegate的各种版本都实现了，而你要做的仅是重新define下那些宏就行了，够方便了吧。

       下一篇文章将会介绍MyGUI实现的一些辅助类，如单委托和DelegateUnlink。并给出一个测试例子，测试该委托机制对C++各种函数的支持。

阅读(755) | 评论(0) | 转发(0) |
0

上一篇：C++实现的委托机制（一）

下一篇：HashMap源码分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6