引言
在很多情况下，在实现多个同类但不一样的功能时，我们需要通过判断来产生不同类的具体实例对象，进而来实现不同的功能。比如在实现计算功能时，我们需要通过判断运算符来确定，到底是按照加减法还是乘除法来运算，于是，可以有如下代码来完成操作：
#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;
}
这就是简单工厂模式的一个小例子，它将多个同类不同样的变化给抽象出来，使得客户端不需要因为业务逻辑的改变而改变自身功能的使用，但通过代码可以发现，简单工厂模式并不符合开闭原则的要求，因为它对修改开放了，所以，这里引出一个以后要分享的模式——工厂模式。