策略模式（c++实现）

策略模式

策略模式(Startegy)：它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

优点：

1. 策略模式的strategy类层次为Context定义了一系列可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。

2. 简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

广义作用：

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

与简单工厂模式结合：

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。这个本身并没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context承担，这就是最大化的减轻了客户端的职责。任何需求的变更都是需要成本的。

UML类图如下：

代码如下：

strategy.h

class Strategy
{
public:
    Strategy();
    virtual ~Strategy();

   virtual double getResult(double price) {return 0;};
};

context.h

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

class Context
{
public:
    Context(std::string strName);

    double getResult(double cash);
private:
    Strategy*   m_Strategy;
};

context.cpp

#include "context.h"
#include "Common.h"
Context::Context(std::string strName)
{
    if ("dis" == strName) {
        m_Strategy = new CashRebate(0.8);
    }
    else if("return" == strName)
    {
        m_Strategy = new CashReturn(200, 100);
    }else if("nor" == strName)
    {
        m_Strategy = new CashNormal();
    }
}

double Context::getResult(double cash)
{
    if(m_Strategy)
        return m_Strategy->getResult(cash);
}

common.h

#include "strategy.h"
#include "cashnormal.h"
#include "cashrebate.h"
#include "cashreturn.h"

cashnormal.h

#include "strategy.h"
class CashNormal : public Strategy
{
public:
    CashNormal();
    double getResult(double price) override;
};

cashnormal.cpp

#include "cashnormal.h"
#include <assert.h>

CashNormal::CashNormal()
{

}

double CashNormal::getResult(double price)
{
    assert(price > 0);
    return price;
}

cashrebate.h

#include "strategy.h"

class CashRebate : public Strategy
{
public:
    CashRebate(double rebate);
    double getResult(double price) override;

private:
    double       m_Rebate;
};

cashrebate.cpp

#include "cashrebate.h"
#include <assert.h>

CashRebate::CashRebate(double rebate)
: m_Rebate(rebate)
{

}

double CashRebate::getResult(double price)
{
    assert(price > 0);
    return price * m_Rebate;
}

cashreturn.h

#include "strategy.h"

class CashReturn : public Strategy
{
public:
    CashReturn(double condition, double returnNum);
    double getResult(double price) override;

private:
    double m_Condition;
    double  m_RetunNum;
};

cashreturn.cpp

#include "cashreturn.h"

CashReturn::CashReturn(double condition, double returnNum)
    :m_Condition(condition), m_RetunNum(returnNum)
{

}

double CashReturn::getResult(double price)
{
    if(price >= m_Condition)
        return price - m_RetunNum;
    else
        return price;
}

main.cpp

#include <iostream>
#include <iostream>
#include <memory>
#include "context.h"
using namespace std;
int main()
{
    std::string input;
    std::cout << "select promotions:" << std::endl;
    std::cin >> input;

    Context cn(input);
    double res = cn.getResult(1000);
    std::cout << "result is :" << res << std::endl;

    return 0;
}

main函数里面通过输入来选择优惠的策略，context类通过输入使用简单工厂模式创建对应的类。总体感觉策略模式跟工厂模式差不多~