大话设计模式 第一章 简单工厂模式 C++实现

1 简单工厂模式：
将功能相似的类统一继承于一个抽象基类（Abstract Base Class），将这些子类的实例化交给一个工厂类来完成。应用多态和封装的思想，子类的代码对客户端不开放。使用基类指针或引用调用virtual函数，动态地确定调用函数的子类类型。
2 例程功能：
实现一个收银台计费程序，根据正常收费（N），打折收费（D）或返现收费（R）来确定收费金额。
3 例程设计思路：
简化程序功能，只计算单一商品价格，输入原价，指定收费模式，输出金额。
为三种收费模式分别建立一个类，均继承于基类CashSuper。
建立工厂类CashFactory，管理上述子类的实例化。
由指向子类对象的基类指针调用相应子类的收费函数acceptCash来计算金额。
4 编程环境：
win10 64位+Qt 5.3 +MinGW 4.8.2
5 工程截图：

6 实现代码：

//cashsuper.h
//收费模式的抽象基类
#ifndef CASHSUPER_H
#define CASHSUPER_H

class CashSuper
{
public:
    //CashSuper();//抽象基类不能实例化，不需要构造函数
    //纯虚函数声明，不需要定义
    virtual double acceptCash(double money)=0;
};
#endif // CASHSUPER_H

//cashsuper.cpp
#include "cashsuper.h"
//CashSuper::CashSuper()
//{
//}

//cashnormal.h
#ifndef CASHNORMAL_H
#define CASHNORMAL_H

#include "cashsuper.h"

class CashNormal:public CashSuper
{
public:
    CashNormal();
    //重载
    double acceptCash(double money){
        return money;//直接返回money
    }
};
#endif // CASHNORMAL_H

//cashnormal.cpp
#include "cashnormal.h"
CashNormal::CashNormal()
{
}

//cashrebate.h
#ifndef CASHREBATE_H
#define CASHREBATE_H
#include "cashsuper.h"
class CashRebate:public CashSuper
{
public:
    //构造函数需要初始化折扣率
    CashRebate(double moneyRebate_in);
    //重载
    double acceptCash(double money);
private:
    double moneyRebate;
};

#endif // CASHREBATE_H

//cashrebate.cpp
#include "cashrebate.h"

CashRebate::CashRebate(double moneyRebate_in)
{
    moneyRebate=moneyRebate_in;
}
double CashRebate::acceptCash(double money)
{
    return money*moneyRebate;
}

//cashreturn.h
#ifndef CASHRETURN_H
#define CASHRETURN_H
#include "cashsuper.h"
class CashReturn:public CashSuper
{
public:
    CashReturn(double moneyCondition_in,double moneyReturn_in);
    //重载
    double acceptCash(double money);
private:
    double moneyCondition;
    double moneyReturn;
};
#endif // CASHRETURN_H

//cashreturn.cpp
#include "cashreturn.h"

CashReturn::CashReturn(double moneyCondition_in,double moneyReturn_in)
{
    moneyCondition=moneyCondition_in;
    moneyReturn=moneyReturn_in;
}
double CashReturn::acceptCash(double money)
{
    return money-(int)(money/moneyCondition)*moneyReturn;
}

//cashfactory.h
#ifndef CASHFACTORY_H
#define CASHFACTORY_H

#include "cashsuper.h"
#include "cashnormal.h"
#include "cashrebate.h"
#include "cashreturn.h"

class CashFactory
{
public:
    CashFactory();
    //return pointer to CashSuper for polymorphism
    //返回基类的指针，才能使用多态
    static CashSuper* createCashAccept(char type);
};
#endif // CASHFACTORY_H

//cashfactory.cpp
#include "cashfactory.h"

CashFactory::CashFactory()
{
}
CashSuper* CashFactory::createCashAccept(char type)
{
    CashSuper* pCashSuper=0;
    switch(type)
    {
    case 'N'://正常模式
        pCashSuper=new CashNormal();
        break;
    case 'R'://返现模式
        pCashSuper=new CashReturn(300,100);
        break;
    case 'D'://打折模式
        pCashSuper=new CashRebate(0.8);
        break;
    }
    return pCashSuper;
}

//main.cpp
#include <iostream>
#include "cashsuper.h"
#include "cashfactory.h"

int main()
{
    CashFactory obj_cash_factory;
    CashSuper* pCashSuper=obj_cash_factory.createCashAccept('N');
    //CashSuper* pCashSuper=obj_cash_factory.createCashAccept('N');
    //CashSuper* pCashSuper=obj_cash_factory.createCashAccept('N');
std::cout<<"The Price is: "<<pCashSuper->acceptCash(300)<<std::endl;
}

7 总结
简单工厂模式将子类封装了起来，客户端不可见。但是没有封装基类CashSuper，仍需要在客户端调用之。