• 定義一系列的演算法，把它們一個個封裝起來，並且使它們可相互替換。
• 適用場景：
  • 許多相關的類僅僅是行為有異。“策略”提供了一種用多個行為中的一個行為來配置一個類的方法。
  • 需要使用一個演算法的不同變體。
  • 演算法使用客戶不應該知道的資料。使用策略模式避免暴露覆雜的、與演算法相關的資料結構。
  • 一個類定義了多種行為，並且這些行為在這個類的操作中以多個條件語句的形式出現。將相關的條件分支移入他們各自的Strategy類中以代替這些條件語句。

/** 
 * 體操策略模式基類. 
 */ 
class StrategyGym 
{ 
public: 
    StrategyGym(); 
    virtual ~StrategyGym(); 
    virtual void DoGym() = 0; //純虛擬函式 
}; 

//--------體操基類實現-------- 
StrategyGym::StrategyGym() 
{ 
} 
StrategyGym::~StrategyGym() 
{ 
    cout << "~StrategyGym....."<<endl;
}

/** 
 * 眼保健操策略類. 
 */ 
class StrategyEyeGym : public StrategyGym 
{ 
public: 
	StrategyEyeGym(); 
	virtual ~StrategyEyeGym(); 
	void DoGym(); 
}; 

//--------眼保健操類-------- 
StrategyEyeGym::StrategyEyeGym() 
{ 
} 
StrategyEyeGym::~StrategyEyeGym() 
{ 
    cout << "打完收工....." << endl; 
} 
//做啥捏? 眼保健操 
void StrategyEyeGym::DoGym() 
{ 
    cout << "做眼保健操1->4節." << endl; 
} 
/** 
 * 廣播體操策略類. 
 */ 
class StrategyBroadcastGym : 
      public StrategyGym 
{ 
public: 
    StrategyBroadcastGym(); 
    virtual ~StrategyBroadcastGym(); 
    void DoGym(); 
}; 
//--------廣播體操-------- 
StrategyBroadcastGym::StrategyBroadcastGym() 
{ 
} 
StrategyBroadcastGym::~StrategyBroadcastGym() 
{ 
    cout << "廣播體操，做完....." << endl; 
} 
void StrategyBroadcastGym::DoGym() 
{ 
    cout << "做廣播體操1->8節." << endl; 
} 

/** 
 * 策略使用類 
 */ 
class Context 
{ 
public: 
    Context(StrategyGym* stg); 
    ~Context(); 
    void DoAction(); 
private: 
    StrategyGym* _stg; //體操的基類指標 
}; 
//--------策略使用者.-------- 
Context::Context(StrategyGym* stg) 
{ 
    _stg = stg; 
} 
Context::~Context() 
{ 
    if (_stg != NULL) 
    { 
        delete _stg; 
    } 
} 
void Context::DoAction() 
{ 
/* 一旦選擇一個演算法, 就完全切換了整個演算法.
 一個演算法與另外一個演算法, 沒有什麼共同的地方.*/ 
    _stg->DoGym();
} 
 

呼叫者的程式碼：

//策略模式例子 
//眼保健操 
StrategyGym* sEye = new StrategyEyeGym(); 
Context contextEye(sEye); 
contextEye.DoAction(); 
//廣播體操 
StrategyGym* sBroad = new StrategyBroadcastGym(); 
Context contestBroad(sBroad); 
contestBroad.DoAction(); 

• 優點
  • Strategy類層次定義了一系列的可供重用的演算法或行為；
  • 消除條件語句；
  • Strategy提供相同行為的不同實現；
• 缺點
  • 客戶必須瞭解不同的Strategy；
  • Strategy和Context之間的通訊開銷；
  • 增加了物件的數目；

1.  特點說明

• 定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。
• 使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。
• 一次性實現一個演算法的不變的部分，並將可變的行為留給子類來實現。
• 各子類中公共的行為被提取出來並集中到一個公共父類中，避免程式碼重複。
• 注：Template Method模式和C++模板一點關係都沒有

2. 基本程式碼實現

class TemplateMethod 
{ 
public: 
    virtual ~TemplateMethod(); 
    void DoGym(); //對外部的介面 
protected: 
    //實際需要呼叫的虛擬函式, 需要派生類實現 
    virtual void Section1st() = 0; 
    virtual void Section2nd() = 0; 
    virtual void Section3rd() = 0; 
    virtual void Section4th() = 0; 
    virtual void Section5th() = 0; 
    virtual void Section6th() = 0; 
    virtual void Section7th() = 0; 
    virtual void Section8th() = 0; 
    TemplateMethod();
}; 
TemplateMethod::TemplateMethod() 
{ 
} 
TemplateMethod::~TemplateMethod() 
{ 
} 
/* 對外的介面函式, 呼叫實際的處理函式, 
這樣, 如果派生類的實現有改動,介面是不需要改動的. 
把公共的部分, 放在介面中, 這是外部使用這個演算法時, 不變的部分, 
比如一個演算法的步驟. 
*/ 
void TemplateMethod::DoGym() 
{ 
    /* 就目前而言, 不管哪一套廣播體操, 一般是8節, 這8節的具體做法可能不一樣,就需要派生類具體實現了.但整個廣播體操的整體架構是一樣的, 都是8節, 都是從第1節做到第8節.*/ 
    Section1st(); 
    Section2nd(); 
    Section3rd(); 
    Section4th(); 
    Section5th(); 
    Section6th(); 
    Section7th(); 
    Section8th();
} 

//第8套廣播體操 
class BroadcastGymEighth : public TemplateMethod 
{ 
public: 
    BroadcastGymEighth(); 
    ~BroadcastGymEighth(); 
protected: 
    void Section1st(); 
    void Section2nd(); 
    void Section3rd(); 
    void Section4th(); 
    void Section5th(); 
    void Section6th(); 
    void Section7th(); 
    void Section8th();
}; 


//第8套廣播體操 
BroadcastGymEighth::BroadcastGymEighth() 
{ } 
BroadcastGymEighth::~BroadcastGymEighth() 
{} 
void BroadcastGymEighth::Section1st() 
{ 
    cout << "第八套廣播體操, 第1節." << endl; 
} 
void BroadcastGymEighth::Section2nd() 
{ 
    cout << "第八套廣播體操, 第2節." << endl; 
} 
void BroadcastGymEighth::Section3rd() 
{ 
    cout << "第八套廣播體操, 第3節." << endl; 
} 
void BroadcastGymEighth::Section4th() 
{ 
    cout << "第八套廣播體操, 第4節." << endl; 
} 
void BroadcastGymEighth::Section5th() 
{ 
    cout << "第八套廣播體操, 第5節." << endl; 
} 
void BroadcastGymEighth::Section6th() 
{ 
    cout << "第八套廣播體操, 第6節." << endl; 
} 
void BroadcastGymEighth::Section7th() 
{ 
    cout << "第八套廣播體操, 第7節." << endl; 
} 
void BroadcastGymEighth::Section8th() 
{ 
    cout << "第八套廣播體操, 第8節." << endl; 
} 


//第9套廣播體操 
class BroadcastGymNinth : public TemplateMethod 
{ 
public: 
	BroadcastGymNinth(); 
	~BroadcastGymNinth(); 
protected: 
	void Section1st(); 
    void Section2nd(); 
    void Section3rd(); 
    void Section4th(); 
    void Section5th(); 
    void Section6th(); 
    void Section7th(); 
    void Section8th();
}; 

//第套廣播體操 
BroadcastGymNinth::BroadcastGymNinth() 
{} 
BroadcastGymNinth::~BroadcastGymNinth() 
{} 
void BroadcastGymNinth::Section1st() 
{ 
    cout << "第九套廣播體操, 第1節." << endl; 
} 
void BroadcastGymNinth::Section2nd() 
{ 
    cout << "第九套廣播體操, 第2節." << endl; 
} 
void BroadcastGymNinth::Section3rd() 
{ 
    cout << "第九套廣播體操, 第3節." << endl; 
} 
void BroadcastGymNinth::Section4th() 
{ 
    cout << "第九套廣播體操, 第4節." << endl; 
} 
void BroadcastGymNinth::Section5th() 
{ 
    cout << "第九套廣播體操, 第5節." << endl; 
} 
void BroadcastGymNinth::Section6th() 
{ 
    cout << "第九套廣播體操, 第6節." << endl; 
} 
void BroadcastGymNinth::Section7th() 
{ 
    cout << "第九套廣播體操, 第7節." << endl; 
} 
void BroadcastGymNinth::Section8th() 
{ 
    cout << "第九套廣播體操, 第8節." << endl;
} 
 

呼叫者程式碼：

/* 模板方法模式 */
//第八套廣播體操 
TemplateMethod* t = new BroadcastGymEighth(); 
t->DoGym();
delete t; 
t = NULL;
//第九套廣播體操 
t = new BroadcastGymNinth(); 
t->DoGym();
delete t; 
t = NULL; 

當不變的和可變的行為在方法的子類實現中混合在一起的時候，不變的行為就會在子類中重複出現。

我們通過模板方法模式，把這些行為搬移到單一的地方，這樣就可以幫助子類擺脫重複的不變行為的糾纏。

三、Strategy模式和Template Method模式的比較：

1. Strategy模式

• 定義一系列的演算法,把它們一個個封裝起來, 並且使它們可相互替換。本模式使得演算法的變化可獨立於使用它的客戶。
• 使用委託來改變整個演算法。

2. Template Method模式

• 定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。Template Method使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。
• 使用繼承來改變演算法的一部分。