C++設計模式-Strategy策略模式

Strategy策略模式
做用：定義了算法家族，分別封裝起來，讓他們之間能夠互相替換，此模式讓算法的變化，不會影響到使用算法的客戶。

UML圖：

Strategy模式將邏輯（算法）封裝到一個類（Context）裏面，經過組合的方式將具體算法的實如今組合對象中實現，再經過委託的方式將抽象接口的實現委託給組合對象實現

將算法的邏輯抽象接口（DoAction）封裝到一個類中（Context），再經過委託的方式將具體的算法實現委託給具體的Strategy類來實現（ConcreteStrategeA類）

Stragegy類，定義全部支持的算法的公共接口
ConcreteStrategy，封裝了具體的算法或行爲，繼承於Strategy
Context，用一個ConcreteStrategy來配置，維護一個對Strategy對象的引用

策略模式是一種定義一系列算法的方法，從概念上來看，全部這些算法完成的都是相同的工做，只是實現不一樣，它能夠以相同的方式調用全部的算法，減小了各類算法類於使用算法類之間的耦合。

策略模式的Strategy類層次爲Context定義了一系列的可供重用的算法或行爲。繼承有助於析取出這些算法中的公共功能。

策略模式的優勢是簡化了單元測試，由於每一個算法都有本身的類，能夠經過本身的接口單獨測試。

策略模式就是用來封裝算法的，但在實踐中，咱們發現能夠用它來封裝幾乎任何類型的規則，只要在分析過程當中聽到須要在不一樣時間應用不一樣的業務規則，就能夠考慮使用策略模式處理這種變化的可能性。

在基本的策略模式中，選擇所用具體實現的職責由客戶端對象承擔，並轉給策略模式的Context對象。這自己並無解除客戶端須要選擇判斷的壓力。

代碼以下：

Strategy.h

 1 #ifndef _STRATEGY_H_
 2 #define _STRATEGY_H_
 3 
 4 class Strategy
 5 {
 6 public:
 7     ~Strategy();
 8     virtual void AlgrithmInterface()=0;
 9 protected:
10     Strategy();
11 private:
12 };
13 
14 class ConcreteStrategyA : public Strategy
15 {
16 public:
17     ConcreteStrategyA();
18     ~ConcreteStrategyA();
19     virtual void AlgrithmInterface();
20 protected:
21 private:
22 };
23 
24 class ConcreteStrategyB : public Strategy
25 {
26 public:
27     ConcreteStrategyB();
28     ~ConcreteStrategyB();
29     virtual void AlgrithmInterface();
30 protected:
31 private:
32 };
33 
34 /*這個類是Strategy模式的關鍵，
35   也是Strategy模式和Template模式的根本區別所在。
36   *Strategy經過「組合」（委託）方式實現算法（實現）的異構，
37   而Template模式則採起的是繼承的方式
38   這兩個模式的區別也是繼承和組合兩種實現接口重用的方式的區別
39 */
40 class Context
41 {
42 public:
43     Context(Strategy*);
44     ~Context();
45     void DoAction();
46 private:
47     Strategy* _strategy;
48 };
49 #endif

Strategy.cpp

 1 #include "Strategy.h"
 2 #include "iostream"
 3 
 4 using namespace std;
 5 
 6 Strategy::Strategy()
 7 {}
 8 
 9 Strategy::~Strategy()
10 {}
11 
12 ConcreteStrategyA::ConcreteStrategyA()
13 {}
14 
15 ConcreteStrategyA::~ConcreteStrategyA()
16 {}
17 
18 void ConcreteStrategyA::AlgrithmInterface()
19 {
20     cout << "ConcreteStrategyA::AlgrithmInterface" << endl;
21 }
22 
23 ConcreteStrategyB::ConcreteStrategyB()
24 {}
25 
26 ConcreteStrategyB::~ConcreteStrategyB()
27 {}
28 
29 void ConcreteStrategyB::AlgrithmInterface()
30 {
31     cout << "ConcreteStrategyB::AlgrithmInterface" << endl;
32 }
33 
34 Context::Context(Strategy* strategy)
35 {
36     this->_strategy = strategy;
37 }
38 
39 Context::~Context()
40 {
41     delete this->_strategy;
42 }
43 
44 void Context::DoAction()
45 {
46     this->_strategy->AlgrithmInterface();
47 }

main.cpp

 1 #include "Strategy.h"
 2 
 3 int main()
 4 {
 5     /*
 6     Strategy模式和Template模式實際是實現一個抽象接口的兩種方式：繼承和組合之間的區別。
 7     要實現一個抽象接口，繼承是一種方式：咱們將抽象接口聲明在基類中，將具體的實現放在具體子類中。
 8     組合（委託）是另一種方式：咱們將接口的實現放在被組合對象中，將抽象接口放在組合類中。
 9     這兩種方式各有優缺點
10     */
11     //策略A與B可替換
12     Strategy* pStr = new ConcreteStrategyA();
13     Context* pcon = new Context(pStr);
14     pcon->DoAction();
15 
16     pStr = new ConcreteStrategyB();
17     pcon = new Context(pStr);
18     pcon->DoAction();
19 
20     return 0;
21 }