计算器之简单工厂模式学习笔记[C++版]

/************************************************************************
* 简单工厂模式学习笔记[C++]
* Author：  陈相礼
* Time：    2009.12.02
* Compiler: VC8
************************************************************************/
#include "SimpleFactory.h"
#include "SimpleFactory1.h"
#include "SimpleFactory2.h"
#include <iostream>
using namespace std;
int main()
{
    //------------------简单工厂原理类测试-------------------
    CProductor *prod;
    prod = CCreator().createProductor( 'a' );
    prod->vGetResult();
    prod = CCreator().createProductor( 'b' );
    prod->vGetResult();
    prod = CCreator().createProductor( 'c' );
    prod->vGetResult();
    //------------------计算器类测试-------------------
    COperation *oper;
    oper = COperationFactory().createOperation( '+' );
    oper->setNumberA( 7 );
    oper->setNumberB( 8 );
    double res = oper->getResult();
    //------------------商场收银类测试-------------------
    CashSuper *csObj;
    csObj = CashFactory().CreateCashAccept( 'R' );
    double dwPayMoney = csObj->dwAcceptCash( 700 );
    csObj = CashFactory().CreateCashAccept( 'T' );
    dwPayMoney = csObj->dwAcceptCash( 700 );
    return 0;
}
/************************************************************************
UML类图学习：
一、类图三层：类名[抽象类，斜体]、字段和属性、操作;{+:Public;-:Private;#:Protected}
二、接口：
    A、矩形表示法：顶端有<<interface>>;分二行：接口名称、接口方法。
    B、棒棒糖表示法：圈圈旁为借口名称；接口方法在实现类中出现。
三、关系：
    A、继承：空心三角形 + 实线。
    B、接口：空心三角形 + 虚线。
    C、关联：实线箭头。[类中引用关联的对象]。
    D、聚合：空心菱形 + 实线箭头。[A对象包含B对象，但B对象不是A对象的一部分]{弱拥有}
    E、合成：实心菱形 + 实线箭头，两端有数字。[部分整体关系]{强拥有}，初始化时同时生成
    F、依赖：虚线箭头。[类中某些方法参数]
四、实例：
    A、类图：
    +-------------------------+
    |   类名[斜体为抽象类]  |
    |-------------------------|
    |   +属性['+','-','#']   |
    |-------------------------|
    |   +方法['+','-','#']   |
    |-------------------------|
    B、接口：
    +-------------------------+
    |   <<interface>>         |
    |   接口名称            |
    |-------------------------|
    | +接口方法['+','-','#'] |
    |-------------------------|
            O
            |
            |
    +-------------------------+
    |    接口名称           |
    |-------------------------|
    |                         |
    |-------------------------|
    | +接口方法实现类中实现 |
    |-------------------------|
    C、继承：
    class CParent
    {
    public:
        Method(){};
    private:
        Attribute;
    };
    class CChild : public CParent
    {
        // 获得父类的方法，属性
    }
    D、接口：
    class IInterface
    {
    public:
        InterfaceMethod()
        {
            Implement;
        }
    }
    class CObject : public IInterface
    {
        Use InterfaceMethod();// 使用IInterface提供的接口
    }
    E、关联：
    class CObjectA
    {
    }
    class CObjectB
    {
    private:
        CObjectA cObj;// 引用CObjectA
    }
    F、聚合：
    class CObjectA
    {
    }
    class CObjectB
    {
    private:
        // CObjectB由若干个CObjectA组成，弱关联
        CObjectA cObj[iNums];
    }
    G、合成：
    class CObjectA
    {
    }
    class CObjectB
    {
    public:
        // 初始化要予以实现
        CObjectB() : cObj( new CObjectA() ) {};
    private:
        // CObjectB由若干个CObjectA合成，强关联
        CObjectA cObj;
    }
    H、依赖：
    class CObjectA
    {
    }
    class CObjectB
    {
    }
    class CObjectC
    {
    public:
        // 此方法需要依赖对象A和B
        Method( CObjectA cObjA, CObjectB cObjB ){};
    }
************************************************************************/

#pragma once
/**********************************************
* 简单工厂模式原理：
* 
*   专门定义一个类来负责创建其他类的实例，被创
* 建的实例通常都具有共同的父类。它又称为静态工
* 厂方法模式，属于类的创建型模式。
* 简单工厂模式的实质是由一个工厂类根据传入的参
* 数，动态决定应该创建哪一个产品类（这些产品类
* 继承自一个父类或接口）的实例。
*   该模式中包含的角色及其职责：
*   一、工厂（Creator）角色
* 简单工厂模式的核心，它负责实现创建所有实例的
* 内部逻辑。工厂类可以被外界直接调用，创建所需
* 的产品对象。
*   二、抽象（Product）角色
* 简单工厂模式所创建的所有对象的父类，它负责描
* 述所有实例所共有的公共接口。
*   三、具体产品（Concrete Product）角色
* 是简单工厂模式的创建目标，所有创建的对象都是
* 充当这个角色的某个具体类的实例。
* 一般来讲它是抽象产品类的子类，实现了抽象产品
* 类中定义的所有接口方法。
*   简单工厂模式的特点:
*   简单工厂模式的创建目标，所有创建的对象都是
* 充当这个角色的某个具体类的实例。
*   在这个模式中，工厂类是整个模式的关键所在。
* 它包含必要的判断逻辑，能够根据外界给定的信息，
* 决定究竟应该创建哪个具体类的对象。用户在使用
* 时可以直接根据工厂类去创建所需的实例，而无需
* 了解这些对象是如何创建以及如何组织的。有利于
* 整个软件体系结构的优化。
*   简单工厂模式的缺点也正体现在其工厂类上，由
* 于工厂类集中了所有实例的创建逻辑，所以“高内聚
* ”方面做的并不好。另外，当系统中的具体产品类不
* 断增多时，可能会出现要求工厂类也要做相应的修
* 改，扩展性并不很好。
* 
***********************************************/
#include <iostream>
using namespace std;
// 抽象角色
class CProductor
{
public:
    virtual void vGetResult() = 0;
};
// 产品子类
class CConcreteProductorA : public CProductor
{
public:
    void vGetResult()
    {
        cout << "具体产品A" << endl;
    }
};
// 产品子类
class CConcreteProductorB : public CProductor
{
public:
    void vGetResult()
    {
        cout << "具体产品B" << endl;
    }
};
// 产品子类
class CConcreteProductorC : public CProductor
{
public:
    void vGetResult()
    {
        cout << "具体产品C" << endl;
    }
};
// 工厂角色
class CCreator
{
public:
    CProductor* createProductor( char cType )
    {
        switch ( cType )
        {
        case 'A':
        case 'a':
            return new CConcreteProductorA();
            break;
        case 'B':
        case 'b':
            return new CConcreteProductorB();
            break;
        case 'C':
        case 'c':
            return new CConcreteProductorC();
            break;
        }
        return NULL;
    }
};

#pragma once
/********************************
*
* 简单工厂模式应用一：计算器
*
********************************/
// 运算抽象类
class COperation
{
public:
    // 构造
    COperation() : dwNumberA(0), dwNumberB(0), dwResult(0) {}
    // 成员数据操作
    double getNumberA() { return dwNumberA; }
    double getNumberB() { return dwNumberB; }
    void setNumberA( const double dwNumber ) { dwNumberA = dwNumber; }
    void setNumberB( const double dwNumber ) { dwNumberB = dwNumber; }
    virtual double getResult() { return dwResult; }// 虚函数
protected:
    double dwNumberA;
    double dwNumberB;
    double dwResult;
};
// 加法子类
class  COperationAdd : public COperation
{
public:
    double getResult()
    {
        return dwNumberA + dwNumberB;
    }
};
// 减法子类
class  COperationSub : public COperation
{
public:
    double getResult()
    {
        return dwNumberA - dwNumberB;
    }
};
// 乘法子类
class  COperationMul : public COperation
{
public:
    double getResult()
    {
        return dwNumberA * dwNumberB;
    }
};
// 除法子类
class  COperationDiv : public COperation
{
public:
    double getResult()
    {
        if ( 0 == dwNumberB )
        {
            return 0;
        }
        return dwNumberA / dwNumberB;
    }
};
// 运算工厂类
class COperationFactory
{
public:
    static COperation* createOperation( char chOper )
    {
        switch ( chOper )
        {
        case '+':
            return new COperationAdd();
            break;
        case '-':
            return new COperationSub();
            break;
        case '*':
            return new COperationMul();
            break;
        case '/':
            return new COperationDiv();
            break;
        default:
            return new COperation();
            break;
        }
    }
};

#pragma once
/********************************
*
* 简单工厂模式应用二：商场收银系统
*
********************************/
// 现金收费抽象类
class CashSuper
{
public:
    // 构造
    CashSuper() : dwTotal(0) {};
    virtual double dwAcceptCash( double dwMoney )
    { 
        dwTotal = dwMoney;
        return dwTotal;
    }
protected:
private:
    // 总价
    double dwTotal;
};
// 正常收费子类
class CashNormal : public CashSuper
{
public:
    double dwAcceptCash( double dwMoney )
    {
        // 正常收费，原价返回
        return dwMoney;
    }
protected:
private:
};
// 打折收费子类
class CashRebate : public CashSuper
{
public:
    CashRebate() : dwMoneyRebate(1){};
    CashRebate( double dwMoney ) : dwMoneyRebate(dwMoney) {};
    double dwAcceptCash( double dwMoney )
    {
        return dwMoney * dwMoneyRebate;
    }
protected:
private:
    double dwMoneyRebate;// 折扣率
};
// 返利收费子类
class CashReturn : public CashSuper
{
public:
    CashReturn() : dwMoneyCondition(300), dwMoneyReturn(100) {};
    CashReturn( double dwCondition, double dwReturn ) 
        : dwMoneyCondition(dwCondition), 
        dwMoneyReturn(dwReturn) {};
    double dwAcceptCash( double dwMoney )
    {
        double dwResult = dwMoney;
        if ( dwMoney > dwMoneyCondition )
        {
            // 大于返利条件
            dwResult = dwMoney - (int)dwMoney / (int)dwMoneyCondition * dwMoneyReturn;
        }
        return dwResult;
    }
protected:
private:
    double dwMoneyCondition;
    double dwMoneyReturn;
};
// 现金收费工厂类
class CashFactory
{
public:
    CashSuper* CreateCashAccept( char cType )
    {
        switch ( cType )
        {
            // 正常
        case 'n':
        case 'N':
            return new CashNormal();
            break;
            // 返利
        case 'r':
        case 'R':
            return new CashReturn( 300, 100 );
            break;
            // 打折
        case 't':
        case 'T':
            return new CashRebate( 0.8 );
            break;
        default:
            return new CashSuper();
            break;
        }
    }
protected:
private:
};