C++中回调函数的封装——使用

 本文是上一篇文章中实现代码的具体使用实例。

1. #include "MultiCB.h"
3. using namespace std;
4. using namespace MultiCB;
6. class EventArgs
7. {
8. public:
9.     EventArgs()
10.     {
11.         Name = "EventArgs";
12.     }
13.     string Name;
14.     void TestMemFunc(EventArgs* arg)
15.     {
16.         cout << arg->Name.c_str() << endl;
17.     }
18. };
20. class EvtArgs2 : public EventArgs
21. {
22. public:
23.     EvtArgs2()
24.     {
25.         Name = "EvtArgs2";
26.     }
27. };
29. void TestGlbFunc1(EventArgs* arg)
30. {    
31.     cout << "TestGlbFunc1: " << arg->Name.c_str() << endl;
32. }
33. void TestGlbFunc2(EventArgs* arg)
34. {    
35.     cout << "TestGlbFunc2: " << arg->Name.c_str() << endl;
36. }
38. class StaticClass
39. {
40. public:
41.     static void Func(EventArgs* arg)
42.     {
43.         cout << "StaticClass::Func: " << arg->Name.c_str() << endl;
44.     }
45. };
47. typedef void(*GlbFuncType)(EventArgs*);
49. void TestStaticCallBack()
50. {       
51.     cout << "Test the StaticCallBack" << endl;
52.     StaticCallBack<GlbFuncType, EventArgs> stEvent;
53.     EventArgs evtArg;
54.     stEvent.Raise(&evtArg);
55.     cout << endl;
57.     stEvent.Register(&TestGlbFunc1);
58.     stEvent.Raise(&evtArg);
59.     cout << endl;
61.     stEvent.Register(&TestGlbFunc2);
62.     stEvent.Raise(&evtArg);
63.     cout << endl;
65.     stEvent.UnRegister(&TestGlbFunc1);
66.     stEvent.Raise(&evtArg);
67.     cout << endl;
69.     stEvent.Register(&TestGlbFunc1);
70.     stEvent.Raise(&evtArg);
71.     cout << endl;
73.     stEvent.Register(&TestGlbFunc1);
74.     stEvent.Raise(&evtArg);
75.     cout << endl;
77.     EvtArgs2 arg2;
78.     stEvent -= &TestGlbFunc1;
79.     stEvent.Raise(&arg2);
80.     cout << endl;
82.     stEvent += &TestGlbFunc2;
83.     stEvent.Raise(&arg2);
84.     cout << endl;
86.     stEvent += &TestGlbFunc1;
87.     stEvent.Raise(&arg2);
88.     cout << endl;
90.     stEvent += &StaticClass::Func;
91.     stEvent.Raise(&arg2);
92.     cout << endl;
94.     stEvent.Clear();
95.     stEvent.Raise(&arg2);
97.     cout << endl;
98. }
101. class UserClass1
102. {
103. public:
104.     void Func1(EventArgs* arg)
105.     {
106.         cout << "UserClass1::Func1 " << arg->Name.c_str() << endl;
107.     }
109.     virtual void VirtualFunc(EventArgs* arg)
110.     {
111.         cout << "UserClass1::VirtualFunc " << arg->Name.c_str() << endl;
112.     }
113. };
117. class UserClass2 : public UserClass1
118. {
119. public:
120.     void VirtualFunc(EventArgs* arg)
121.     {
122.         cout << "UserClass2::VirtualFunc " << arg->Name.c_str() << endl;
123.     }
124. };
126. class UserClass3 : public UserClass2
127. {
128. public:
129.     void VirtualFunc(EventArgs* arg)
130.     {
131.         cout << "UserClass3::VirtualFunc " << arg->Name.c_str() << endl;
132.     }
133. };
135. typedef void (UserClass1::*MemFuncType)(EventArgs* arg);
137. void TestClassCallBack()
138. {
139.     typedef ClassCallBack<UserClass1,MemFuncType,EventArgs> Event;
140.     Event clsEvt;
141.     Event::Pair pair;
142.     UserClass1 cls1;
143.     UserClass2 cls2;
144.     UserClass3 cls3;
145.     EventArgs evtArg;
146.     EvtArgs2 evtArg2;
148.     pair.func = &UserClass1::Func1;
149.     pair.obj = &cls1;
150.     clsEvt.Register(pair);
151.     clsEvt.Raise(&evtArg);
152.     cout << endl;
154.     pair.func = &UserClass1::VirtualFunc;
155.     pair.obj = &cls1;
156.     clsEvt.Register(pair);
157.     clsEvt.Raise(&evtArg);
158.     cout << endl;
160.     //pair.func = &UserClass2::VirtualFunc;
161.     pair.func = &UserClass1::VirtualFunc;
162.     pair.obj = &cls2;
163.     clsEvt.Register(pair);
164.     clsEvt.Raise(&evtArg2);
165.     cout << endl;
167.     pair.func = &UserClass1::Func1;
168.     pair.obj = &cls2;
169.     clsEvt += pair;
170.     clsEvt.Raise(&evtArg2);
171.     cout << endl;
173.     pair.func = &UserClass1::VirtualFunc;
174.     pair.obj = &cls1;
175.     clsEvt -= pair;    
176.     clsEvt.Raise(&evtArg2);
177.     cout << endl;
179.     pair.func = &UserClass1::VirtualFunc;
180.     pair.obj = &cls3;
181.     clsEvt += pair;    
182.     clsEvt.Raise(&evtArg2);
183.     cout << endl;
185. }