002 --- 第2章 策略模式

简述：

　　策略模式定义了算法家族，分别封装起来，让他们之间可以互相替换，此设计模式让算法的变化，不会影响到使用算法的客户。

　　策略模式包括：抽象策略类、具体策略类、上下文类。

　　　　抽象策略类：定义所有支持的算法的公共接口。

　　　　具体策略类：继承自抽象策略类，封装了具体的算法活行为。

　　　　上下文类：用一个具体策略类的指针对象来配置一个对抽象策略类的指针。

　　策略模式可以结合简单工厂模式一起使用，设计模式的组合配搭，可根据具体需求自如运用。

应用场景：策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式来处理这种变化的可能性

 

注：开发环境调整为VS2017，操作系统win11

策略模式代码：

#include <iostream>
using namespace std;

// 策略模式
// 抽象策略类：定义所有支持的算法的公共接口
class CStrategy
{
public:
    virtual void AlgorithmInterface() = 0;
};

// 具体策略类A：封装了具体的算法或行为
class CConcreteStrategyA : public CStrategy
{
public:
    virtual void AlgorithmInterface()
    {
        cout << "算法A实现" << endl;
    }
};

// 具体策略类B：封装了具体的算法或行为
class CConcreteStrategyB : public CStrategy
{
public:
    virtual void AlgorithmInterface()
    {
        cout << "算法B实现" << endl;
    }
};

// 具体策略类C：封装了具体的算法或行为
class CConcreteStrategyC : public CStrategy
{
public:
    virtual void AlgorithmInterface()
    {
        cout << "算法C实现" << endl;
    }
};

// 上下文类：用一个具体策略类的指针对象来配置一个对抽象策略类的指针
class CContext
{
private:
    CStrategy* m_pStrategy;

public:
    CContext(CStrategy* pStrategy)
    {
        m_pStrategy = pStrategy;
    }

    ~CContext()
    {
        if (m_pStrategy)
        {
            delete m_pStrategy;
            m_pStrategy = NULL;
        }
    }

    void ContextInterface()
    {
        m_pStrategy->AlgorithmInterface();
    }
};

int main()
{
    CContext Context1(new CConcreteStrategyA());
    Context1.ContextInterface();

    CContext Context2(new CConcreteStrategyB());
    Context2.ContextInterface();

    CContext Context3(new CConcreteStrategyC());
    Context3.ContextInterface();

    system("pause");
    return 0;
}

 

输出结果：

 

例：商场打折促销手段分类（策略模式与工厂模式结合使用）

代码如下：

#include <iostream>
using namespace std;

// 收费基类(抽象策略类)
class CCashSuper
{
public:
    virtual double AcceptCash(double dMoney)
    {
        return dMoney;
    }
};

// 正常收费子类(具体策略类)
class CCashNormal : public CCashSuper
{
public:
    virtual double AcceptCash(double dMoney)
    {
        return dMoney;
    }
};

// 打折收费子类(具体策略类)
class CCashRebate : public CCashSuper
{
private:
    double m_dMoneyRebate;

public:
    CCashRebate(double dMoneyRebate)
    {
        m_dMoneyRebate = dMoneyRebate;
    }

    virtual double AcceptCash(double dMoney)
    {
        return dMoney * m_dMoneyRebate;
    }
};

// 返利收费子类(具体策略类)
class CCashReturn : public CCashSuper
{
private:
    double m_dMoneyCondition;
    double m_dMoneyReturn;

public:
    CCashReturn(double dMoneyCondition, double dMoneyReturn)
    {
        m_dMoneyCondition = dMoneyCondition;
        m_dMoneyReturn = dMoneyReturn;
    }

    virtual double AcceptCash(double dMoney)
    {
        double dResult = dMoney;
        if (dMoney >= m_dMoneyCondition)
            dResult = dMoney - ((int)dMoney / (int)m_dMoneyCondition) * m_dMoneyReturn;

        return dResult;
    }
};

// 上下文类与简单工厂模式结合
enum TYPE { NORMAL, REBATE, RETURN };
class CCashContext
{
private:
    CCashSuper* m_pCashSuper;

public:
    CCashContext(int nType) : m_pCashSuper(NULL)
    {
        switch (nType)
        {
        case NORMAL:
            {
                CCashNormal* pCashNormal = new CCashNormal();
                m_pCashSuper = pCashNormal;
            }
            break;
        case REBATE:
            {
                CCashRebate* pCashRebate = new CCashRebate(0.8);
                m_pCashSuper = pCashRebate;
            }
            break;
        case RETURN:
            {
                CCashReturn* pCashReturn = new CCashReturn(300, 100);
                m_pCashSuper = pCashReturn;
            }
            break;
        }
    }

    ~CCashContext()
    {
        if (m_pCashSuper)
        {
            delete m_pCashSuper;
            m_pCashSuper = NULL;
        }
    }

    double GetResult(double dMoney)
    {
        return m_pCashSuper->AcceptCash(dMoney);
    }
};


int main()
{
    double dTotal = 0;
    int nType = REBATE;
    CCashContext CashContext(nType);

    double dTotalPrices = 0;
    double dPrice = 200;
    int nCount = 3;
    dTotalPrices = CashContext.GetResult(dPrice * nCount);
    dTotal = dTotal + dTotalPrices;
    cout << "单价：[" << dPrice << "]  "
        << "数量：[" << nCount << "]  "
        << "打折：[" << nType << "]  "
        << "合计：[" << dTotal << "]  " << endl;

    system("pause");
    return 0;
}

 

输出结果：