策略模式（Strategy）

简介

策略模式是指定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。也就是说这些算法所完成的功能一样，对外的接口一样，只是各自实现上存在差异。
策略模式把对象本身和运算规则区分开来，其功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性的思想。

优缺点

1、策略模式的优点
（1）策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，他可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
（2）策略模式的Strategy类曾是为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。
（3）策略模式简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
（4）策略模式就是用来封装算法的。
（5）只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。
（6）简单工厂模式需要让客户端认识两个类，而策略模式和简单工厂模式结合的用法，客户端只需要认识一个类Context即可。
2、策略模式的缺点
（1）客户端必须知道所有的策略类，并自行决定使用哪一个策略类: 本模式有一个潜在的缺点，就是一个客户要选择一个合适的Strategy就必须知道这些Strategy到底有何不同。此时可能不得不向客户暴露具体的实现问题。因此仅当这些不同行为变体与客户相关的行为时 , 才需要使用Strategy模式。
（2）Strategy和Context之间的通信开销 ：无论各个ConcreteStrategy实现的算法是简单还是复杂, 它们都共享Strategy定义的接口。因此很可能某些 ConcreteStrategy不会都用到所有通过这个接口传递给它们的信息；简单的 ConcreteStrategy可能不使用其中的任何信息！这就意味着有时Context会创建和初始化一些永远不会用到的参数。如果存在这样问题 , 那么将需要在Strategy和Context之间更进行紧密的耦合。
（3）策略模式将造成产生很多策略类：可以通过使用享元模式在一定程度上减少对象的数量。 增加了对象的数目 Strategy增加了一个应用中的对象的数目。有时你可以将 Strategy实现为可供各Context共享的无状态的对象来减少这一开销。任何其余的状态都由 Context维护。Context在每一次对Strategy对象的请求中都将这个状态传递过去。共享的 Strategy不应在各次调用之间维护状态。

使用场景及注意事项

• 当一组算法对应一个任务，并且程序可以在运行时灵活的选择其中一个算法，策略模式是很好的选择。
• 需要安全的封装平等的多种不同类型操作
• 当同一抽象类拥有很多具体子类时且程序运行的时候需要动态决定使用哪一具体类时
• 策略模式的重心不是如何实现算法，而是关注如何组织、调用这些算法，从而让程序结构更灵活，具有更好的维护性和扩展性。
• 策略模式中各个策略算法的平等性。对于一系列具体的策略算法，大家的地位是完全一样的，正因为这个平等性，才能实现算法之间可以相互替换。所有的策略算法在实现上也是相互独立的，相互之间是没有依赖的。
• 运行时策略的互斥性，策略模式在运行的每一个时刻只能使用这组被封装算法中的某一个，虽然可以动态地在不同的策略实现中切换，但是同时只能使用一个。
• 策略的抽象实现，当所有的具体策略类都有一些公有的行为。此时根据设计原则应把这些公有的行为放到共同的抽象策略角色Strategy类里面。
  

代码实现

#include <iostream>
#include <string>
#include <cmath>
#include <memory>
 
//父类抽象类
class CashSuper
{
public:
    virtual double acceptCash(double) = 0;
    virtual ~CashSuper() = default;
};
 
//子类：正常付费类型
class CashNormal:public CashSuper
{
public:
    double acceptCash(double money)
    {
        return money;
    }
};
 
//子类：返现类型
class CashReturn:public CashSuper
{
private:
    double moneyCondition;
    double moneyReturn;
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result=money;
        if(money>moneyCondition)
            result=money - std::floor(money/moneyCondition)*moneyReturn;
        return result;
    }
};
 
//子类：打折扣类型
class CashRebate:public CashSuper
{
private:
    double moneyRebate;
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
        return money*moneyRebate;
    }
};
 
enum SellStrategy
{
    normal,
    returnMoney,
    rebate
};
class CashContext
{
private:
    std::unique_ptr<CashSuper> cs;
public:
    CashContext(int type)
    {
        switch(type)
        {
        case SellStrategy::normal:
            {
                cs = std::make_unique<CashNormal>();
                break;
            }
        case SellStrategy::returnMoney:
            {
                cs = std::make_unique<CashReturn>(300,100);
                break;
            }
        case SellStrategy::rebate:
            {
                cs = std::make_unique<CashRebate>(0.8);
                break;
            }
        default:;
        }
    }
 
    double GetResult(double money)
    {
        return cs->acceptCash(money);
    }
};
 
int main(void)
{
    double total=0;
    double totalPrices=0;
 
    //正常收费
    auto cc1 = std::make_unique<CashContext>(SellStrategy::normal);
 
    totalPrices=cc1->GetResult(300);
    total+=totalPrices;
    std::cout<<"Type:正常收费  totalPrices:"<<totalPrices<<"  total:"<<total<<std::endl;
    totalPrices=0;
 
    //返现类型
    auto cc2 = std::make_unique<CashContext>(SellStrategy::returnMoney);
    totalPrices=cc2->GetResult(700);
    total+=totalPrices;
    std::cout<<"Type:满300返100  totalPrices:"<<totalPrices<<"  total:"<<total<<std::endl;
    totalPrices=0;
 
    //打折类型
    auto cc3 = std::make_unique<CashContext>(SellStrategy::rebate);
    totalPrices=cc3->GetResult(300);
    total+=totalPrices;
    std::cout<<"Type:打8折  totalPrices:"<<totalPrices<<"  total:"<<total<<std::endl;
    totalPrices=0;
 
 
    return 0;
}

总结分析

1）策略模式是一个比较容易理解和使用的设计模式，策略模式是对算法的封装，它把算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法封装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
2）在策略模式中，应当由客户端自己决定在什么情况下使用什么具体策略角色。
3）策略模式仅仅封装算法，提供新算法插入到已有系统中，以及老算法从系统中“退休”的方便，策略模式并不决定在何时使用何种算法，算法的选择由客户端来决定。这在一定程度上提高了系统的灵活性，但是客户端需要理解所有具体策略类之间的区别，以便选择合适的算法，这也是策略模式的缺点之一，在一定程度上增加了客户端的使用难度。