回調函數應用
好郁悶的void* int*
StatusEnum CreateList(Node_t *p , void *i);
StatusEnum PrintStatus(void* p)
操作:
構造的時候
for (int i = 0; i < 5; ++ i)
{
CreateList(&((list.pHead)), (void*)i);
}
打印的時候
StatusEnum PrintStatus(void* p)
{
//cout<<"A "<<(int) (*p);
// cout<<"B "<<*((int*)p)<<endl;
cout<<(int)p<<endl;
return LIST_OK;
}
就這么點代碼,糾結死我了,why? 為什么這樣就不用
考慮生命周期了呢,為什么打印不是cout<<"B "<<*((int*)p)<<endl;
而是 cout<<(int)p<<endl;
1
#include <iostream>
2
using namespace std;
3
4
#define MAX 5
5
6
typedef struct tagNode_t
7
{
8
struct tagNode_t *pPre;
9
struct tagNode_t *pNex;
10
void * pData;
11
}Node_t;
12
13
typedef struct tagList_t
14
{
15
Node_t pHead;
16
}List_t;
17
18
19
typedef enum tagStatusEnum
20
{
21
LIST_NG = 0,
22
LIST_OK,
23
}StatusEnum;
24
25
//函數指針
26
typedef StatusEnum (*pFun ) (void* data);
27
typedef StatusEnum (*pVistFun)(void* ctx, void* data);
28
29
StatusEnum CreateList(Node_t* p , int* i);
30
StatusEnum DeleteList(List_t* p);
31
32
StatusEnum PrintList(List_t* list, pFun print);
33
StatusEnum PrintStatus(void* p);
34
35
StatusEnum List_ForEach(List_t* p, pVistFun, void* pvCtx);
36
StatusEnum FindMax(void* pvCtx, void* pvData);
37
StatusEnum Sum(void* pvCtx, void* pvData);
38
39
40
StatusEnum ListForEach(List_t* p, pVistFun Fun, void* pvCtx)
41
{
42
StatusEnum Status = LIST_OK;
43
Node_t *pstTemp = (p->pHead).pNex;
44
while((NULL != pstTemp ) && (Status != LIST_NG))
45
{
46
Status = Fun(pvCtx, pstTemp->pData);
47
pstTemp = pstTemp->pNex;
48
}
49
50
return Status;
51
}
52
53
54
StatusEnum Sum(void* pvCtx, void* pvData)
55
{
56
int *piCtx = (int*)pvCtx;
57
int *piData = (int*)pvData;
58
*piCtx += *piData;
59
return LIST_OK;
60
}
61
62
StatusEnum FindMax(void* pvCtx, void* pvData)
63
{
64
int *piMax = (int*)pvCtx;
65
int *piData = (int*)pvData;
66
if ( *piMax < *piData)
67
{
68
*piMax = *piData;
69
}
70
71
return LIST_OK;
72
}
73
74
75
StatusEnum CreateList(Node_t *p , int *i)
76
{
77
Node_t *pTemp = new Node_t;
78
pTemp->pPre = NULL;
79
pTemp->pNex = NULL;
80
pTemp->pData = i;
81
82
//Head Insert
83
pTemp->pNex = (p)->pNex;
84
(p)->pNex = pTemp;
85
pTemp->pPre = p;
86
87
if (NULL != pTemp->pNex)
88
{
89
pTemp->pNex->pPre = pTemp;
90
}
91
92
return LIST_OK;
93
}
94
95
StatusEnum PrintList(List_t *p, pFun print)
96
{
97
Node_t *pTemp = p->pHead.pNex;
98
while ( NULL != pTemp)
99
{
100
print(pTemp->pData);
101
pTemp = pTemp->pNex;
102
}
103
104
return LIST_OK;
105
}
106
107
108
StatusEnum PrintStatus(void* p)
109
{
110
//cout<<"A "<<(int) (*p);
111
cout<<"B "<<*(int*)p<<endl;
112
return LIST_OK;
113
}
114
115
116
StatusEnum DeleteList(List_t *p)
117
{
118
Node_t *pTemp = p->pHead.pNex;
119
Node_t *pCur = NULL;
120
while ( NULL != pTemp)
121
{
122
pCur = pTemp;
123
pTemp = pTemp->pNex;
124
delete pCur;
125
}
126
127
return LIST_OK;
128
}
129
130
int main(int argc, char ** argv)
131
{
132
List_t list;
133
(list.pHead).pPre = NULL;
134
(list.pHead).pNex = NULL;
135
(list.pHead).pData = NULL;
136
137
//Create
138
int aiData[MAX] = {1,3,4,5,2};
139
for (int i = 0; i < MAX; ++ i)
140
{
141
CreateList(&(list.pHead), &(aiData[i]));
142
}
143
144
145
//Print
146
PrintList(&list, PrintStatus);
147
148
//Max
149
int iMax = 0;
150
ListForEach(&list, FindMax, &iMax);
151
cout<<"Max: "<<iMax<<endl;
152
153
//Sum
154
int iSum = 0;
155
ListForEach(&list, Sum, &iSum);
156
cout<<"Sum: "<<iSum<<endl;
157
158
//Delete
159
DeleteList(&list);
160
161
return 0;
162
}
163
164
165

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

159

160

161

162

163

164

165

好郁悶的void* int*
StatusEnum CreateList(Node_t *p , void *i);
StatusEnum PrintStatus(void* p)
操作:
構造的時候
for (int i = 0; i < 5; ++ i)
{
CreateList(&((list.pHead)), (void*)i);
}
打印的時候
StatusEnum PrintStatus(void* p)
{
//cout<<"A "<<(int) (*p);
// cout<<"B "<<*((int*)p)<<endl;
cout<<(int)p<<endl;
return LIST_OK;
}
就這么點代碼,糾結死我了,why? 為什么這樣就不用
考慮生命周期了呢,為什么打印不是cout<<"B "<<*((int*)p)<<endl;
而是 cout<<(int)p<<endl;