Design Pattern之工厂方法模式

在本文之前，已经介绍过简单工厂模式，简单工厂模式只有一个工厂，该工厂负责产生所有的运算类，如果增加一个运算类，不仅需要修改工厂类，还需要修改客户端类，这违反了设计模式所提倡的开放-封闭原则。本文所说的工厂方法模式就是在之前的简单工厂模式前提下增加了各种运算方法的工厂类，UML图如下：

相比较简单工厂模式，只增加了运算符的工厂类，下面是代码demo，运算符类这里就不列举，只给出工厂类以及客户端代码。

#ifndef  _OPERATIONFACTORY_H
#define  _OPERATIONFACTORY_H
#include "operation.h"
//#define  ADD   0x01
//#define  SUB   0x02
//#define  MUL   0x03
//#define  DIV   0x04
class OperationFactory
{
public:
    OperationFactory(){}
    ~OperationFactory() {}
    virtual Operation* createOperate( ) = 0;
};
#endif // ! _OPERATIONFACTORY_H

//加法工厂
#ifndef __ADD_FACTORY_H
#define __ADD_FACTORY_H


#include "operationfactory.h"
#include "operationadd.h"

class AddFactory: public OperationFactory
{
public:
    AddFactory(){}
    ~AddFactory() {}
    virtual Operation* createOperate( )
    {
        return ( new OperationAdd() ) ;
    }

};

#endif // !__ADD_FACTORY_H

//减法工厂
#ifndef __SUB_FACTORY_H
#define __SUB_FACTORY_H


#include "operationfactory.h"
#include "operationsub.h"

class SubFactory : public OperationFactory
{
public:
    SubFactory() {}
    ~SubFactory() {}
    virtual Operation* createOperate()
    {
        return (new OperationSub());
    }

};

#endif // !__SUB_FACTORY_H

//乘法工厂
#ifndef __MUL_FACTORY_H
#define __MUL_FACTORY_H


#include "operationfactory.h"
#include "operationmul.h"

class MulFactory : public OperationFactory
{
public:
    MulFactory() {}
    ~MulFactory() {}
    virtual Operation* createOperate()
    {
        return (new OperationMul());
    }

};

#endif // !__MUL_FACTORY_H

//除法工厂
#ifndef __DIV_FACTORY_H
#define __DIV_FACTORY_H


#include "operationfactory.h"
#include "operationdiv.h"

class DivFactory : public OperationFactory
{
public:
    DivFactory() {}
    ~DivFactory() {}
    virtual Operation* createOperate()
    {
        return (new OperationDiv());
    }

};

#endif // !__DIV_FACTORY_H

//客户端代码
#include "addfactory.h"
#include "subfactory.h"
#include "mulfactory.h"
#include "divfactory.h"
#include <tchar.h>
#include <stdio.h>

int _tmain(int argc, TCHAR* argv[])
{
    Operation *oper = NULL;
    OperationFactory *addFactory = new AddFactory();
    oper = addFactory->createOperate( );
    oper->SetValue(3, 97);
    double result = oper->GetResult();
    printf("add:reulst=%f\n", result);
    delete oper;
    oper = NULL;
    delete addFactory;
    addFactory = NULL;

    OperationFactory *subFactory = new SubFactory();
    oper = subFactory->createOperate();
    oper->SetValue(9,4);
    result = oper->GetResult();
    printf("sub:reulst=%f\n", result);
    delete oper;
    oper = NULL;
    delete subFactory;
    subFactory = NULL;

    OperationFactory *mulFactory = new MulFactory();
    oper = mulFactory->createOperate();
    oper->SetValue(9, 4);
    result = oper->GetResult();
    printf("mul:reulst=%f\n", result);
    delete oper;
    oper = NULL;
    delete mulFactory;
    mulFactory = NULL;

    OperationFactory *divFactory = new DivFactory();
    oper = divFactory->createOperate();
    oper->SetValue(9, 4);
    result = oper->GetResult();
    printf("div:reulst=%f\n", result);
    delete oper;
    oper = NULL;
    delete divFactory;
    divFactory = NULL;

    return 0;
}