【设计模式】商场促销 -- 策略模式

2024-04-05 01:38
文章标签 设计模式 模式 策略 商场 促销

本文主要是介绍【设计模式】商场促销 -- 策略模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一，概念

        策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

二，策略模式的组成

　　 1）抽象策略角色： 策略类，通常由一个接口或者抽象类实现。
　　 2）具体策略角色：包装了相关的算法和行为。

　　 3）环境角色：持有一个策略类的引用，最终给客户端调用。

三，补充C++知识

类对象的构造顺序是这样的：
  1.分配内存，调用构造函数时，隐式／显示的初始化各数据成员
  2.进入构造函数后在构造函数中执行一般计算
       1）类里面的任何成员变量在定义时是不能初始化的。
       2）一般的数据成员可以在构造函数中初始化。
       3）const数据成员必须在构造函数的初始化列表中初始化。
       4）static要在类的定义外面初始化。  
       5）数组成员是不能在初始化列表里初始化的。
       6）不能给数组指定明显的初始化。 
这6条一起，说明了一个问题：C++里面是不能定义常量数组的！因为3和5的矛盾。这个事情似乎说不过去啊？没有办法，我只好转而求助于静态数据成员。
到此，我的问题解决。但是我还想趁机复习一下C++类的初始化：
  1.初始化列表：CSomeClass::CSomeClass() : x(0), y(1){}
  2.类外初始化：int CSomeClass::myVar=3;
  3.const常量定义必须初始化，C++类里面使用初始化列表;
  4.C++类不能定义常量数组。

在C++类中，必须做如下事情：

1.必须对任何const或引用类型成员以及没有默认构造函数的 类 类型 的任何成员 显示地使用初始化列表进行初始化

2.类成员在定义时是不能被初始化的。

3.类的成员初始化顺序与成员变量在构造函数中的位置选后顺序无关，至于成员变量在类中定义的先后顺序有关。

C++默认继承方式为private

C++ new 生成的对象为指针，所以new 前面的对象要声明为指针类型

四，实例

        计算器简单工厂模式的精简实现

#include <iostream>
using namespace std;class COperation//基类
{
public:int m_nFirst;int m_nSecond;virtual double GetResult(){double dResult=0;return dResult;}
};class AddOperation : public COperation//加法
{
public:virtual double GetResult(){return m_nFirst+m_nSecond;}
};class SubOperation : public COperation//减法
{
public:virtual double GetResult(){return m_nFirst-m_nSecond;}
};class CCalculatorFactory//工厂类
{public://静态方法属于类本身，不属于哪个对象 static COperation* Create(char cOperator);};COperation* CCalculatorFactory::Create(char cOperator)//工厂类的实现
{COperation *oper;//在C#中可以用反射来取消判断时用的switch，在C++中用什么呢？RTTI？？switch (cOperator){case '+':oper=new AddOperation();break;case '-':oper=new SubOperation();break;default:oper=new AddOperation();break;}return oper;
}int main()
{int a,b;cin>>a>>b;/*静态方法为类所有，可以通过对象来使用，也可以通过类来使用。但一般提倡通过类名来使用，因为静态方法只要定义了类，不必建立类的实例就可使用*/COperation * op = CCalculatorFactory::Create('-');//静态方法调用方式 op->m_nFirst=a;op->m_nSecond=b;cout<<op->GetResult()<<endl;return 0;
}

将简单工厂模式优化为策略模式后的代码如下： 

#include <iostream>
using namespace std; //策略基类
class COperation
{
public:int m_nFirst;int m_nSecond;virtual double GetResult(){double dResult=0;return dResult;}
};//策略具体类-加法类
class AddOperation : public COperation
{
public:AddOperation(int a,int b){m_nFirst=a;m_nSecond=b;}virtual double GetResult(){return m_nFirst+m_nSecond;}
};class Context//策略类 
{
private:COperation* op;
public:Context(COperation* temp)//参数为策略基类（传递的时候被初始化为子类） {op=temp;}double GetResult(){return op->GetResult();}
};//客户端
int main()
{int a,b;char c;cin>>a>>b;cout<<"请输入运算符：";cin>>c;switch(c){case '+':Context *context=new Context(new AddOperation(a,b));cout<<context->GetResult()<<endl;break;default:break;}return 0;
}

这里将策略（操作符）封装成一个Context类，通过传递操作符子对象来返回相应子对象下操作结果。

菜鸟实现工厂模式和策略模式

        客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。在上例基础上，修改下面内容

#include <iostream>
using namespace std;//策略基类
class COperation
{
public:int m_nFirst;int m_nSecond;virtual double GetResult(){double dResult=0;return dResult;}
};//策略具体类-加法类
class AddOperation : public COperation
{
public:AddOperation(int a,int b){m_nFirst=a;m_nSecond=b;}AddOperation(){m_nFirst=0;m_nSecond=0;}virtual double GetResult(){return m_nFirst+m_nSecond;}
};
class Context
{
private:COperation* op;
public:Context(char cType){switch (cType){case '+':op=new AddOperation(3,8);break;default:op=new AddOperation();break;}}double GetResult(){return op->GetResult();}
};
//客户端
int main()
{Context *test=new Context('+');cout<<test->GetResult()<<endl;return 0;
}

五，商场促销例子

        这里想说的是，abstract 关键字是微软为C#定义的，抽象类关键字。C++中没有抽象类，如果想成为抽象类在类中定义纯虚函数就可以了。只要拥有纯虚函数的类就是抽象类，由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。

         商场促销的简单工厂实现：

#include <iostream>using namespace std;class CashSuper //现金收费抽象类
{
public:virtual double acceptCash(double money)//不能设置为纯虚函数，后面还要生成对象用呢！！！！ (不能只定义，而不实现){}
};class CashNormal : public CashSuper //收费子类，正常收费
{
public:double acceptCash(double money){return money;}};class CashRebate : public CashSuper //打折收费子类
{
private:double moneyRebate;//不允许初始化
public:CashRebate(double moneyRebate){this->moneyRebate=moneyRebate;}double acceptCash(double money){return money*moneyRebate;}
};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-(money/moneyCondition)*moneyReturn;return result;}
};class CashFactory
{
public:static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类{CashSuper *cs;if(type=="CashNormal")cs=new CashNormal();else if(type == "CashRebate")cs=new CashRebate(0.8);else if(type == "CashReturn")cs=new CashReturn(300,100);return cs;}
};int main(int argc, char** argv) {CashSuper *csuper = CashFactory::creatCashAccept("CashRebate");double result=csuper->acceptCash(500);//500打八折，应该输出 400cout<<"CashRebate 500 is："<<result<<endl;return 0;
}策略模式：定义了算法家族，分别封装起来，让它们之间可以相互替换，算法的变化不会影响使用算法的客户。
        主要升级就是，将算法封装到Context中，然后通过传递对象生成相应子类对象，然后得到结果。 

#include <iostream>using namespace std;class CashSuper //现金收费抽象类
{
public:virtual double acceptCash(double money)//不能设置为纯虚函数，后面还要生成对象用呢！！！！ {}
};class CashNormal : public CashSuper //收费子类，正常收费
{
public:double acceptCash(double money){return money;}};class CashRebate : public CashSuper //打折收费子类
{
private:double moneyRebate;//不允许初始化
public:CashRebate(double moneyRebate){this->moneyRebate=moneyRebate;}double acceptCash(double money){return money*moneyRebate;}
};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-(money/moneyCondition)*moneyReturn;return result;}
};/*class CashFactory
{
public:static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类{CashSuper *cs;if(type=="CashNormal")cs=new CashNormal();else if(type == "CashRebate")cs=new CashRebate(0.8);else if(type == "CashReturn")cs=new CashReturn(300,100);return cs;}
};*/class CashContext
{
private:CashSuper cs;
public:CashContext(CashSuper csuper){this->cs=csuper;}double GetResult(double money){return cs.acceptCash(money);}
};int main(int argc, char** argv) {//CashSuper *csuper = CashFactory::creatCashAccept("CashRebate");//double result=csuper->acceptCash(500);//500打八折，应该输出 400CashContext *cs;string type="CashRebate";if(type=="CashNormal")cs=CashContext(new CashNormal());else if(type == "CashRebate")cs=CashContext(new CashRebate(0.8));else if(type == "CashReturn")cs=CashContext(new CashReturn(300,100));cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl;return 0;
}

这样仍然存在缺点：就是让客户端来判断生成哪个子类。

改进策略是，让策略模式和工厂模式结合

#include <iostream>using namespace std;class CashSuper //现金收费抽象类
{
public:virtual double acceptCash(double money)//不能设置为纯虚函数，后面还要生成对象用呢！！！！ {}
};class CashNormal : public CashSuper //收费子类，正常收费
{
public:double acceptCash(double money){return money;}};class CashRebate : public CashSuper //打折收费子类
{
private:double moneyRebate;//不允许初始化
public:CashRebate(double moneyRebate){this->moneyRebate=moneyRebate;}double acceptCash(double money){return money*moneyRebate;}
};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-(money/moneyCondition)*moneyReturn;return result;}
};/*class CashFactory
{
public:static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类{CashSuper *cs;if(type=="CashNormal")cs=new CashNormal();else if(type == "CashRebate")cs=new CashRebate(0.8);else if(type == "CashReturn")cs=new CashReturn(300,100);return cs;}
};*/class CashContext
{
private:CashSuper cs;
public:CashContext(string type){if(type=="CashNormal")this->cs=new CashNormal();else if(type == "CashRebate")this->cs=new CashRebate(0.8);else if(type == "CashReturn")this->cs=new CashReturn(300,100);}double GetResult(double money){return cs.acceptCash(money);}
};int main(int argc, char** argv) {CashContext *cs=new CashContext("CashRebate");cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl;return 0;
}

这样客户端只需要更改金额和打折手段就可以了。相对简单工厂的提升为：简单工厂需要让客户调用两个类SuperCash和CashFactory。而结合之后仅仅需要调用CashContext就可以了

相对与策略模式的提升为：客户端需要承担的判断更少了，更简洁了


这篇关于【设计模式】商场促销 -- 策略模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/877352。

相关文章

Redis Cluster模式配置

Redis Cluster模式配置

《RedisCluster模式配置》：本文主要介绍RedisCluster模式配置,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录分片 一、分片的本质与核心价值二、分片实现方案对比 ‌三、分片算法详解1. ‌范围分片（顺序分片）‌2. ‌哈希分片3. ‌虚
阅读更多...
Redis过期删除机制与内存淘汰策略的解析指南

Redis过期删除机制与内存淘汰策略的解析指南

《Redis过期删除机制与内存淘汰策略的解析指南》在使用Redis构建缓存系统时,很多开发者只设置了EXPIRE但却忽略了背后Redis的过期删除机制与内存淘汰策略,下面小编就来和大家详细介绍一下... 目录1、简述2、Redis http://www.chinasem.cn的过期删除策略（Key Expir
阅读更多...
RabbitMQ工作模式中的RPC通信模式详解

RabbitMQ工作模式中的RPC通信模式详解

《RabbitMQ工作模式中的RPC通信模式详解》在RabbitMQ中,RPC模式通过消息队列实现远程调用功能,这篇文章给大家介绍RabbitMQ工作模式之RPC通信模式,感兴趣的朋友一起看看吧... 目录RPC通信模式概述工作流程代码案例引入依赖常量类编写客户端代码编写服务端代码RPC通信模式概述在R
阅读更多...
利用Python实现时间序列动量策略

利用Python实现时间序列动量策略

《利用Python实现时间序列动量策略》时间序列动量策略作为量化交易领域中最为持久且被深入研究的策略类型之一,其核心理念相对简明：对于显示上升趋势的资产建立多头头寸,对于呈现下降趋势的资产建立空头头寸... 目录引言传统策略面临的风险管理挑战波动率调整机制：实现风险标准化策略实施的技术细节波动率调整的战略价
阅读更多...
SQL Server身份验证模式步骤和示例代码

SQL Server身份验证模式步骤和示例代码

《SQLServer身份验证模式步骤和示例代码》SQLServer是一个广泛使用的关系数据库管理系统,通常使用两种身份验证模式：Windows身份验证和SQLServer身份验证,本文将详细介绍身份... 目录身份验证方式的概念更改身份验证方式的步骤方法一：使用SQL Server Management S
阅读更多...
Redis高可用-主从复制、哨兵模式与集群模式详解

Redis高可用-主从复制、哨兵模式与集群模式详解

《Redis高可用-主从复制、哨兵模式与集群模式详解》：本文主要介绍Redis高可用-主从复制、哨兵模式与集群模式的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝... 目录Redis高可用-主从复制、哨兵模式与集群模式概要一、主从复制（Master-Slave Repli
阅读更多...
一文带你搞懂Redis Stream的6种消息处理模式

一文带你搞懂Redis Stream的6种消息处理模式

《一文带你搞懂RedisStream的6种消息处理模式》Redis5.0版本引入的Stream数据类型,为Redis生态带来了强大而灵活的消息队列功能,本文将为大家详细介绍RedisStream的6... 目录1. 简单消费模式（Simple Consumption）基本概念核心命令实现示例使用场景优缺点2
阅读更多...
Redis中6种缓存更新策略详解

Redis中6种缓存更新策略详解

《Redis中6种缓存更新策略详解》Redis作为一款高性能的内存数据库,已经成为缓存层的首选解决方案,然而,使用缓存时最大的挑战在于保证缓存数据与底层数据源的一致性,本文将介绍Redis中6种缓存更... 目录引言策略一：Cache-Aside（旁路缓存）策略工作原理代码示例优缺点分析适用场景策略二：Re
阅读更多...
SpringBoot基于配置实现短信服务策略的动态切换

SpringBoot基于配置实现短信服务策略的动态切换

《SpringBoot基于配置实现短信服务策略的动态切换》这篇文章主要为大家详细介绍了SpringBoot在接入多个短信服务商（如阿里云、腾讯云、华为云）后,如何根据配置或环境切换使用不同的服务商,需... 目录目标功能示例配置（application.yml）配置类绑定短信发送策略接口示例：阿里云 & 腾
阅读更多...
Nginx location匹配模式与规则详解

Nginx location匹配模式与规则详解

《Nginxlocation匹配模式与规则详解》：本文主要介绍Nginxlocation匹配模式与规则,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、环境二、匹配模式1. 精准模式2. 前缀模式（不继续匹配正则）3. 前缀模式（继续匹配正则）4. 正则模式（大
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2