用C++模拟C#事件机制之改进篇

我前面写过的一篇 C++模拟C#事件机制 中给出了一个C++ event完整实现, 但是存在好多问题，主要是：由于使用静态变量存储函数类别导致不能保存多个相同函数特征（参数列表和返回值）的函数。这个重构版本充分利用了面向对象的思想，利用派生和多态封装了全局函数，成员函数，函数对象，使３者借口完全一致．

 

 

1. template<class TReturn, class TArgument>
2. class BaseInvoker
3. {
4. public:
5.  BaseInvoker(){}
6.  virtual ~BaseInvoker(){}
7. public:
8.  virtual TReturn invoke(TArgument args) = 0;
9. };
11. template<class TReturn, class TArgument>
12. class GlobalInvoker : public BaseInvoker<TReturn, TArgument>
13. {
14. public:
15.  typedef TReturn (*Method)(TArgument args);
16. public:
17.  GlobalInvoker(Method pCallback)
18.  :mCallback(pCallback)
19.  {
21.  }
23.  virtual TReturn invoke(TArgument args)
24.  {
25.   return mCallback(args);
26.  }
28. private:
29.  Method mCallback;
30. };
32. template<class TObject, class TReturn, class TArgument>
33. class MemberInvoker : public BaseInvoker<TReturn, TArgument>
34. {
35. public:
36.  typedef TReturn (TObject::*MemberMethod)(TArgument);
37. public:
38.  MemberInvoker(TObject* pObject,MemberMethod pCallback)
39.  :mObject(pObject), mCallback(pCallback)
40.  {
42.  }
44.  virtual TReturn invoke(TArgument args)
45.  {
46.   return (mObject->*mCallback)(args);
47.  }
49. private:
50.  TObject*  mObject;
51.  MemberMethod mCallback;
52. };
54. template<class TFunctor, class TReturn, class TArgument>
55. class FunctorInvoker : public BaseInvoker<TReturn, TArgument>
56. {
57. public:
58.  typedef TFunctor* FunctorMethod;
59. public:
60.  FunctorInvoker(FunctorMethod pCallback)
61.  :mCallback(pCallback)
62.  {
64.  }
66.  virtual TReturn invoke(TArgument args)
67.  {
68.   return mCallback(args);
69.  }
71. private:
72.  FunctorMethod mCallback;
73. };

delegate使用智能指针shared_ptr存储实际的函数类型（智能指针可以自己实现，也可以用boost::shared_ptr, std::tr1::shread_ptr,我这里使用的是OGRE自带的一个只能指针，其实自己写也不难），以确保安全性，相应的，delagate构造函数也要改一下：

 

 

1. template<class TReturn, class TArgument>
2. class Delegate  
3. {
4. public:
5.  virtual ~Delegate()
6.  {
7.  }
8. public:
9.  template<class TReturn, class TArgument>
10.  friend bool operator==(Delegate<TReturn, TArgument> const& lhs, Delegate<TReturn, TArgument> const& rhs);
12.  // for global or static methods
13.  Delegate(TReturn (*pCallback)(TArgument))
14.  :mInvoker(new GlobalInvoker<TReturn, TArgument>(pCallback))
15.  {
17.  } 
19.  // for object member methods
20.  template<class TObject>
21.  Delegate(TObject* pObject, TReturn (TObject::*pCallback)(TArgument))
22.  :mInvoker(new MemberInvoker<TObject,TReturn,TArgument>(pObject,pCallback))
23.  {
24.   
25.  }
27.  // for functor methods
28.  template<class TFunctor>
29.  Delegate(TFunctor* pCallback)
30.  :mInvoker(new FunctorInvoker<TFunctor,TReturn,TArgument>(pCallback))
31.  {
32.  }
35.  TReturn operator() (TArgument args)
36.  {
37.   return mInvoker->invoke(args);
38.  }
40.  //implementations
42. private:
43.  Ogre::SharedPtr<BaseInvoker<TReturn, TArgument> > mInvoker;
44. // unsigned int mReference;
45. };

delegate对外接口没有改变因此event及使用event的代码 无需改变，这也充分说明了抽象的好处：实现不论怎么变化，但接口不便。