模板方法模式是一種很簡單但卻很常見的設計模式,它常常在不知不覺中被使用。
概念:定義一個操作中的算法的骨架,而將具體的執行步驟延遲到子類中。模板方法使得子類可以不改變算法的結構而只是重新定義算法的步驟,使得不同步驟產生不同的效果。
說的更簡單點,就是執行的框架由基類來定,而框架中的方法及執行順序由子類來重定義。
UML類圖:
上圖的代碼很好實現,就是基類的模板函數中調用了operation1和operation2中的一個或兩個,而子類則重載了那兩個方法。
下面給出一個常用的簡單多線程工作模式,具體的工作由實際的調用者決定。
為方便,將代碼都實現在一個文件里:
概念:定義一個操作中的算法的骨架,而將具體的執行步驟延遲到子類中。模板方法使得子類可以不改變算法的結構而只是重新定義算法的步驟,使得不同步驟產生不同的效果。
說的更簡單點,就是執行的框架由基類來定,而框架中的方法及執行順序由子類來重定義。
UML類圖:

上圖的代碼很好實現,就是基類的模板函數中調用了operation1和operation2中的一個或兩個,而子類則重載了那兩個方法。
下面給出一個常用的簡單多線程工作模式,具體的工作由實際的調用者決定。
為方便,將代碼都實現在一個文件里:
1
#include <iostream>
2
#include <pthread.h>
3
#include <unistd.h>
4
5
using namespace std;
6
7
/**//**
8
* @class BaseThread
9
* @brief The Base class for TemplateMethod DesignPattern.
10
* @author wei.chen (2010-8-7)
11
*/
12
class BaseThread
13

{
14
public:
15
BaseThread(): m_runThread(0)
16
{
17
cout << "BaseThread's constructor" << endl;
18
}
19
20
virtual ~BaseThread()
21
{
22
cout << "BaseThread's destructor" << endl;
23
}
24
25
/**//**
26
* @fn run
27
* @brief Running as the thread's starting.
28
* @param pObject The Sub-class's object.
29
* @author wei.chen (2010-8-7)
30
*/
31
static void* run(void* pObject)
32
{
33
cout << "running
" << endl;
34
BaseThread* pThread = static_cast<BaseThread*>(pObject);
35
pThread->work();
36
return NULL;
37
}
38
39
/**//// Template method, no-virtual.
40
int init()
41
{
42
cout << "Initilize
" << endl;
43
return pthread_create(&m_runThread, NULL, run, this);
44
}
45
46
protected:
47
48
/**//// Need to be overloaded in Sub-class.
49
virtual int work()
50
{
51
cout << "The real method of working for BaseThread" << endl;
52
return 0;
53
}
54
55
private:
56
pthread_t m_runThread;
57
};
58
59
class TestThread1 : public BaseThread
60

{
61
public:
62
TestThread1()
63
{
64
cout << "TestThread1's constructor" << endl;
65
}
66
67
virtual ~TestThread1()
68
{
69
cout << "TestThread1's destructor" << endl;
70
}
71
72
protected:
73
virtual int work()
74
{
75
cout << "working for test1" << endl;
76
return 0;
77
}
78
};
79
80
class TestThread2 : public BaseThread
81

{
82
public:
83
TestThread2()
84
{
85
cout << "TestThread2's constructor" << endl;
86
}
87
virtual ~TestThread2()
88
{
89
cout << "TestThread2's destructor" << endl;
90
}
91
92
protected:
93
virtual int work()
94
{
95
cout << "working for test2" << endl;
96
return 0;
97
}
98
};
99
100
int main()
101

{
102
BaseThread* test1 = new TestThread1();
103
test1->init();
104
105
cout << endl;
106
107
BaseThread* test2 = new TestThread2();
108
test2->init();
109
110
while (1)
{
111
pause();
112
}
113
114
return 0;
115
}

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

輸出:
BaseThread's constructor
TestThread1's constructor
Initilize...
running...
working for test1
BaseThread's constructor
TestThread2's constructor
Initilize...
running...
working for test2