c++ 设计模式--简单工厂模式&策略模式(01,03)

案例：营业员根据客户所购买商品的单价和数量，根据不同活动向客户收费

• 正常原价收费
• 八折收费
• 满300返100

简单工厂模式(Sample Factory Pattern)

简单工厂模式定义

定义一个简单工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类

简单工厂模式结构

• 工厂(Factory)：根据客户提供的具体产品类的参数，创建具体产品实例
• 抽象产品(Abstract Product)：具体产品类的基类，包含创建产品的公共方法
• 具体产品(Concrete Product)：抽象产品的派生类，包含具体产品特有的实现方法，是简单工厂模式的创建目标
  

简单工厂模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _SAMPLE_FACTORY_PATTERN_
#define _SAMPLE_FACTORY_PATTERN_
#include<iostream>

enum CashType
{
	NORMAL = 0,
	REBATE,
	RETURN
};

class CashSuper
{
public:
	virtual double AcceptCash(double dMoney) = 0;
};

class CashNormal :public CashSuper
{
public:
	CashNormal() {}
	double AcceptCash(double dMoney)
	{
		return dMoney;
	}
};

class CashRebate :public CashSuper
{
public:
	CashRebate(double dMoneyRebate = 0) :m_dMoneyRebate(dMoneyRebate) {}
	double AcceptCash(double dMoney)
	{
		return dMoney * m_dMoneyRebate;
	}
private:
	double m_dMoneyRebate;
};

class CashReturn :public CashSuper
{
public:
	CashReturn(double dMoneyCondition = 0, double dMoneyReturn = 0) :
		m_dMoneyCondition(dMoneyCondition), m_dMoneyReturn(dMoneyReturn) {}
	double AcceptCash(double dMoney)
	{
		if (dMoney > m_dMoneyCondition)
		{
			return dMoney - (dMoney / m_dMoneyCondition) * m_dMoneyReturn;
		}
		return dMoney;
	}
private:
	double m_dMoneyCondition;
	double m_dMoneyReturn;
};

class CashFactory
{
public:
	std::shared_ptr<CashSuper> CashOperation(CashType eCashType)
	{
		switch (eCashType)
		{
		case NORMAL:
			return std::shared_ptr<CashNormal>(new CashNormal());
			break;
		case REBATE:
			return std::shared_ptr<CashRebate>(new CashRebate(0.8));
			break;
		case RETURN:
			return std::shared_ptr<CashReturn>(new CashReturn(300, 100));
			break;
		default:
			break;
		}
	}
};
#endif // !_SAMPLE_FACTORY_PATTERN_

客户端调用

#include"Strategy.h"
#include<iostream>
int main()
{
	auto cashFactory = std::shared_ptr<CashFactory>(new CashFactory());
	auto cashOperation = cashFactory->CreatCashOperation(REBATE);
	std::cout << cashOperation->AcceptCash(500);
	return EXIT_SUCCESS;
}

策略模式(Strategy Pattern)

策略模式定义

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

策略模式结构

• 上下文类(Context):上下文类是使用算法的角色，可以在解决不同具体的问题时实例化不同的具体策略类对象
• 抽象策略类(Stategy):声明算法的方法，抽象层的设计使上下文类可以无差别的调用不同的具体策略的方法
• 具体策略类(Concrete Strategy):实现具体的算法

策略模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _STRATEGY_PATTERN_
#define _STRATEGY_PATTERN_
#include<iostream>

enum CashType
{
	NORMAL = 0,
	REBATE,
	RETURN
};

class CashSuper
{
public:
	virtual double AcceptCash(double dMoney) = 0;
};

class CashNormal :public CashSuper
{
public:
	CashNormal() {}
	double AcceptCash(double dMoney)
	{
		return dMoney;
	}
};

class CashRebate :public CashSuper
{
public:
	CashRebate(double dMoneyRebate = 0) :m_dMoneyRebate(dMoneyRebate) {}
	double AcceptCash(double dMoney)
	{
		return dMoney * m_dMoneyRebate;
	}
private:
	double m_dMoneyRebate;
};

class CashReturn :public CashSuper
{
public:
	CashReturn(double dMoneyCondition = 0, double dMoneyReturn = 0) :
		m_dMoneyCondition(dMoneyCondition), m_dMoneyReturn(dMoneyReturn) {}
	double AcceptCash(double dMoney)
	{
		if (dMoney > m_dMoneyCondition)
		{
			return dMoney - (dMoney / m_dMoneyCondition) * m_dMoneyReturn;
		}
		return dMoney;
	}
private:
	double m_dMoneyCondition;
	double m_dMoneyReturn;
};

class Context
{
public:
	Context(CashType eCashType)
	{
		switch (eCashType)
		{
		case NORMAL:
			m_spCashSuper = std::shared_ptr<CashNormal>(new CashNormal());
			break;
		case REBATE:
			m_spCashSuper = std::shared_ptr<CashRebate>(new CashRebate(0.8));
			break;
		case RETURN:
			m_spCashSuper = std::shared_ptr<CashReturn>(new CashReturn(300, 100));
			break;
		default:
			break;
		}
	}
	double GetResult(double dMoney) { return m_spCashSuper->AcceptCash(dMoney); }
private:
	std::shared_ptr<CashSuper> m_spCashSuper;
};

#endif // !_STRATEGY_PATTERN_

客户端调用

#include"Strategy.h"
#include<iostream>
int main()
{
	auto context = std::shared_ptr<Context>(new Context(REBATE));
	std::cout << context->GetResult(500);
	return EXIT_SUCCESS;
}