C++設計模式-TemplateMethod模板方法模式

Template模板方法模式
做用：定義一個操做中的算法的骨架。而將一些步驟延遲到子類中，模板方法使得子類能夠不改變一個算法的結構便可重定義該算法的某些特定步驟。

其關鍵是將通用算法（邏輯）封裝在抽象基類中，並將不一樣的算法細節放到子類中實現。

UML圖以下：

AbstractClass是抽象類，其實也就是一個抽象模板，定義並實現了一個模板方法。這個模板方法通常是一個具體方法，它給出了一個頂層邏輯的骨架，而邏輯的組成步驟在相應的抽象操做中，推遲到之類實現。頂層邏輯也有可能調用一些具體方法。

ConcreteClass，實現父類所定義的一個或多個抽象方法。每個AbstractClass均可以有任意多個ConcreteClass與之對應，而每一ConcreteClass均可以給出這些抽象方法（也就是頂級邏輯的組成步驟）的不一樣實現，從而使得頂級邏輯的實現各不相同。

特色：

模板方法模式是經過把不變行爲搬移到基類，去除之類中的重複代碼來體現它的優點。

當不變的和可變的行爲在方法的子類實現中混合在一塊兒的時候，不變的行爲就會在子類中重複出現。經過模板方法模式把這些行爲搬移到單一的地方，這樣就幫助子類擺脫重複的不變行爲的糾纏。

代碼以下：

TemplateMethod.h

 1 #ifndef _TEMPLATEMETHOD_H_
 2 #define _TEMPLATEMETHOD_H_
 3 
 4 //抽象模板，並定義了一個模板方法。
 5 class AbstractClass
 6 {
 7 public:
 8     ~AbstractClass();
 9     //具體的模板方法，給出了邏輯的骨架，而邏輯的組成是一些相應的抽象操做，它們都推遲到子類中實現
10     void TemplateMethod();
11     //一些抽象行爲，放到子類中去實現
12     virtual void PrimitiveOperation1()=0;
13     virtual void PrimitiveOperation2()=0;
14 protected:
15     AbstractClass();
16 private:
17 };
18 
19 //實現基類所定義的抽象方法
20 class ConcreteClassA : public AbstractClass
21 {
22 public:
23     ConcreteClassA();
24     ~ConcreteClassA();
25     //實現基類定義的抽象行爲
26     virtual void PrimitiveOperation1();
27     virtual void PrimitiveOperation2();
28 private:
29 };
30 
31 //實現基類所定義的抽象方法
32 class ConcreteClassB : public AbstractClass
33 {
34 public:
35     ConcreteClassB();
36     ~ConcreteClassB();
37     //實現基類定義的抽象行爲
38     virtual void PrimitiveOperation1();
39     virtual void PrimitiveOperation2();
40 private:
41 };
42 #endif

TemplateMethod.cpp

 1 #include "TemplateMethod.h"
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 AbstractClass::AbstractClass()
 7 {}
 8 
 9 AbstractClass::~AbstractClass()
10 {}
11 
12 void AbstractClass::TemplateMethod()
13 {
14     this->PrimitiveOperation1();
15     this->PrimitiveOperation2();
16 }
17 
18 ConcreteClassA::ConcreteClassA()
19 {}
20 
21 ConcreteClassA::~ConcreteClassA()
22 {}
23 
24 void ConcreteClassA::PrimitiveOperation1()
25 {
26     cout << "ConcreteClassA::PrimitiveOperation1" << endl;
27 }
28 
29 void ConcreteClassA::PrimitiveOperation2()
30 {
31     cout << "ConcreteClassA::PrimitiveOperation2" << endl;
32 }
33 
34 ConcreteClassB::ConcreteClassB()
35 {}
36 
37 ConcreteClassB::~ConcreteClassB()
38 {}
39 
40 void ConcreteClassB::PrimitiveOperation1()
41 {
42     cout << "ConcreteClassB::PrimitiveOperation1" << endl;
43 }
44 
45 void ConcreteClassB::PrimitiveOperation2()
46 {
47     cout << "ConcreteClassB::PrimitiveOperation2" << endl;
48 }

Main.cpp

 1 #include "TemplateMethod.h"
 2 
 3 int main()
 4 {
 5     //ConcreteClassA與ConcreteClassB可相互替換
 6     AbstractClass* pAbstract = new ConcreteClassA();
 7     pAbstract->TemplateMethod();
 8 
 9     pAbstract = new ConcreteClassB();
10     pAbstract->TemplateMethod();
11     
12     return 0;
13 }