商城促销的案例

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来承担，这样就最大化的减轻了客户端的职责