文章目錄

• 商城促銷的案例
• 單純策略模式程式碼舉例
• strategy.h
• strategy.cpp
• main.cpp
• 策略模式+簡單工廠模式程式碼舉例
• strategy.h
• strategy.cpp
• main.cpp

商城促銷的案例

1.簡單工廠模式實現

簡單工廠模式我需要讓客戶端認識兩個類，CashSuper和CashFactory

2.策略模式+簡單工廠模式實現

而策略模式我只需要給客戶端暴露CashContext類即可，耦合更加降低了，

單純策略模式程式碼舉例

strategy.h

#ifndef STRATEGY_H
#define STRATEGY_H

class Strategy
{
public:
    Strategy();
    virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA:public Strategy
{
public:
    ConcreteStrategyA() {}
    void AlgorithmInterface();
};

class ConcreteStrategyB:public Strategy
{
public:
    ConcreteStrategyB() {}
    void AlgorithmInterface();
};

class ConcreteStrategyC:public Strategy
{
public:
    ConcreteStrategyC() {}
    void AlgorithmInterface();
};

class Context
{
public:
    Context(Strategy *strategy);
    Strategy *strategy;
    void ContextInterface();
};
#endif // STRATEGY_H
 

strategy.cpp

#include "strategy.h"
#include <iostream>
using namespace std;

Strategy::Strategy()
{

}

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

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

void ConcreteStrategyC::AlgorithmInterface()
{
    cout<<"AlgorithmInterface of ConcreteStrategyC"<<endl;
}

//初始化的時候傳入具體的策略物件
Context::Context(Strategy *strategy)
{
    this->strategy = strategy;
}

//再根據具體的策略物件來呼叫其演算法介面
void Context::ContextInterface()
{
    this->strategy->AlgorithmInterface();
}
 

main.cpp

#include <iostream>
#include "strategy.h"

using namespace std;

int main()
{
    Context contextA(new ConcreteStrategyA());
    contextA.ContextInterface();

    Context contextB(new ConcreteStrategyB());
    contextB.ContextInterface();

    Context contextC(new ConcreteStrategyC());
    contextC.ContextInterface();

    return 0;
}

策略模式+簡單工廠模式程式碼舉例

strategy.h

#ifndef STRATEGY_H
#define STRATEGY_H

enum AlgorithmMode
{
    ALGORITHMA,
    ALGORITHMB,
    ALGORITHMC,
};


class Strategy
{
public:
    Strategy();
    virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA:public Strategy
{
public:
    ConcreteStrategyA() {}
    void AlgorithmInterface();
};

class ConcreteStrategyB:public Strategy
{
public:
    ConcreteStrategyB() {}
    void AlgorithmInterface();
};

class ConcreteStrategyC:public Strategy
{
public:
    ConcreteStrategyC() {}
    void AlgorithmInterface();
};

class Context
{
public:
    Context(Strategy *strategy);//策略模式
    Context(int AlgorithmMode);//策略模式+簡單工廠模式
    Strategy *strategy;
    void ContextInterface();
};
#endif // STRATEGY_H

strategy.cpp

#include "strategy.h"
#include <iostream>
using namespace std;

Strategy::Strategy()
{

}

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

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

void ConcreteStrategyC::AlgorithmInterface()
{
    cout<<"AlgorithmInterface of ConcreteStrategyC"<<endl;
}


//策略模式：初始化的時候傳入具體的策略物件
Context::Context(Strategy *strategy)
{
    this->strategy = strategy;
}

//簡單工廠模式：封裝了物件的建立的介面
Context::Context(int AlgorithmMode)
{
    switch (AlgorithmMode) {
    case ALGORITHMA:
        this->strategy = new ConcreteStrategyA();
        break;

    case ALGORITHMB:
        this->strategy = new ConcreteStrategyB();
        break;

    case ALGORITHMC:
        this->strategy = new ConcreteStrategyC();
        break;

    default:
        this->strategy = nullptr;
        break;
    }
}

//再根據具體的策略物件來呼叫其演算法介面
void Context::ContextInterface()
{
    this->strategy->AlgorithmInterface();
}

main.cpp

#include <iostream>
#include "strategy.h"

using namespace std;

int main()
{
    /***************策略模式**************/
    Context contextA(new ConcreteStrategyA());
    contextA.ContextInterface();

    Context contextB(new ConcreteStrategyB());
    contextB.ContextInterface();

    Context contextC(new ConcreteStrategyC());
    contextC.ContextInterface();

    /***********策略模式+工廠模式**********/
    Context contextA1(ALGORITHMA);
    contextA1.ContextInterface();

    Context contextB1(ALGORITHMB);
    contextB1.ContextInterface();

    Context contextC1(ALGORITHMC);
    contextC1.ContextInterface();

    return 0;
}

上述程式碼顯示策略模式+工廠模式，客戶端只要管理一個類：Context即可，呼叫的ContextInterface(),這樣就徹底把演算法和客戶端分離出來了，耦合度更低

策略模式就是用來封裝演算法的，但在實踐中，我們發現可以用來封裝幾乎任何型別的規則，只要在分析的過程中聽到：需要在不同的時間對應不同的業務規則，就可以考慮用策略模式處理這種變化的可能性，但是在基本的策略模式中，選擇所用的具體實現的職責由客戶端物件承擔，並轉給策略模式的Context物件，這本身並沒有解除客戶端需要判斷的壓力，而策略模式+簡單工廠模式後，選擇具體實現的職責可以由Context來承擔，這樣就最大化的減輕了客戶端的職責