设计模式之简单工厂模式（C++）

简单工厂模式，主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。优点：适用于不同情况创建不同的类时。缺点：客户端必须要知道基类和工厂类，耦合性差。需要根据不同的需求创建不同的类。添加类的时候需要更爱工厂类。
以四则运算为例，其UML图如下：

在客户端中给简单工厂类传递相关参数，工厂根据参数判断要create什么类型的对象，然后返回该对象。示例代码如下：

// SimpleFactoryModel.h文件
#pragma once

// 操作基类
template<typename T>
class COperator
{
public:
	virtual T getResult() = 0;
	virtual void setArgs(T lpa, T rpa);
protected:
	T lah, rah;
};

template<typename T>
void COperator<T>::setArgs(T lpa, T rpa)
{
	lah = lpa;
	rah = rpa;
}
// 加法类
template<typename T>
class CAddOperator : public COperator<T>
{
public:
	virtual T getResult()
	{
		return COperator<T>::lah + COperator<T>::rah;
	}
};
// 减法类
template<typename T>
class CSubOperator : public COperator<T>
{
public:
	virtual T getResult()
	{
		return COperator<T>::lah - COperator<T>::rah;
	}
};
// 乘法类
template<typename T>
class CMulOperator : public COperator<T>
{
public:
	virtual T getResult()
	{
		return COperator<T>::lah * COperator<T>::rah;
	}
};
// 除法类
template<typename T>
class CDivOperator : public COperator<T>
{
public:
	virtual T getResult()
	{
		if (0 == COperator<T>::rah)
		{
			std::cout << "除数不能为0" << std::endl;
			return 0;
		}
		return COperator<T>::lah / COperator<T>::rah;
	}
};
// 工厂类
template<typename T>
class CCalculatorFactory
{
public:
	static COperator<T> * createObject(char c);
};

template<typename T>
COperator<T> * CCalculatorFactory<T>::createObject(char c)
{
	COperator<T> * oper;
	switch (c)
	{
	case '+':
		oper = new CAddOperator<T>();
		break;
	case '-':
		oper = new CSubOperator<T>();
		break;
	case '*':
		oper = new CMulOperator<T>();
		break;
	case '/':
		oper = new CDivOperator<T>();
		break;
	default:
		oper = new CAddOperator<T>();
		break;
	}
	return oper;
}

测试代码如下：

#include <iostream>
#include "SimpleFactoryModel.h"

int main()
{
	using namespace std;
    // 创建对象
	COperator<double> *p = CCalculatorFactory<double>::createObject('/');
	p->setArgs(23.23, 10.74);

	cout << p->getResult() << endl;
	delete p;

	p = CCalculatorFactory<double>::createObject('+');
	p->setArgs(23.23, 10.74);
	cout << p->getResult() << endl;
	delete p;

	p = CCalculatorFactory<double>::createObject('-');
	p->setArgs(23.23, 10.74);
	cout << p->getResult() << endl;
	delete p;

	p = CCalculatorFactory<double>::createObject('*');
	p->setArgs(23.23, 10.74);
	cout << p->getResult() << endl;
	delete p;

	getchar();
	return 0;

	getchar();
	return 0;
}

测试输出如下：

简单工厂模式破坏了开放-封闭原则，当想添对象类型的时候，例如上例中想添加一个‘^’的运算，则需要添加一个乘方类并且需要修改简单工厂类。这是简单工工厂模式的一个缺点，因为我们最好遵循只添加不修改的原则，即开放-封闭原则。