简单工厂模式

大二上设计模式时，老师推荐了一本书叫大话设计模式，现在才入手看看，感觉例子确实蛮不错的。

第一种简单工厂模式，

书中给的例子是商城购物收银时，经常有优惠活动，有的是打折，有的是满多少返多少类似的情况等等。

开始大牛让菜鸡写个简单工厂，菜鸡的实现的第一种形式就是每给一种打折，写个工厂子类。

于是大牛表示这么写，子类可能太多，为什么不找找这些打优惠类的共同点。

“面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象”

于是菜鸡总结了下，发现其实归纳起来只有3个子类，

1是无优惠的原价收费

2是打几折的优惠

3是满多少返多少的优惠

参数有区别而已。

于是实现如下

#include <iostream>
using namespace std;
class CashSuper
{
public:
    virtual float AcceptCash(float)=0;
};

class CashNormal:public CashSuper
{
public:
    virtual float AcceptCash(float cash)
    {
        return cash;
    }
};

class CashRebate:public CashSuper
{
private:
    float m_rebate;
public:
    CashRebate(float r):m_rebate(r){}
    virtual float AcceptCash(float cash)
    {
        return cash*m_rebate;
    }
};

class CashReturn:public CashSuper
{
private:
    int m_condition;
    int m_return;
public:
    CashReturn(int c,int r):m_condition(c),m_return(r){}
    virtual float AcceptCash(float cash)
    {
        return cash-(int)cash/m_condition*m_return;
    }
};
class CashFactory
{
public:
    enum CASHTYPE{NORMAL,REBATE,CASHRETURN};
public:
    CashSuper* CreateCashAccept(CASHTYPE ct)
    {
        CashSuper* cs=NULL;
        switch(ct)
        {
        case NORMAL:
            cs=new CashNormal();
            break;
        case REBATE:
            cs=new CashRebate(0.8f);
            break;
        case CASHRETURN:
            cs=new CashReturn(300,100);
            break;

        }
        return cs;
    }
};

int main()
{
    CashFactory cf;
    CashSuper* cs=cf.CreateCashAccept(CashFactory::REBATE);
    cout<<cs->AcceptCash(300);
    return 0;
}

 写完后发现enum类型能根据的值来switch case...而且类里面定义的enum类型要在外部访问也得public：

比如可以

        case 0:
            cs=new CashNormal();
            break;
        case 1:
            cs=new CashRebate(0.8f);
            break;
        case CASHRETURN:
            cs=new CashReturn(300,100);
            break;

但是外部调用时，由于函数接收的参数是ENUM类型
不能直接
CashSuper* cs=cf.CreateCashAccept(1);
强制转换一下
CashSuper* cs=cf.CreateCashAccept((CashFactory::CASHTYPE)1);