策略模式加工厂模式实现商场促销 C++

简单记录一下策略模式，策略模式是一种定义一系列算法的方法，这些算法完成相同工作， 只是实现的细节不一样。那么我们可以利用策略模式， 封装算法， 实现算法与算法使用者之间的解耦工作。

另外， 策略模式利于单元检测， 因为各个算法之间是相互独立的。

下面上UML图



这个图和简单工厂模式的图很类似， 不过简单工厂模式中 工厂类 和 产品基类之间是一种依赖关系， 而这里是一种聚合关系。

代码如下：

Csuper.h

#ifndef _CASHSUPER_H_
#define _CASHSUPER_H_

template <class T>
class CCashSuper{
public:
/************************************************************************/
/* 收取现金的接口                                                       */
/************************************************************************/
virtual double acceptCash(T money) const /*{ return money; }*/ = 0;
};

#endif // _CASHSUPER_H_

MainSuper.h

#ifndef _MAINCASHSTRATEGY_H_
#define _MAINCASHSTRATEGY_H_

#include "CashSuper.h"

/************************************************************************/
/* 正常收费的策略                                                       */
/************************************************************************/
template<class T>
class CCashNormal : public CCashSuper<T>{
public:
T acceptCash(T money) const{
return money;
}
};

/************************************************************************/
/* 打折收费的策略                                                       */
/************************************************************************/
template<class T, class U>
class CCashRebate : public CCashSuper<T>{
public:
CCashRebate(T debate) : debate(debate){}
// 操作 debate 数据
void setRebate(U debate){ this->debate = debate; }
U getRebate() const { return debate; }

// 计算收费
T acceptCash(T money) const{
return money * getRebate();
}

private:
U debate;
};

/************************************************************************/
/* 返现收费的策略                                                       */
/************************************************************************/
template<class T, class U>
class CCashReturn : public CCashSuper<T>{
public:
CCashReturn(T moneyCond, T moneyRet) : moneyCond(moneyCond), moneyRet(moneyRet){}
// manipulate the moneyCond
U getMoneyCond() const { return moneyCond; }
void setMoneyCond(U val) { moneyCond = val; }

// manipulate the moneyRet
U getMoneyRet() const { return moneyRet; }
void setMoneyRet(U val) { moneyRet = val; }

// calc the money
T acceptCash(T money) const{
return money >= moneyCond ? money - moneyRet : money;
}

private:
U moneyCond;        //  返现标准
U moneyRet;         //  返现额度
};

#endif // _MAINCASHSTRATEGY_H_

strategyContext.h

#ifndef _STRATEGYCONTEXT_H_
#define _STRATEGYCONTEXT_H_

#include "MainCashStrategy.h"
#include <memory>

template <class T>
class CStrategyContext{
public:
CStrategyContext(int type){
switch (type)
{
case 0: // normal cash
strategy = std::shared_ptr<CCashSuper<T>>(new CCashNormal<T>());
break;
case 1: // rebate cash
strategy = std::shared_ptr<CCashSuper<T>>(new CCashRebate<T, double>(0.8));
break;
case 2: // return cash
strategy = std::shared_ptr<CCashSuper<T>>(new CCashReturn<T, double>(300.0, 100.0));
break;

default:
break;
}
}

T getResult(T money) const {
return strategy->acceptCash(money);
}

private:
std::shared_ptr<CCashSuper<T>> strategy;
};

#endif // _STRATEGYCONTEXT_H_

main.cpp

#include <iostream>
#include <memory>
#include "StrategyContext.h"

using namespace std;

int main(){
shared_ptr<CStrategyContext<double>> context(new CStrategyContext<double>(2));
cout << context->getResult(300.0) << endl;

system("pause");
return 0;
}