【5】工厂模式

设计场景：

工厂模式实现计算机基础加减乘除运算

---

原因分析：

简单工厂模式与工厂模式的区别
写了一半还没写完，先睡了

---

代码如下：

#include"factory.h"
#include"add_factory.h"
#include"sub_factory.h"
#include"mul_factory.h"
#include"div_factory.h"
#include"add_operation.h"
#include"sub_operation.h"
#include"mul_operation.h"
#include"div_operation.h"


// 工厂模式
int main()
{
	while (true)
	{
		double numA = 0.00;
		double numB = 0.00;
		char operate;

		cout << "输入第一个数据：";
		cin >> numA;

		cout << "输入第二个数据：";
		cin >> numB;

		cout << "输入操作符：";
		cin >> operate;

		FACTORY* operFactory = nullptr;
		OPERATION* oper = nullptr;

		switch (operate)
		{
		case '+':
			operFactory = new ADD_FACTORY();
			oper = operFactory->createOperation();
			oper->setNumberA(numA);
			oper->setNumberB(numB);
			cout << "结果：" << oper->getResult() << endl;
			break;
		case '-':
			operFactory = new SUB_FACTORY();
			oper = operFactory->createOperation();
			oper->setNumberA(numA);
			oper->setNumberB(numB);
			cout << "结果：" << oper->getResult() << endl;
			break;
		case '*':
			operFactory = new MUL_FACTORY();
			oper = operFactory->createOperation();
			oper->setNumberA(numA);
			oper->setNumberB(numB);
			cout << "结果：" << oper->getResult() << endl;
			break;
		case '/':
			operFactory = new DIV_FACTORY();
			oper = operFactory->createOperation();
			oper->setNumberA(numA);
			oper->setNumberB(numB);
			cout << "结果：" << oper->getResult() << endl;
			break;
		default:
			break;
		}
	}
	system("pause");
	return 0;
}

#pragma once

#include<iostream>
#include<string>
using namespace std;

// 操作类-----基类
class OPERATION
{
public:
	// get
	double getNumberA() { return m_NumberA; }
	double getNumberB() { return m_NumberB; }
	// set
	void setNumberA(double numberA) { m_NumberA = numberA; }
	void setNumberB(double numberB) { m_NumberB = numberB; }

	// 虚函数
	virtual double getResult() { double result = 0; return result; }; // 获取结果值

private:
	double m_NumberA;
	double m_NumberB;
};

#pragma once
#include"operation.h"

// 加法-----派生类
class ADD_OPERATION : public OPERATION
{
public:
	double getResult() override
	{
		return (getNumberA() + getNumberB());
	}
};


#pragma once
#include"operation.h"

// 减法-----派生类
class SUB_OPERATION : public OPERATION
{
public:
	double getResult() override
	{
		return (getNumberA() - getNumberB());
	}
};


#pragma once
#include"operation.h"

// 承法-----派生类
class MUL_OPERATION : public OPERATION
{
public:
	double getResult() override
	{
		return (getNumberA() * getNumberB());
	}
};

#pragma once
#include"operation.h"

// 除法-----派生类
class DIV_OPERATION : public OPERATION
{
public:
	double getResult() override
	{
		if (getNumberB() != 0)
		{
			return (getNumberA() / getNumberB());
		}
		cout << "零不能做除数" << endl;
		abort();
	}
};

#pragma once
#include "operation.h"

// 工厂-----接口-----特殊的抽象类
class FACTORY
{
public:
	// 纯虚函数
	virtual OPERATION* createOperation() = 0;
};

#pragma once
#include"factory.h"
#include"operation.h"
#include"add_operation.h"

// 加法工厂类
class ADD_FACTORY : public FACTORY
{
public:
	// 返回加法操作对象
	OPERATION* createOperation() override
	{
		return new ADD_OPERATION();
	}
};


#pragma once
#include"factory.h"
#include"operation.h"
#include"sub_operation.h"

// 减法工厂类
class SUB_FACTORY : public FACTORY
{
public:
	// 返回加法操作对象
	OPERATION* createOperation() override
	{
		return new SUB_OPERATION();
	}
};


#pragma once
#include"factory.h"
#include"operation.h"
#include"mul_operation.h"

// 承法工厂类
class MUL_FACTORY : public FACTORY
{
public:
	// 返回加法操作对象
	OPERATION* createOperation() override
	{
		return new MUL_OPERATION();
	}
};


#pragma once
#include"factory.h"
#include"operation.h"
#include"div_operation.h"

// 除法工厂类
class DIV_FACTORY : public FACTORY
{
public:
	// 返回加法操作对象
	OPERATION* createOperation() override
	{
		return new DIV_OPERATION();
	}
};