策略模式&简单工厂模式

策略模式&简单工厂模式 一、策略模式&简单工厂模式 1、需求：

某商场三种收费方式、联想商场收费方式的复杂性编写合适的代码、采用面向对象编程；

2、思路：

仅仅使用简单工厂模式实现当前需求，不利于后期维护和扩展；
仅仅使用策略模式，在编码过程中过程比较笨拙繁琐，难以和客户端进行很好的交互；
使用策略模式&简单工厂模式恰好；

代码如下（示例）：

#pragma once
using namespace std;

// 基类-----现金收费抽象类-----抽象策略
class CashSuper
{
public:
	// 抽象类至少有一个纯虚函数

	// 接收现金
	virtual double acceptCash(double money) = 0; // 纯虚函数
};

#pragma once
#include"cashSuper.h"

// 派生类-----正常收费类-----具体策略
class CashNormal : public CashSuper
{
public:
	// 重写
	double acceptCash(double money) // override
	{
		return money;
	}
};

#pragma once
#include"cashSuper.h"
#include
#include

// 派生类-----返利收费类-----具体策略
class CashReturn : public CashSuper
{
public:
	CashReturn()
	{

	}

	CashReturn(string moneyCondition, string moneyReturn)
	{
		m_moneyCondition = stod(moneyCondition);  // stod sting->double
		m_moneyReturn = stod(moneyReturn);
	}
	
	double acceptCash(double money) // override
	{
		double result = money;
		if (money >= m_moneyCondition)
		{
			// 若大于返利条件，则需要减去返利值
			result = money - floor(money / m_moneyCondition) * m_moneyReturn; // floor 对浮点数向下取整
		}
		return result;
	}
private:
	double m_moneyCondition = 0.00; // 返利条件
	double m_moneyReturn = 0.00; // 返利值
};

#pragma once
#include"cashSuper.h"
#include"string"

// 派生类------打折收费类-----具体策略
class CashRebate : public CashSuper
{
public:
	CashRebate(string moneyReabte)
	{
		m_moneyRebate = stod(moneyReabte);
	}

	double acceptCash(double money)
	{
		return (money * m_moneyRebate);
	}
private:
	double m_moneyRebate = 1.00;
};

#pragma once
#include"cashSuper.h"
#include"cashNormal.h"
#include"cashReturn.h"
#include"cashRebate.h"
#include



// 收费对象生成工厂类
class CashFactory
{
public:
	// 确定对象实例
	static CashSuper* createCashAccept(char type)
	{
		// 创建基类对象 根据需求生成所需派生类对象
		CashSuper* cS = nullptr; // 抽象类不能创建类对象 但可以创建类指针
		switch (type)
		{
		case 'A': // 正常收费
			cS = new CashNormal();
			break;
		case 'B': // 满 300 反 100
			cS = new CashReturn("300", "100");
			break;
		case 'C': // 打 8 折
			cS = new CashRebate("0.8");
			break;
		default:
			cout << "输入有误" << endl;
			abort();
			break;
		}
		return cS;
	}
};

#pragma once
#include"cashSuper.h"
#include"cashNormal.h"
#include"cashReturn.h"
#include"cashRebate.h"
#include

// 策略类
class CashContext
{
public:
	// 通过构造函数 传入具体收费策略（不是具体的对象)
	// 在策略模式得基础上引入工厂模式
	CashContext(char type)
	{
		switch (type)
		{
		case 'A': // 正常收费
			m_cashSuper = new CashNormal();
			break;
		case 'B': // 满 300 反 100
			m_cashSuper = new CashReturn("300", "100");
			break;
		case 'C': // 打 8 折
			m_cashSuper = new CashRebate("0.8");
			break;
		default:
			cout << "输入有误" << endl;
			abort();
			break;
		}
	}

	double getResult(double money)
	{
		return m_cashSuper->acceptCash(money);
	}
private:
	CashSuper* m_cashSuper = nullptr;
};

#include
using namespace std;
#include"cashSuper.h"
#include"cashFactory.h"
#include"cashContext.h"

// 简单工厂模式	需要使开发者认识两个类 CashSuper、CashFactory
// 策略模式&简单工厂模式 只需要开发者认识一个类 CashContext
// 降低程序的耦合度
int main()
{
	
	double price;
	char type;
	cout << "输入预现金：" << endl;
	cin >> price;
	cout << "输入收费类型：" << endl;
	cin >> type;

	// 简单工厂模式
	//CashSuper* cS = CashFactory::createCashAccept(type);
	//cout << "最终价格：" << cS->acceptCash(price) << endl; // 算法类和客户端直观相见

	// 策略模式 & 简单工厂模式
	CashContext* cC = new CashContext(type);
	cout << "最终价格：" << cC->getResult(price) << endl; // 算法类和客户端彻底分离
	
	system("pause");
	return 0;
}

---

总结

提示：这里对文章进行总结：