设计模式之简单工厂模式详解

引言

在很多情况下，在实现多个同类但不一样的功能时，我们需要通过判断来产生不同类的具体实例对象，进而来实现不同的功能。比如在实现计算功能时，我们需要通过判断运算符来确定，到底是按照加减法还是乘除法来运算，于是，可以有如下代码来完成操作：

#include<iostream>
using std::cout;
using std::cin;
int main()
{
	//模拟GUI界面
	char operator;
	float op1,op2;
	float res = 0;
	cout<<"请输入运算符:"<<endl;
	cin>>operator;
	//模拟GUI界面
	cout<<"请分别输入两个运算数:"<<endl;
	cin>>op1>>op2;
	//判断
	if(operator=='+')
	{
		res = op1+op2;
	}else if(operator=='-')
	{
		res = op1-op2;
	}else if(operator=='*')
	{
		res = op1*op2;
	}else if(operator=='/')
	{
		assert(op2 != 0);
		res = op1/op2;
	}
	cout<<"result is:"<<res<<endl;
	system("pause");
}

上述程序能完美实现四则运算，代码也很简单。但有个很大的问题，main函数的地位相当于客户端，客户端逻辑上应当使用各种功能接口而无需知道其内部具体实现，不该让客户端模块中出现多种功能的具体实现。比如你去餐厅吃饭，餐厅提供给你的接口应当为：点菜、吃饭、付钱，这几个功能内部的逻辑修改后，并不会影响客户的用餐流程；而不应该是：吃什么菜、菜要几百克、菜怎么炒、放一勺盐还是两勺、你要多大的餐具等等。

解决方案

将判断逻辑封装在接口中，并对此处的功能变化（唯一的变化就是，何种运算符）进行抽象，于是简单工厂模式诞生了：将运算符进行抽象，每个运算符都能够计算但具体的计算规则不同，每个运算式的操作符不同，需要用一个简单工厂来进行运算符的生成。一个具体的简单工厂模式的UML类图如下：

简单工厂模式的类图确实较为简单。
对于四则运算而言，功能产品类的定义如下：

template<typename T,typename U,typename K>
class Calculator {
	public:
		K virtual getResult(const T&first,const U &second)=0;
};
//具体实现不同的计算方法

template<typename T, typename U, typename K>
class Add :public Calculator<T,U,K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			return static_cast<K>(first) + static_cast<K>(second);
		}
};

template<typename T, typename U, typename K>
class Subtract :public Calculator<T,U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			return static_cast<K>(first) - static_cast<K>(second);
		}
};

template<typename T, typename U, typename K>
class Multiply :public Calculator<T, U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			return static_cast<K>(first) * static_cast<K>(second);
		}
};

template<typename T, typename U, typename K>
class Divide :public Calculator<T, U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			assert(second != 0);
			return static_cast<K>(first) / static_cast<K>(second);
	}
};

template<typename T, typename U, typename K>
class Unimplement :public Calculator<T, U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			cout << "此功能暂未实现。。。。。。" << endl;
			//该返回值并无任何意义
			return static_cast<K>(INT32_MIN);
	}
};

工厂类的定义如下：

在这里插入代码片

具体代码实现

#include<iostream>
#include<cassert>
#include<string>

using namespace std;

//实现运算符、运算数与具体调用者的简单分离 

//但由于运算符不同 因此计算方法也不同 因此将计算方法抽象出来
//通过第三个类型来设置运算精度
template<typename T,typename U,typename K>
class Calculator {
	public:
		K virtual getResult(const T&first,const U &second)=0;
};
//具体实现不同的计算方法

template<typename T, typename U, typename K>
class Add :public Calculator<T,U,K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			return static_cast<K>(first) + static_cast<K>(second);
		}
};

template<typename T, typename U, typename K>
class Subtract :public Calculator<T,U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			return static_cast<K>(first) - static_cast<K>(second);
		}
};

template<typename T, typename U, typename K>
class Multiply :public Calculator<T, U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			return static_cast<K>(first) * static_cast<K>(second);
		}
};

template<typename T, typename U, typename K>
class Divide :public Calculator<T, U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			assert(second != 0);
			return static_cast<K>(first) / static_cast<K>(second);
	}
};

template<typename T, typename U, typename K>
class Unimplement :public Calculator<T, U, K> {
	public:
		K virtual getResult(const T& first, const U& second)override {
			cout << "此功能暂未实现。。。。。。" << endl;
			//该返回值并无任何意义
			return static_cast<K>(INT32_MIN);
	}
};

//简单工厂来啦
template<typename T, typename U, typename K>
class SimpleFactor {
	public:
		static Calculator<T, U, K>* produce(const char& ch)
		{
			Calculator<T, U, K>* ptr = nullptr;
			switch (ch)
			{
				case '+':
					ptr = new Add<T, U, K>();
					break;
				case '-':
					ptr = new Subtract<T, U, K>();
					break;
				case '*':
					ptr = new Multiply<T, U, K>();
					break;
				case '/':
					ptr = new Divide<T, U, K>();
					break;
				default:
					ptr = new Unimplement<T, U, K>();
					break;
			}
			return ptr;
		}
};

int main()
{
	//智能指针托管内存
	unique_ptr<Calculator<int, int, double>>calc(std::move(SimpleFactor<int,int,double>::produce('/')));
	auto res = calc->getResult(5, 6);
	cout << "result is :" << res << endl;

	system("pause");
	return 0;
}

这就是简单工厂模式的一个小例子，它将多个同类不同样的变化给抽象出来，使得客户端不需要因为业务逻辑的改变而改变自身功能的使用，但通过代码可以发现，简单工厂模式并不符合开闭原则的要求，因为它对修改开放了，所以，这里引出一个以后要分享的模式——工厂模式。