在C++中实现C#的delegate机制

由于这段时间较忙，自从上次我发布了一个供初学者学习的“MFC”程序后，就没怎么写文章了。这段时间在忙新的项目，项目逻辑还算复杂，用了好多有闪光点的技术，下面我要讨论的是闪光点之一：在C++中实现C#的delegate机制。

用过C#的朋友都觉得C#的确是个好语言，但有时由于特殊需要，不得不用C++，在C++中要想实现C#中的Thread等也是可行的，不过代码要稍复杂。

以例子来说明：

01. class   Sdk

02. {

03. public:

04. void   DoSomething();  

05. };

06.  

07. class   client

08. {

09. public:

10. Sdk   m_sdk;

11. void   DoSomething{}

12. {

13. m_sdk.DoSomething();

14. }

15.  

16. void   OnMessage()

17. {

18. //

19. }

20. }

这个例子比较简单，Sdk用来实现某个功能，client是客户程序，要想在m_sdk做处理的时候能发送通知到client，有几个方法可以实现， 其一是发线程消息，其一是回调，但传统的回调对面向对象的支持并不好，这就是实现delegate的出发点。 下面是一个实现：

01. class   Delegate

02. {

03. public:

04. virtual   ~Delegate(void){   }

05. virtual   void   operator()(void)   =   0;

06. };

07. template < typename   C >

08. class   DelegateImpl   :   public   Delegate

09. {

10. private:

11. typedef   void   (C::*F)(void);

12. C*   m_class;

13. F   m_fun;

14. public:

15. DelegateImpl(C*   c,   F   f){   m_class   =   c;   m_fun   =   f;   }

16. virtual   void   operator()(void)

17. {

18. if(m_class)

19. return   (m_class-> *m_fun)();

20. }

21. };

有了上面代码，再稍加修改sdk和client代码就能实现事件通知了：

01. class   Sdk

02. {

03. public:

04. Delegate*   pEvent;

05. sdk():   pEvent(NULL)   {   }

06. void   DoSomething()

07. {

08. cout < < "opened"  < < endl;

09. if(pEvent   !=   NULL)

10. (*pEvent)(   );

11. }

12. };

13.  

14. class   client

15. {

16. private:

17. Sdk   m_sdk;

18.  

19. public:

20. client()

21. {

22. m_sdk.pEvent   =   new   Delegate < client > (this,   OnOpen);

23. }

24. void   DoSomething()

25. {

26. m_sdk.DoSomething();

27. }

28.  

29. void   OnDoSomething()

30. {

31. cout < <  "event   fired"  > >endl;

32. }

33. }

上面的实现有不少局限性，事件处理方法的返回值和参数设置不是十分灵活，因此可以用宏定义优代以上代码， 下面给出我的全部代码，请朋友指正。

view source

print ?

001. /

002. //delegate 0

003. #define DEFINE_DELEGATE(NAME, R)\

004. class NAME##Delegate\

005. {\

006. public:\

007. virtual ~NAME##Delegate(void){ }\

008. virtual R operator()(void) = 0;\

009. };\

010. template < typename C>\

011. class NAME##DelegateImpl : public NAME##Delegate\

012. {\

013. private:\

014. typedef R (C::*F)(void);\

015. C* m_class;\

016. F m_fun;\

017. public:\

018. NAME##DelegateImpl(C* c, F f){ m_class = c; m_fun = f; }\

019. virtual R operator()(void)\

020. {\

021. if(m_class)\

022. return (m_class->*m_fun)();\

023. }\

024. };\

025. template< typename C, typename F>\

026. NAME##Delegate* Make##NAME##Delegate(C* c, F f)\

027. {\

028. return new NAME##DelegateImpl< C >(c, f);\

029. }

030. /

031. //delegate 1

032. #define DEFINE_DELEGATE(NAME, R, P1)\

033. class NAME##Delegate\

034. {\

035. public:\

036. virtual ~NAME##Delegate(void){ }\

037. virtual R operator()(P1 p1) = 0;\

038. };\

039. template< typename C >\

040. class NAME##DelegateImpl : public NAME##Delegate\

041. {\

042. private:\

043. typedef R (C::*F)(P1);\

044. C* m_class;\

045. F m_fun;\

046. public:\

047. NAME##DelegateImpl(C* c, F f){ m_class = c; m_fun = f; }\

048. virtual R operator()(P1 p1)\

049. {\

050. if(m_class)\

051. return (m_class->*m_fun)(p1);\

052. }\

053. };\

054. template< typename C, typename F>\

055. NAME##Delegate* Make##NAME##Delegate(C* c, F f)\

056. {\

057. return new NAME##DelegateImpl< C>(c, f);\

058. }

059. /

060. //delegate 2

061. #define DEFINE_DELEGATE(NAME, R, P1, P2)\

062. class NAME##Delegate\

063. {\

064. public:\

065. virtual ~NAME##Delegate(void){ }\

066. virtual R operator()(P1 p1, P2 p2) = 0;\

067. };\

068. template< typename C >\

069. class NAME##DelegateImpl : public NAME##Delegate\

070. {\

071. private:\

072. typedef R (C::*F)(P1, P2);\

073. C* m_class;\

074. F m_fun;\

075. public:\

076. NAME##DelegateImpl(C* c, F f){ m_class = c; m_fun = f; }\

077. virtual R operator()(P1 p1, P2 p2)\

078. {\

079. if(m_class)\

080. return (m_class->*m_fun)(p1, p2);\

081. }\

082. };\

083. template< typename C, typename F>\

084. NAME##Delegate* Make##NAME##Delegate(C* c, F f)\

085. {\

086. return new NAME##DelegateImpl< C>(c, f);\

087. }

088.  

089. /*

090. ///

091. //sample

092. DEFINE_DELEGATE(Open, void, int, string)

093. class sdk

094. {

095. public:

096. OpenDelegate* pEvent;

097. sdk(): pEvent(NULL) { }

098. void Open()

099. {

100. cout < < ;"opened"> >endl;

101. if(pEvent != NULL)

102. (*pEvent)(100, "你好");

103. }

104. };

105. class client

106. {

107. private:

108. sdk m_sdk;

109. public:

110. client()

111. {

112. m_sdk.pEvent = MakeOpenDelegate(this, OnOpen2);

113. }

114. void Open()

115. {

116. m_sdk.Open();

117. }

118. void OnOpen()

119. {

120. cout< < ;"Open event fired" > >endl;

121. }

122. void OnOpen2(int t, string str)

123. {

124. cout< < "Open event fired, Param = "< < t < < "param2 = "< < str.c_str() < < endl;

125. }

126. };

127. */