大话设计模式--工厂方法模式 Factory Method -- C++实现

1. 工厂方法模式

定义一个用于创建对象的接口， 让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

和简单工厂模式相比：

A： 简单工厂模式最大的优点在于工厂类中包含有必要的逻辑判断， 根据客户端的选择条件动态实例化相关的类，对客户端来说去除了与具体产品的依赖。

但缺点是 添加新产品时 需要修改工厂类 case， 违背了 "开放-封闭" 原则。

B： 工厂方法模式实现时，需要由客户端来决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在，只是由工厂类内部转移到客户端。



实例：

operation.h -- operation.cpp

#ifndef OPERATION_H
#define OPERATION_H

class Operation
{
public:
Operation();
double virtual getResult();

double strA;
double strB;
double result;
};

#endif // OPERATION_H

#include "operation.h"

Operation::Operation()
{
strA = 0;
strB = 0;
result = 0;
}

double Operation::getResult()
{
return result;
}

operationfunc.h operationfunc.cpp

#ifndef OPERATIONFUNC_H
#define OPERATIONFUNC_H

#include "operation.h"

class OperationAdd : public Operation
{
public:
double getResult();
};

class OperationSub : public Operation
{
public:
double getResult();
};

class OperationMul : public Operation
{
public:
double getResult();
};

class OperationDiv : public Operation
{
public:
double getResult();
};

#include "operationfunc.h"

double OperationAdd::getResult()
{
result = strA + strB;
return result;
}

double OperationSub::getResult()
{
result = strA - strB;
return result;
}

double OperationMul::getResult()
{
result = strA * strB;
return result;
}

double OperationDiv::getResult()
{
result = strA / strB;
return result;
}

factory.h factory.cpp 抽象工厂

#ifndef FACTORY_H
#define FACTORY_H

#include "operation.h"
#include "operationfunc.h"
#include <string>
using namespace std;

class Factory
{
public:
Factory();
virtual Operation* createOperation();
};

#endif // FACTORY_H

#include "factory.h"

Factory::Factory()
{
}

Operation* Factory::createOperation()
{}

addfactory.h addfactory.cpp

#ifndef ADDFACTORY_H
#define ADDFACTORY_H

#include "factory.h"

class AddFactory : public Factory
{
public:
AddFactory();
Operation* createOperation();
};

#endif // ADDFACTORY_H

#include "addfactory.h"

AddFactory::AddFactory()
{
}

Operation* AddFactory::createOperation()
{
return new OperationAdd();
}

subfactory.h subfactory.cpp

#ifndef SUBFACTORY_H
#define SUBFACTORY_H

#include "factory.h"

class SubFactory : public Factory
{
public:
SubFactory();
Operation* createOperation();
};

#endif // SUBFACTORY_H

#include "subfactory.h"

SubFactory::SubFactory()
{
}

Operation* SubFactory::createOperation()
{
return new OperationSub();
}

main.cpp

#include <iostream>
#include "operationfunc.h"
#include "addfactory.h"
#include "subfactory.h"

using namespace std;

int main()
{
cout << "Factory method " << endl;

Factory *factory = new SubFactory();
Operation *oper = factory->createOperation();
oper->strA = 1.1;
oper->strB = 2.3;

cout << "result: " << oper->getResult() << endl;

return 0;
}