C++设计模式四、工厂模式。

本篇介绍设计模式四---工厂模式之计算器实现。

学习本篇之前要先掌握简单工厂模式，请参考上篇，链接为：

https://blog.csdn.net/qq_39795581/article/details/88776558

        之所以把本篇放在简单工厂模式之后，是因为此篇是简单工厂模式的进阶篇。简单模式已经可以完成通过工厂来成产你想要的对象，但是你有没有发现，在上篇计算器程序中，你如果想要新增加一个运算，你就要把工厂给改造，增加一个case分支，这样做很合情合理，但是却违背了C++设计中的开放--封闭原则。此原则简单来说就是当我们设计完一个产品时候，如果有新的需求，我们希望进行扩展，而不是对原来的系统大作周张的去修改。也就是说，我们是增加代码，而不是改变原有的代码，当需求变化发生时，我们就创建抽象来隔离以后将要发生同类的变化。 

工厂模式：定义一个用于创建对象的接口，让子类决定去实例化哪一个类。

下面是代码实现：

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
class Operation
{
private:
	double A, B;
public:
	double GetA() const { return A; }
	double GetB() const { return B; }
	void SetA(double x) { A = x; }
	void SetB(double y) { B = y; }
	double virtual GetResult() { return 0; }
	Operation()
	{
		A = 0;
		B = 0;
	}
};

class Add : public Operation
{
public:
	double GetResult()
	{
		return GetA() + GetB();
	}
};

class Sub : public Operation
{
public:
	double GetResult()
	{
		return GetA() - GetB();
	}
};

class Mul : public Operation
{
public:
	double GetResult()
	{
		return GetA()*GetB();
	}
};

class Div : public Operation
{
public:
	double GetResult()
	{
		return GetA() / GetB();
	}
};

class SimpleFactory
{
public:
	virtual Operation * CreateOpeartor() = 0;
};
class ADD :public SimpleFactory
{
public:
	Operation * CreateOpeartor()
	{
		return new Add;
	}	
};
class SUB :public SimpleFactory
{
public:
	Operation * CreateOpeartor()
	{
		return new Sub;
	}
};
class DIV :public SimpleFactory
{
public:
	Operation * CreateOpeartor()
	{
		return new Div;
	}
};
class MUL :public SimpleFactory
{
public:
	Operation * CreateOpeartor()
	{
		return new Mul;
	}
};
int main()
{
	double A = 0;
	double B = 0;
	char ch = '\0';
	ADD p1;
	SUB p2;
	MUL p3;
	DIV p4;
	cin >> A >> ch >> B;
	Operation *p = new Operation();
	switch (ch)
	{
		case '+':
			p = p1.CreateOpeartor();
			break;
		case '-':
			p = p2.CreateOpeartor();
			break;
		case '*':
			p = p3.CreateOpeartor();
			break;
		case '/':
			p = p4.CreateOpeartor();
			break;
		
	}
	p->SetA(A);
	p->SetB(B);
	cout << p->GetResult() << endl;
}

几点解释，大佬绕行：

1、可以看到在工厂类SimpleFactory中我们定义了一个纯虚函数，这就说明了此类是一个抽象类，并且这个定义是虚函数，也就是会有相应的子类去完成具体的功能，这也就是多态。

2、此设计没有违背开放--封闭原则，也就是当我们新增加运算的时候，我们的工厂类不会发生变化，我们只需要增加相应的运算类，并在运算类中完成相应的实现，这就体现了C++的可维护性以及可扩展性。

说人话：开放封闭原则就是：想要增加功能的情况下，我们不希望修改原来存在的代码，只需要扩展原来的代码即可。

3、你会发现我们把case语句由原先的工厂类转移到了主函数中，代码量其实改变不大，但是却做到了可扩展性、可维护性。

说人话：可以看到简单工厂模式情况下，我们想要增加运算类型的话，就必须修改工厂（简单工厂模式的核心思想就是，输入不同的类型，产出不同的对象），但是在工厂模式中，我想要增加运算，比如增加平方的运算，我只需要增加一个继承于SimpleFactory的平方类，返回一个继承于Opreation的具体时间平方运算的类即可。