简单工厂模式（Simple Factory）

简单工厂模式包含三种角色：

1、工厂(Creator)角色：简单工厂模式的核心，负责实现所有实例的内部逻辑。工厂类可以被外部直接调用，创建所需的产品对象。

2、抽象产品(Product)角色：所有产品对象的父类，负责描述所有实例所共有的接口。

3、具体产品(Concrete Product)角色：所有创建的对象所对应的具体的类。

//SimpleFactory.h
#include <iostream>
#include <string>
using namespace std;

class Operation		//所有运算类的父类
{
protected:
	int numberA;
	int numberB;
public:
	void SetNumberA(int numberA)
	{
		this->numberA = numberA;
	}
	void SetNumberB(int numberB)
	{
		this->numberB = numberB;
	}
	virtual int GetResult()
	{
		return 0;
	}
};

class Add: public Operation		//加运算
{
public:
	virtual int GetResult()
	{
		return numberA + numberB;
	}
};

class Subtract: public Operation	//减运算
{
public:
	virtual int GetResult()
	{
		return numberA - numberB;
	}
};

class Multiply: public Operation	//乘运算
{
public:
	virtual int GetResult()
	{
		return numberA * numberB;
	}
};

class Divide: public Operation		//除运算
{
public:
	virtual int GetResult()
	{
		if (numberB == 0)
		{
			return 0;
		}
		return numberA / numberB;
	}
};

class OperationFactory				//生产运算类的工厂类
{
public:
	static Operation* CreateOperation(char operate)
	{
		Operation *oper;
		switch (operate)
		{
		case '+':
			oper = new Add();
			break;
		case '-':
			oper = new Subtract();
			break;
		case '*':
			oper = new Multiply();
			break;
		case '/':
			oper = new Divide();
			break;
		default:
			oper = NULL;
		}
		return oper;
	}
};

　　

//SimpleFactory.cpp
#include "SimpleFactory.h"
using namespace std;

int main()
{
	Operation *oper;
	char operate;
	int numberA, numberB;
	cin>>numberA>>numberB;
	getchar();
	cin>>operate;
	OperationFactory factory;
	oper = factory.CreateOperation(operate);
	oper->SetNumberA(numberA);
	oper->SetNumberB(numberB);
	int result = oper->GetResult();
	cout<<result<<endl;
	return 0;
}

　

优点：工厂类中包含了必要的逻辑判断，根据外界给定的信息决定创建具体的对象。通过工厂类，外界可以从直接创建具体产品对象的局面摆脱出来，仅需要负责消费对象就可以了，而不必考虑这些对象是如何创建和组织的，明确了各自的职责和权利。

缺点：工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新类，则需要改变工厂类。

适用场景：

1、工厂类负责创建的对象比较少。

2、客户只知道传入工厂类的参数，对于如何创建对象不关心。