Strategy 策略模式

意圖

定義一系列的算法,把它們一個個封裝起來, 并且使它們可相互替換。本模式使得算法可獨立于使用它的客戶而變化。

動機

策略模式為了適應不同的需求，只把變化點封裝了，這個變化點就是實現不同需求的算法，但是，用戶需要知道各種算法的具體情況。就像上面的加班工資，不同的加班情況，有不同的算法。我們不能在程序中將計算工資的算法進行硬編碼，而是能自由的變化的。這就是策略模式。

剛剛加班回來；哎，公司規定平時加班只有10塊錢的餐補；星期六和星期天加班，只給串休假；在國家規定的節假日按照3倍工資發放。那么對于這么多的計算加班費的方法，公司的OA系統是如何進行做的呢？各種計算加班費的情況就可以認為是策略模式

適用性

• 許多相關的類僅僅是行為有異。 “策略”提供了一種用多個行為中的一個行為來配置一個類的方法。
• 需要使用一個算法的不同變體。例如，你可能會定義一些反映不同的空間 /時間權衡的算法。當這些變體實現為一個算法的類層次時,可以使用策略模式
• 算法使用客戶不應該知道的數據。可使用策略模式以避免暴露復雜的、與算法相關的數據結構。
• 一個類定義了多種行為 , 并且這些行為在這個類的操作中以多個條件語句的形式出現。將相關的條件分支移入它們各自的Strategy類中以代替這些條件語句。

結構

?

參與者

Strategy：定義所有支持的算法的公共接口。Context使用這個接口來調用某ConcreteStrategy定義的算法；
ConcreteStrategy：實現Strategy接口的具體算法；
Context：使用一個ConcreteStrategy對象來配置；維護一個對Stategy對象的引用，同時，可以定義一個接口來讓Stategy訪問它的數據。

效果

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

實現

純策略模式，實際上就是父類為純虛函數，子類根據需求實現各種方法

#include <iostream>
using namespace std;

// The abstract strategy
class Strategy
{
public:
     virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy
{
public:
     void AlgorithmInterface()
     {
          cout<<"I am from ConcreteStrategyA."<<endl;
     }
};

class ConcreteStrategyB : public Strategy
{
public:
     void AlgorithmInterface()
     {
          cout<<"I am from ConcreteStrategyB."<<endl;
     }
};

class ConcreteStrategyC : public Strategy
{
public:
     void AlgorithmInterface()
     {
          cout<<"I am from ConcreteStrategyC."<<endl;
     }
};

class Context
{
public:
     Context(Strategy *pStrategyArg) : pStrategy(pStrategyArg)
     {
     }
     void ContextInterface()
     {
          pStrategy->AlgorithmInterface();
     }
private:
     Strategy *pStrategy;
};

int main()
{
     // Create the Strategy
     Strategy *pStrategyA = new ConcreteStrategyA;
     Strategy *pStrategyB = new ConcreteStrategyB;
     Strategy *pStrategyC = new ConcreteStrategyC;
     Context *pContextA = new Context(pStrategyA);
     Context *pContextB = new Context(pStrategyB);
     Context *pContextC = new Context(pStrategyC);
     pContextA->ContextInterface();
     pContextB->ContextInterface();
     pContextC->ContextInterface();

     if (pStrategyA) delete pStrategyA;
     if (pStrategyB) delete pStrategyB;
     if (pStrategyC) delete pStrategyC;

     if (pContextA) delete pContextA;
     if (pContextB) delete pContextB;
     if (pContextC) delete pContextC;
}

在實際操作的過程中，我們會發現，在main函數中，也就是在客戶端使用策略模式時，會創建非常多的Strategy，而這樣就莫名的增加了客戶端的壓力，讓客戶端的復雜度陡然增加了。那么，我們就可以借鑒簡單工廠模式，使策略模式和簡單工廠模式相結合，從而減輕客戶端的壓力，代碼實現如下：

#include <iostream>
using namespace std;

// Define the strategy type
typedef enum StrategyType
{
    StrategyA,
    StrategyB,
    StrategyC
}STRATEGYTYPE;

// The abstract strategy
class Strategy
{
public:
    virtual void AlgorithmInterface() = 0;
    virtual ~Strategy() = 0; // 謝謝hellowei提出的bug，具體可以參見評論
};

Strategy::~Strategy()
{}

class ConcreteStrategyA : public Strategy
{
public:
    void AlgorithmInterface()
    {
        cout << "I am from ConcreteStrategyA." << endl;
    }

    ~ConcreteStrategyA(){}
};

class ConcreteStrategyB : public Strategy
{
public:
    void AlgorithmInterface()
    {
        cout << "I am from ConcreteStrategyB." << endl;
    }

    ~ConcreteStrategyB(){}
};

class ConcreteStrategyC : public Strategy
{
public:
    void AlgorithmInterface()
    {
        cout << "I am from ConcreteStrategyC." << endl;
    }

    ~ConcreteStrategyC(){}
};

class Context
{
public:
    Context(STRATEGYTYPE strategyType)
    {
        switch (strategyType)
        {
        case StrategyA:
            pStrategy = new ConcreteStrategyA;
            break;

        case StrategyB:
            pStrategy = new ConcreteStrategyB;
            break;

        case StrategyC:
            pStrategy = new ConcreteStrategyC;
            break;

        default:
            break;
        }
    }

    ~Context()
    {
        if (pStrategy) delete pStrategy;
    }

    void ContextInterface()
    {
        if (pStrategy)
            pStrategy->AlgorithmInterface();
    }

private:
    Strategy *pStrategy;
};

int main()
{
    Context *pContext = new Context(StrategyA);
    pContext->ContextInterface();

    if (pContext) delete pContext;
}

?