学雷锋之工厂方法模式学习笔记[C++版]

/************************************************************************
* 工厂方法模式学习笔记[C++]
* Author：  陈相礼
* Time：    2009.12.03
* Compiler: VC8
************************************************************************/
#define _CALC_
#include "FactoryPattern.h"
#ifdef _CALC_
#include "FactoryPattern1.h"
#else
#include "FactoryPattern2.h"
#endif
#include <iostream>
#include <string>
using namespace std;
void main( void )
{
    //------------------工厂方法模式原理类测试-------------------
    ICreator *creator = new CConcreteCreatorA();
    IProductor *productor = creator->cFactoryMethod();
    productor->vGetResult();
    delete(creator);
    //------------------计算器之工厂方法模式类测试-------------------
#ifdef _CALC_
    IFactory *operFactory = new CAddFactory();
    COperation *oper = operFactory->cCreateOperation();
    oper->setNumberA( 1 );
    oper->setNumberB( 2 );
    double dwResult = oper->getResult();
    delete(operFactory);
#else
    //------------------学雷锋之工厂方法模式类测试-------------------
    // 在校大学生
    IFactory *factory = new CUndergraduateFactory();
    CLeiFeng *daxuesheng = factory->cCreateLeiFeng();
    daxuesheng->vSweep();
    daxuesheng->vWash();
    daxuesheng->vBuyRice();
    delete(factory);
    // 志愿者
    factory = new CVolunteerFactory();
    CLeiFeng *volunteer = factory->cCreateLeiFeng();
    volunteer->vSweep();
    volunteer->vWash();
    volunteer->vBuyRice();
    delete(volunteer);
#endif
}
/************************************************************************
* 小结：
*   1、工厂方法模式克服了简单工厂模式违背的开放-封闭原则的缺点，又保持
*      了封装对象创建过程的优点。
*   2、工厂方法模式和简单工厂模式都是集中封装了对象的创建，使得要更换对
*      象时，不需要做大的改动就可以实现，降低了客户程序与船票对象的耦合。
*   3、工厂方法模式是简单工厂模式的进一步抽象和推广。
*   4、由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服
*      了它的缺点。但缺点是由于每增加一个产品，就需要加一个产品工厂的类，
*      增加了额外的开发量。
************************************************************************/

#pragma once
/**********************************************
* 工厂方法模式原理：
*   定义一个用于创建对象的接口，让子类决定
* 实例化哪一个类。工厂方法使一个类的实例化
* 延迟到其子类。
***********************************************/
#include <iostream>
#include <string>
using namespace std;
//---------------------------------------------
// 抽象角色
// 定义工厂方法所创建的对象的接口。
class IProductor
{
public:
    virtual void vGetResult() = 0;
};
//---------------------------------------------
// 产品子类
// 具体产品，实现了Product接口。
class CConcreteProductorA : public IProductor
{
public:
    void vGetResult()
    {
        cout << "具体产品A" << endl;
    }
};
// 同上
class CConcreteProductorB : public IProductor
{
public:
    void vGetResult()
    {
        cout << "具体产品B" << endl;
    }
};
// 同上
class CConcreteProductorC : public IProductor
{
public:
    void vGetResult()
    {
        cout << "具体产品C" << endl;
    }
};
//---------------------------------------------
// 工厂方法接口
// 返回一个IProductor类型的对象。
class ICreator
{
public:
    virtual IProductor* cFactoryMethod() = 0;
protected:
private:
};
//---------------------------------------------
// 重定义工厂方法
// 返回一个CConcreteProductorA实例。
class CConcreteCreatorA : public ICreator
{
public:
    IProductor* cFactoryMethod()
    {
        return new CConcreteProductorA();
    }
protected:
private:
};
// 同上
class CConcreteCreatorB : public ICreator
{
public:
    IProductor* cFactoryMethod()
    {
        return new CConcreteProductorB();
    }
protected:
private:
};
// 同上
class CConcreteCreatorC : public ICreator
{
public:
    IProductor* cFactoryMethod()
    {
        return new CConcreteProductorC();
    }
protected:
private:
};

#pragma once
/**********************************************
* 
* 工厂方法模式应用：再论计算器
*
***********************************************/
#include <iostream>
using namespace std;
// 运算抽象类
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 IFactory
{
public:
    virtual COperation* cCreateOperation() = 0;
protected:
private:
};
// 加法类工厂
class CAddFactory : public IFactory
{
public:
    COperation* cCreateOperation()
    {
        return new COperationAdd();
    }
protected:
private:
};
// 减法类工厂
class CSubFactory : public IFactory
{
public:
    COperation* cCreateOperation()
    {
        return new COperationSub();
    }
protected:
private:
};
// 乘法类工厂
class CMulFactory : public IFactory
{
public:
    COperation* cCreateOperation()
    {
        return new COperationMul();
    }
protected:
private:
};
// 除法类工厂
class CDivFactory : public IFactory
{
public:
    COperation* cCreateOperation()
    {
        return new COperationDiv();
    }
protected:
private:
};
/************************************************************************
* 小结：[工厂方法与简单工厂]
*   1、简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据
*      客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与
*      具体产品的依赖。
*   2、工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算
*      类，选择判断的问题还是存在的，也就是说，工厂方法把简单工厂的
*      内部逻辑判断转移到了客户端代码来进行。你要想加功能，本来是改
*      工厂类的，而现在是修改客户端。
************************************************************************/

#pragma once
/**********************************************
* 
* 工厂方法模式应用：学雷锋
* 
***********************************************/
#include <iostream>
#include <string>
using namespace std;
// 雷锋类
class CLeiFeng
{
public:
    void vSweep()
    {
        cout << "扫地！" << endl;
    }
    void vWash()
    {
        cout << "洗衣！" << endl;
    }
    void vBuyRice()
    {
        cout << "买米！" << endl;
    }
protected:
private:
};
// 学雷锋的大学生
class CUndergraduate : public CLeiFeng
{
public:
protected:
private:
};
// 社区志愿者类
class CVolunteer : public CLeiFeng
{
public:
protected:
private:
};
// 简单雷锋工厂
class CSimpleFactory
{
public:
    CLeiFeng* cCreateLeiFeng( char cType )
    {
        switch ( cType )
        {
        case 'U':;
        case 'u':
            return new CUndergraduate();
            break;
        case 'V':
        case 'v':
            return new CVolunteer();
            break;
        default:
            return new CLeiFeng();
            break;
        }
    }
protected:
private:
};
//-------------------------------------------
// 雷锋工厂方法模式
// 雷锋工厂接口
class IFactory
{
public:
    virtual CLeiFeng* cCreateLeiFeng() = 0;
protected:
private:
};
// 学雷锋的大学生工厂
class CUndergraduateFactory : public IFactory
{
public:
    CLeiFeng* cCreateLeiFeng()
    {
        return new CUndergraduate();
    }
protected:
private:
};
// 社区志愿者工厂
class CVolunteerFactory : public IFactory
{
public:
    CLeiFeng* cCreateLeiFeng()
    {
        return new CVolunteer();
    }
protected:
private:
};