一.引入

 二.template method(模板方法)

程式碼示例:

一開始的程式碼:

template1_app.cpp:

 1 //應用程式開發人員
 2 class Application{
 3 public:
 4     bool Step2(){
 5         //...
 6     }
 7 
 8     void Step4(){
 9         //...
10     }
11 };
12 
13 int main()
14 {
15     Library lib;　　//這裡都是以類的方式來呼叫方法的
16     Application app;
17 
18     lib.Step1();
19 
20     if (app.Step2()){
21         lib.Step3();
22     }
23 
24     for (int i = 0; i < 4; i++){
25         app.Step4();
26     }
27 
28     lib.Step5();
29 
30 }

對應的庫的程式碼:

template1_lib.cpp:

 1 //程式庫開發人員
 2 class Library{
 3 
 4 public:
 5     void Step1(){
 6         //...
 7     }
 8 
 9     void Step3(){
10         //...
11     }
12 
13     void Step5(){
14         //...
15     }
16 };

這裡的主體程式流程,實際上框架開發者已經設計好了,常常是穩定的.

因此更好的解決方案是,庫開發者把流程寫好,一些需要開發者實現的介面定義好,留給開發者實現:

改進後的程式碼:

template2_lib.cpp:

 1 //程式庫開發人員
 2 class Library{
 3 public:
 4     //穩定 template method
 5     void Run(){
 6         
 7         Step1();
 8 
 9         if (Step2()) { //支援變化 ==> 虛擬函式的多型呼叫
10             Step3(); 
11         }
12 
13         for (int i = 0; i < 4; i++){
14             Step4(); //支援變化 ==> 虛擬函式的多型呼叫
15         }
16 
17         Step5();
18 
19     }
20     virtual ~Library(){ }
21 
22 protected:　　//採用protected,讓子類能夠訪問到.
23     
24     void Step1() { //穩定
25         //.....
26     }
27     void Step3() {//穩定
28         //.....
29     }
30     void Step5() { //穩定
31         //.....
32     }
33 
34     virtual bool Step2() = 0;//變化
35     virtual void Step4() =0; //變化
36 };

template2_app.cpp:

 1 //應用程式開發人員
 2 class Application : public Library {
 3 protected:
 4     virtual bool Step2(){
 5         //... 子類重寫實現
 6     }
 7 
 8     virtual void Step4() {
 9         //... 子類重寫實現
10     }
11 };
12 
13 
14 
15 
16 int main()
17     {
18         Library* pLib=new Application();
19         lib->Run();
20 
21         delete pLib;
22     }
23 }

注意一下:

基類的解構函式要寫成虛的,否則呼叫不到子類的解構函式,因為如果不是虛擬函式的話,

基類指標只能找到基類的解構函式,delete時只會呼叫基類的解構函式;而解構函式為虛擬函式時,則基類指標可以找到子類對應的解構函式.

 紅色部分時穩定的,藍色部分是變化的.

&n