基本是照搬了代碼 但是不知道是作者沒有在VC71中測試 還是發出來的代碼還是有問題的 我在VC71中編譯還是有點點小小的曲折
下面是我自己根據VC71修改的!
1
class CEvent;
2
3
class CFunImpl
4

{
5
public:
6
CFunImpl()
{}
7
virtual ~CFunImpl()
{}
8
virtual void operator()(CEvent& e) = 0;
9
virtual bool operator== (const CFunImpl& fun) = 0;
10
virtual CFunImpl* Clone() = 0;
11
};
12
13
template <typename ClassName>
14
class CMemberFunc : public CFunImpl
15

{
16
public:
17
18
typedef CMemberFunc<ClassName> this_type;
19
typedef void (ClassName::*fEventHandler) ( CEvent & e );
20
21
CMemberFunc( ClassName& obj, fEventHandler impl ) : m_Object(obj), m_pImpl(impl)
{}
22
23
void operator ()( CEvent & e )
24
{
25
if ( m_pImpl!=NULL ) (m_Object.*(m_pImpl))( e );
26
}
27
28
CFunImpl* Clone()
29
{
30
return new this_type(m_Object, m_pImpl);
31
}
32
33
bool operator== (const CFunImpl& fun)
34
{
35
if ( typeid(*this) == typeid(fun) )
36
{
37
const this_type& rFun = dynamic_cast<const this_type& >(fun);
38
39
return (&m_Object == &rFun.m_Object && m_pImpl == rFun.m_pImpl);
40
}
41
42
return false;
43
}
44
45
virtual ~CMemberFunc()
46
{
47
}
48
protected:
49
ClassName& m_Object;
50
fEventHandler m_pImpl;
51
};
52
53
class CStaticFunc : public CFunImpl
54

{
55
public:
56
typedef void (*fEventHandler) ( CEvent & e );
57
58
CStaticFunc( fEventHandler impl ) : m_pImpl(impl)
{}
59
60
void operator ()( CEvent & e )
61
{
62
if ( m_pImpl!=NULL ) m_pImpl( e );
63
}
64
65
CFunImpl* Clone()
66
{
67
return new CStaticFunc(m_pImpl);
68
}
69
70
bool operator== (const CFunImpl& fun)
71
{
72
if ( typeid(*this) == typeid(fun) )
73
{
74
const CStaticFunc& rFun = dynamic_cast<const CStaticFunc& >(fun);
75
76
return (m_pImpl == rFun.m_pImpl);
77
}
78
79
return false;
80
}
81
82
virtual ~CStaticFunc()
83
{
84
}
85
protected:
86
fEventHandler m_pImpl;
87
};
88
89
class CEventHandler
90

{
91
private:
92
void Clear()
{if(m_pImpl)
{delete m_pImpl ;m_pImpl = NULL ;}}
93
CFunImpl* m_pImpl;
94
public:
95
~CEventHandler()
96
{
97
Clear();
98
}
99
template<typename ClassName>
100
CEventHandler( ClassName& obj, void (ClassName::*impl)(CEvent&) ) : m_pImpl( new CMemberFunc<ClassName>(obj,impl) )
{}
101
CEventHandler( void(*impl)(CEvent&) ) : m_pImpl( new CStaticFunc(impl) )
{}
102
CEventHandler( const CEventHandler&fun ) : m_pImpl( NULL )
{ *this=fun; }
103
void operator() ( CEvent & e )
104
{
105
(*m_pImpl)(e);
106
}
107
CEventHandler& operator= ( const CEventHandler& fun )
108
{
109
Clear();
110
if (fun.m_pImpl) m_pImpl = fun.m_pImpl->Clone();
111
return *this;
112
}
113
bool operator== ( const CEventHandler & handler )
114
{
115
if ( m_pImpl==NULL || handler.m_pImpl==NULL ) return true ;
116
if ( typeid(*m_pImpl) == typeid(*(handler.m_pImpl)) )
117
{
118
return (*m_pImpl) == (*(handler.m_pImpl));
119
}
120
return false ;
121
}
122
};
123
124
class CEvent
125

{
126
private:
127
std::list<CEventHandler>m_Funcs;
128
void Register( CEventHandler handle )
129
{
130
m_Funcs.push_back(handle);
131
}
132
void UnRegister( const CEventHandler & handler )
133
{
134
m_Funcs.remove(handler);
135
}
136
void* lpData;
137
public:
138
void* GetPointer()
{ return lpData; }
139
CEvent & operator<< ( const CEventHandler & handler )
140
{
141
Register ( handler );
142
return * this ;
143
}
144
145
CEvent & operator>> ( const CEventHandler & handler )
146
{
147
UnRegister ( handler );
148
return * this ;
149
}
150
151
void operator ( )( void* pData=NULL )
152
{
153
lpData=pData;
154
for(std::list<CEventHandler>::iterator pos=m_Funcs.begin(); pos!=m_Funcs.end(); ++pos )
155
(*pos)(*this);
156
}
157
};
158

2

3

4



5

6



7



8

9

10

11

12

13

14

15



16

17

18

19

20

21



22

23

24



25

26

27

28

29



30

31

32

33

34



35

36



37

38

39

40

41

42

43

44

45

46



47

48

49

50

51

52

53

54



55

56

57

58



59

60

61



62

63

64

65

66



67

68

69

70

71



72

73



74

75

76

77

78

79

80

81

82

83



84

85

86

87

88

89

90



91

92




93

94

95

96



97

98

99

100



101



102



103

104



105

106

107

108



109

110

111

112

113

114



115

116

117



118

119

120

121

122

123

124

125



126

127

128

129



130

131

132

133



134

135

136

137

138



139

140



141

142

143

144

145

146



147

148

149

150

151

152



153

154

155

156

157

158

編譯的時候要打開RTTI!