大话设计模式04-工厂方法模式-2020-9-22

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

class Operator
{
public:
	Operator(double iVal1, double iVal2) :m_val1(iVal1), m_val2(iVal2){};
	virtual double getResult() = 0;
	virtual ~Operator(){};
protected:
	double m_val1;
	double m_val2;
};

class OperatorAdd :public Operator
{
public:
	OperatorAdd(double iVal1, double iVal2) :Operator(iVal1,iVal2){};
	double getResult() override
	{
		return m_val1 + m_val2; 
	}
};

class OperatorSub :public Operator
{
public:
	OperatorSub(double iVal1, double iVal2) :Operator(iVal1, iVal2){};
	double getResult() override
	{
		return m_val1 - m_val2;
	}
};

class OperatorMuti :public Operator
{
public:
	OperatorMuti(double iVal1, double iVal2) :Operator(iVal1, iVal2){};
	double getResult() override
	{
		return m_val1 * m_val2;
	}
};

class OperatorDev :public Operator
{
public:
	OperatorDev(double iVal1, double iVal2) :Operator(iVal1, iVal2){};
	double getResult() override
	{
		if (m_val2==0)
		{
			cout << "除数不能为0！" << endl;
			throw exception("除数不能为0！");
		}
		return m_val1 / m_val2;
	}
};

class IOperatorFactory
{
public:
	IOperatorFactory(double ival1, double ival2):m_ival1(ival1),m_ival2(ival2){}
	virtual Operator *createOperator() = 0;
	~IOperatorFactory(){};
protected:
	double m_ival1;
	double m_ival2;
};

class OperatorAddFactory :public IOperatorFactory
{
public:
	OperatorAddFactory(double ival1, double ival2) :IOperatorFactory(ival1,ival2){}
	Operator *createOperator() override
	{
		return new OperatorAdd(m_ival1,m_ival2);
	}
};

class OperatorSubFactory :public IOperatorFactory
{
public:
	OperatorSubFactory(double ival1, double ival2) :IOperatorFactory(ival1, ival2){}
	Operator *createOperator() override
	{
		return new OperatorSub(m_ival1, m_ival2);
	}
};

class OperatorMutiFactory :public IOperatorFactory
{
public:
	OperatorMutiFactory(double ival1, double ival2) :IOperatorFactory(ival1, ival2){}
	Operator *createOperator() override
	{
		return new OperatorMuti(m_ival1, m_ival2);
	}
};

class OperatorDevFactory :public IOperatorFactory
{
public:
	OperatorDevFactory(double ival1, double ival2) :IOperatorFactory(ival1, ival2){}
	Operator *createOperator() override
	{
		return new OperatorDev(m_ival1, m_ival2);
	}
};

int main()
{
	IOperatorFactory *pFact = new OperatorMutiFactory(2.4, 4.5);
	Operator *pOper = pFact->createOperator();
	cout << pOper->getResult() << endl;
	delete pOper;
	delete pFact;
	system("pause");
}