天天看點
傳回

别隻知道政策模式+簡單工廠，試試更香的政策模式+抽象工廠！

政策模式

在GOF的《設計模式:可複用面向對象軟體的基礎》一書中對政策模式是這樣說的：

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

政策模式為了适應不同的需求，隻把變化點封裝了，這個變化點就是實作不同需求的算法，例如加班工資，不同的加班情況，有不同的計算加班工資的方法。

我們不能在程式中将計算工資的算法進行寫死，而能夠***變化。

這就是政策模式。

别隻知道政策模式+簡單工廠，試試更香的政策模式+抽象工廠！
别隻知道政策模式+簡單工廠，試試更香的政策模式+抽象工廠！

實驗1 政策模式+簡單工廠

代碼

#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(int x, int y) = 0;
    virtual ~Strategy() = 0; 
};

Strategy::~Strategy()
{}

class ConcreteStrategyA : public Strategy
{
public:
    void AlgorithmInterface(int x, int y)
    {
        cout << "I am from ConcreteStrategyA: result=X+Y, = " << x+y << endl;
    }

    ~ConcreteStrategyA(){
        cout << "~ConcreteStrategyA()." << endl;
    }
};

class ConcreteStrategyB : public Strategy
{
public:
    void AlgorithmInterface(int x, int y)
    {
        cout << "I am from ConcreteStrategyB: result=X*Y, = " << x*y << endl;
    }

    ~ConcreteStrategyB(){
        cout << "~ConcreteStrategyB()." << endl;
    }
};

class ConcreteStrategyC : public Strategy
{
public:
    void AlgorithmInterface(int x, int y)
    {
        cout << "I am from ConcreteStrategyC: result=X-Y, = " << x-y << endl;
    }

    ~ConcreteStrategyC(){
        cout << "~ConcreteStrategyC()." << endl;
    }
};

// 使用者類 ： 使用算法的使用者
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(int x, int y) // 定義一個接口來讓Stategy通路使用者的資料
    {
        if (pStrategy)
            pStrategy->AlgorithmInterface(x, y);
    }

private:
    Strategy *pStrategy; // 維護一個對Stategy對象的引用或指針
    int a;               // 私有資料,這是使用者資料,該使用者是獨立于算法的使用者,使用者不需要了解算法内部的資料結構
    int b;
};

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

    if (pContext) 
        delete pContext;
}

上述的例子是政策模式，我們還能看到一點簡單工廠模式的影子。

百度到的絕大多數都是這種例子了。 這個代碼完美嗎？看下GoF的要領：

别隻知道政策模式+簡單工廠，試試更香的政策模式+抽象工廠！

如果我們需要新增新的算法，我們需要修改Context類的構造函數，在裡面新增新的算法，這顯然不符合GoF采用擴充、子類化的精要。

是以引出了我下面的政策模式+抽象工廠的解決方案。

實驗2 政策模式+抽象工廠

代碼

#include <iostream>
using namespace std;


// The abstract strategy
class Strategy
{
public:
    virtual void AlgorithmInterface(int x, int y) = 0;
    virtual ~Strategy() = 0; 
};

Strategy::~Strategy()
{}

class ConcreteStrategyA : public Strategy
{
public:
    void AlgorithmInterface(int x, int y)
    {
        cout << "I am from ConcreteStrategyA: result=X+Y, = " << x+y << endl;
    }

    ~ConcreteStrategyA(){
        cout << "~ConcreteStrategyA().析夠" << endl;
    }
};

class ConcreteStrategyB : public Strategy
{
public:
    void AlgorithmInterface(int x, int y)
    {
        cout << "I am from ConcreteStrategyB: result=X*Y, = " << x*y << endl;
    }

    ~ConcreteStrategyB(){
        cout << "~ConcreteStrategyB().析夠" << endl;
    }
};

class ConcreteStrategyC : public Strategy
{
public:
    void AlgorithmInterface(int x, int y)
    {
        cout << "I am from ConcreteStrategyC: result=X-Y, = " << x-y << endl;
    }

    ~ConcreteStrategyC(){
        cout << "~ConcreteStrategyC().析夠" << endl;
    }
};

// 使用者類 ： 使用算法的使用者
class Context
{
public:
    // 該構造函數内使用簡單工廠模式
    Context(Strategy* paraStrategy)
    {
        pStrategy = paraStrategy;
    }

    ~Context()
    {
        // 這裡不需要析夠pStrategy， pStrategy對應對象的析夠會在delete pAbstractStrategyFactory時進行。
        // 即，銷毀具體某個政策工廠對象時會負責析夠具體的政策對象。是以這裡就不需要了。
    }

    void ContextInterface(int x, int y) // 定義一個接口來讓Stategy通路使用者的資料
    {
        if (pStrategy)
            pStrategy->AlgorithmInterface(x, y);
    }

private:
    Strategy *pStrategy; // 維護一個對Stategy對象的引用或指針
    int a;               // 私有資料,這是使用者資料,該使用者是獨立于算法的使用者,使用者不需要了解算法内部的資料結構
    int b;
};



// 點評shape類： 一條産品線下的産品，通常存在共性，
// 也就是說，一個産品抽象類通常是需要的，而不是必須的。   

class AbstractStrategyFactory   // 抽象工廠這裡可以實作多個純虛方法
{
public:
    virtual Strategy* createStrategy(string Strategy)=0;
    virtual ~AbstractStrategyFactory(){}
};
  
class StrategyA_Factory:public AbstractStrategyFactory
{
Strategy *pStrategy;
public:
    StrategyA_Factory():pStrategy(NULL)
    {}
    Strategy* createStrategy(string Strategy)
    {
        if(Strategy == "StrategyA"){
            pStrategy = new ConcreteStrategyA();
            return pStrategy;
        }
        return NULL;
    }
    ~StrategyA_Factory()
    {
        cout << "~StrategyA_Factory(). 析夠" << endl;
        if(pStrategy)
            delete pStrategy;
    }
};

class StrategyB_Factory:public AbstractStrategyFactory
{
Strategy *pStrategy;
public:
    StrategyB_Factory():pStrategy(NULL)
    {}
    Strategy* createStrategy(string Strategy)
    {
        if(Strategy == "StrategyB"){
            pStrategy = new ConcreteStrategyB();
            return pStrategy;
        }
        return NULL;
    }
    ~StrategyB_Factory()
    {
        if(pStrategy)
            delete pStrategy;
    }
};

class StrategyC_Factory:public AbstractStrategyFactory
{
Strategy *pStrategy;
public:
    StrategyC_Factory():pStrategy(NULL)
    {}
    Strategy* createStrategy(string Strategy)
    {
        if(Strategy == "StrategyC"){
            pStrategy = new ConcreteStrategyC();
            return pStrategy;
        }
        return NULL;
    }
    ~StrategyC_Factory()
    {
         if(pStrategy)
            delete pStrategy;       
    }
};

int main(int argc, char *argv[])
{
    AbstractStrategyFactory* pAbstractStrategyFactory;  // 建立抽象工廠指針
 
    pAbstractStrategyFactory = new StrategyA_Factory();       // 建立政策A的工廠
    Strategy* pStrategy = pAbstractStrategyFactory->createStrategy("StrategyA");  //使用政策A工廠來生産出政策A
    if(pStrategy == NULL)
    {
        cout << "pStrategy is NULL" << endl;
    }
    else
    {
    // 供使用者來使用政策A : 使用者使用政策A 和 政策A的實作，是松耦合的。
    Context *pContext = new Context(pStrategy);
    pContext->ContextInterface(100, 6);

    delete pAbstractStrategyFactory;

    if (pContext) 
        delete pContext;
    }

    return 0;
  
}

編譯運作：

别隻知道政策模式+簡單工廠，試試更香的政策模式+抽象工廠！

此時，如果要新增算法，那我覺得可以采用擴充、子類化的解決方案了，而不用像本博文上一個例子那樣，去修改已有的代碼了。

當然，這樣的設計會導緻代碼量變大，是以一切都需要權衡，适合自己的就是最好的。

.

Linux系統程式設計政策模式設計模式
上一篇: 【除了Gore-Tex，還有哪些防水面料值得購買？】在戶外，有一家面料商的名字可謂比一些品牌更響，尤其是沖鋒衣，标有GO
下一篇: 7.15日測試總結