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

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

UML圖：

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

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

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

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

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

策略模式的優點是簡化了單元測試，因為每個算法都有自己的類，可以通過自己的接口單獨測試。

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

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

代碼如下：

Strategy.h

#ifndef _STRATEGY_H_
#define _STRATEGY_H_

class Strategy
{
public:
    ~Strategy();
    virtual void AlgrithmInterface()=0;
protected:
    Strategy();
private:
};

class ConcreteStrategyA : public Strategy
{
public:
    ConcreteStrategyA();
    ~ConcreteStrategyA();
    virtual void AlgrithmInterface();
protected:
private:
};

class ConcreteStrategyB : public Strategy
{
public:
    ConcreteStrategyB();
    ~ConcreteStrategyB();
    virtual void AlgrithmInterface();
protected:
private:
};

/*這個類是Strategy模式的關鍵，
  也是Strategy模式和Template模式的根本區別所在。
  *Strategy通過“組合”（委托）方式實現算法（實現）的異構，
  而Template模式則采取的是繼承的方式
  這兩個模式的區別也是繼承和組合兩種實現接口重用的方式的區別
*/
class Context
{
public:
    Context(Strategy*);
    ~Context();
    void DoAction();
private:
    Strategy* _strategy;
};
#endif

Strategy.cpp

#include "Strategy.h"
#include "iostream"

using namespace std;

Strategy::Strategy()
{}

Strategy::~Strategy()
{}

ConcreteStrategyA::ConcreteStrategyA()
{}

ConcreteStrategyA::~ConcreteStrategyA()
{}

void ConcreteStrategyA::AlgrithmInterface()
{
    cout << "ConcreteStrategyA::AlgrithmInterface" << endl;
}

ConcreteStrategyB::ConcreteStrategyB()
{}

ConcreteStrategyB::~ConcreteStrategyB()
{}

void ConcreteStrategyB::AlgrithmInterface()
{
    cout << "ConcreteStrategyB::AlgrithmInterface" << endl;
}

Context::Context(Strategy* strategy)
{
    this->_strategy = strategy;
}

Context::~Context()
{
    delete this->_strategy;
}

void Context::DoAction()
{
    this->_strategy->AlgrithmInterface();
}

main.cpp

#include "Strategy.h"

int main()
{
    /*
    Strategy模式和Template模式實際是實現一個抽象接口的兩種方式：繼承和組合之間的區別。
    要實現一個抽象接口，繼承是一種方式：我們將抽象接口聲明在基類中，將具體的實現放在具體子類中。
    組合（委托）是另外一種方式：我們將接口的實現放在被組合對象中，將抽象接口放在組合類中。
    這兩種方式各有優缺點
    */
    //策略A與B可替換
    Strategy* pStr = new ConcreteStrategyA();
    Context* pcon = new Context(pStr);
    pcon->DoAction();

    pStr = new ConcreteStrategyB();
    pcon = new Context(pStr);
    pcon->DoAction();

    return 0;
}