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

Myth丶恋晨 2022-08-24 05:14 206阅读 0赞

我前面写过的一篇 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.  \};
10. 
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. \{
20. 
21. \}
22. 
23. virtual TReturn invoke(TArgument args)
24. \{
25. return mCallback(args);
26. \}
27. 
28. private:
29. Method mCallback;
30. \};
31. 
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. \{
41. 
42. \}
43. 
44. virtual TReturn invoke(TArgument args)
45. \{
46. return (mObject->\*mCallback)(args);
47. \}
48. 
49. private:
50. TObject\* mObject;
51. MemberMethod mCallback;
52. \};
53. 
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. \{
63. 
64. \}
65. 
66. virtual TReturn invoke(TArgument args)
67. \{
68. return mCallback(args);
69. \}
70. 
71. private:
72. FunctorMethod mCallback;
73. \};
74.

**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);
11. 
12. // for global or static methods 
13. Delegate(TReturn (\*pCallback)(TArgument))
14. :mInvoker(new GlobalInvoker<TReturn, TArgument>(pCallback))
15. \{
16. 
17. \}
18. 
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. \}
26. 
27. // for functor methods 
28. template<class TFunctor>
29. Delegate(TFunctor\* pCallback)
30. :mInvoker(new FunctorInvoker<TFunctor,TReturn,TArgument>(pCallback))
31. \{
32. \}
33. 
34. 
35. TReturn operator() (TArgument args)
36. \{
37. return mInvoker->invoke(args);
38. \}
39. 
40. //implementations 
41. 
42. private:
43. Ogre::SharedPtr<BaseInvoker<TReturn, TArgument> > mInvoker;
44. // unsigned int mReference; 
45. \};
46.

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