【设计模式】策略模式

策略模式

简单工厂模式只是解决对象的创建问题，而且由于工厂本身包括所有了的对象创建方式，而对象创建方式可能会经常改变，每次维护和扩展都要改动这个工厂，以致代码需要重新编译部署，不利于维护。

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

其中：

Strategy类：定义所有支持的算法公共接口
ConcreteStrategy*类：封装了具体算法，继承于Strategy类
Context 类：用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用。
Clinet代码：由于实例化不同的策略，所以最终在调用Context.ContextInterface()时所获得的结果就不尽相同。

但是现在发生了一个问题：就是之前简单工厂模式解决的问题：选择所用具体实现的职责由客户端对象承担，并将选择的结果转给Context对象，实例化对应的ConcreteStrategy对象。

解决办法：策略模式 + 简单工厂模式

策略模式 + 简单工厂模式

将实例化具体策略的过程由客户端转移到Context类中。（简单工厂的应用）

并且这样还有一个优点：context除了引入基类对象之外，也在类内定义了一个函数用来调用基类的函数，这样做的目的是当我们在客户端（主函数）中进行相关操作时，我们只需实例化context类的对象，也就是说我们的主函数只需要认识context类就可。因此在策略模式下的代码实现的进一步解耦合，解耦的目的就是使各部分之间的依赖降低，因此当其中某部分代码发生变动时，其他的代码无需变动或者无需大的变动，让代码维护和扩展更加便利。

基于策略模式 + 简单工厂模式实现商场促销

// cash.h
#ifndef CASH
#define CASH

#include <string>
#include <unordered_map>
#include <memory>

// 设置可选择的打折促销选项
enum CashType
{
    NORMAL_CASH,
    REBATE_CASH,
    RETURN_CASH
};

std::unordered_map<std::string, CashType> cashtypes(
    {
        {"normal", NORMAL_CASH},
        {"300back100", RETURN_CASH},
        {"0.8", REBATE_CASH}
    }
);

// 收费抽象类 收取现金，money为原价，返回当前价。
// 定义所有支持的算法的公共接口
class CashSuper
{
public:
    virtual double acceptCash(double money) = 0;
};

// 下面自类封装了具体的算法和行为
// 正常收费子类
class CashNormal : public CashSuper
{
private:
    /* data */
public:
    virtual double acceptCash(double money);
};

// 打折收费子类
class CashRebate : public CashSuper
{
private:
    double moneyRebate;
public:
    CashRebate(std::string Rebate);
    virtual double acceptCash(double money);
};

// 返利收费子类
class CashReturn : public CashSuper
{
private:
    double moneyCondition;
    double moneyReturn;
public:
    CashReturn(std::string cond, std::string ret);
    virtual double acceptCash(double money);
};

// 维护一个对CashSuper的引用(指针)
// 根据具体的策略对象，调用相应的算法。
// 并且应用简单工厂模式，将实例化具体策略的过程由客户端转移到Context类中
class CashContext
{
private:
    std::shared_ptr<CashSuper> cash;
    // CashSuper* cash;
public:
    CashContext(std::string type);
    ~CashContext();
    double getResult(std::string price, std::string counts);
};

double CashContext::getResult(std::string price, std::string counts)
{
    double price_c = stod(price);
    double counts_c = stod(counts);
    return cash->acceptCash(price_c * counts_c);
}

CashContext::CashContext(std::string type)
{
    CashType cur = cashtypes[type];
    std::cout << cur << std::endl;;
    // 根据选项选择打折额度
    switch (cur)
    {
    /*
    因为带有参数的 shared_ptr 构造函数是 explicit 类型的，
    所以不能像这样std::shared_ptr<int> p1 = new int();隐式调用它构造函数。
    创建新的shared_ptr对象的最佳方法是使用std :: make_shared：
    */
    case NORMAL_CASH:
        cash = std::make_shared<CashNormal>();
        break;
    case REBATE_CASH:
        cash = std::make_shared<CashRebate>("0.8");
        break;
    case RETURN_CASH:
        cash = std::make_shared<CashReturn>("300","100");
        break;    
    default:
        break;
    }
}

CashReturn::CashReturn(std::string cond, std::string ret)
{
    moneyCondition = stod(cond);
    moneyReturn = stod(ret);
}

double CashReturn::acceptCash(double money)
{
    if(money >= moneyCondition)
        return money - (money / moneyCondition) * moneyReturn;
    return money;
}

CashRebate::CashRebate(std::string Rebate)
{
    moneyRebate = stod(Rebate);
}

double CashRebate::acceptCash(double money)
{
    return money * moneyRebate;
}

double CashNormal::acceptCash(double money)
{
    return money;
}
#endif

客户端的实现：

#include <iostream>
#include "cash.h"
// #include <Windows.h>

void calcCash(double& totalPrices)
{
    std::string price, counts, type;
    std::cout << "请输入单价金额" << std::endl;
    std::cin >> price;
    if(price == "") exit(0);
    std::cout << "请输入购入数量" << std::endl;
    std::cin >> counts;
    if(price == "") exit(0);
    std::cout << "请输入收费模式, 如:"  << std::endl;
    // C++ 存储中文乱码
    // cited from: https://blog.csdn.net/CHAOS_ORDER/article/details/112095898
    for(auto it = cashtypes.cbegin(); it != cashtypes.cend(); ++it)
    {
        std::cout << it->first << std::endl;
    }
    std::cin >> type;
    if(price == "") exit(0);
    CashContext* cash = new CashContext(type);
    totalPrices += cash->getResult(price,counts);
    std::cout << "当前总价为" << totalPrices << std::endl;
}

int main(int argc, char* argv[])
{
    // C++ cout输出中文乱码
    // cited from: https://blog.csdn.net/qq_44881664/article/details/120166258
    system("chcp 65001");
    // SetConsoleOutputCP(CP_UTF8);
    double totalPrices = 0;
    while(std::cin)
    {
        calcCash(totalPrices);
    }
    return 0;
}

总结

当不同的行为堆砌到一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。

策略模式定义了一个算法家族，分别封装起来，让他们可以互相替换。这个模式让算法的变化，不会影响到使用算法的客户。这个算法广义来讲可以理解为各种类型的规则。只要需要在不同时间应用不同的业务规则，就可以考虑用策略模式来处理这种变化的可能性。

优点：

策略模式下的代码实现进一步解耦合
- 减少了各种算法类与使用算法类之间的耦合。解耦的目的就是使各部分之间的依赖降低，因此当其中某部分代码发生变动时，其他的代码无需变动或者无需大的变动，让代码维护和扩展更加便利。
- context除了引入基类对象之外，也在类内定义了一个函数用来调用基类的函数，这样做的目的是当我们在客户端（主函数）中进行相关操作时，只需实例化context类的对象，也就是说main函数只需要认识context类就可，算法的基类也被封装起来，不会让客户端认识。
策略模式的Strategy类层次为Context定义了一系列可供重用的算法或行为，继承有利于提取出这些算法中的公共功能。
简化了单元测试，因为每个算法都有自己封装的类，可以通过自己的接口单独测试。
在客户端的代码中可以消除条件语句，避免了大量判断，将具体算法的变化封装起来。
结合了简单工厂模式后的策略模式可以使选择具体实现的职责由Context承担，最大化减轻了客户端的职责。

不足：如果需要扩展和修改算法类，仍然需要更改Context类中的switch代码，花费成本依然很重。

【设计模式】策略模式

策略模式

策略模式 + 简单工厂模式

基于策略模式 + 简单工厂模式实现商场促销

总结

相关推荐