策略模式
简单工厂模式只是解决对象的创建问题,而且由于工厂本身包括所有了的对象创建方式,而对象创建方式可能会经常改变,每次维护和扩展都要改动这个工厂,以致代码需要重新编译部署,不利于维护。
策略模式定义了一个算法家族,分别封装起来,让他们可以互相替换。这个模式让算法的变化,不会影响到使用算法的客户。
其中:
- 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代码,花费成本依然很重。