简单的工厂模式

大学阶段一直没有好好地学习过设计模式，这是一个遗憾。

在朋友的推荐下，买了程杰的《大话设计模式》。此书甚好，把枯燥的技术思想写的十分活泼、有趣。今天学习了第一章：工厂模式，然后我就用C++实现了一下书中的计算器。也是想借此练一下手。

目前只实现了加、减、乘和除四种运算，像书中说的，我们需要考虑以后的扩展性，比如以后加上其他的运算等等。

建立了一个基类：Operation，然后派生出四个类（加减乘除）：OperationAdd、OperationSub、OperationMul、OperationDiv。如果以后要加入其他运算方法，同样直接继承基类Operation就行。

Operation.h

#pragma once
class Operation
{
public:
	Operation(void);
	//Operation(double A,double B);
	~Operation(void);
	void GetNumbles(double A,double B);
	virtual double GetResult();
protected:
	double numbleA;
	double numbleB;
};

OperationAdd.h

#pragma once
#include "operation.h"
class OperationAdd :
	public Operation
{
public:
	OperationAdd(void);
	~OperationAdd(void);
	virtual double GetResult();
};

OperationDiv.h

#pragma once
#include "operation.h"
#include "ExceptionNum.h"
class OperationDiv :
	public Operation
{
public:
	OperationDiv(void);
	~OperationDiv(void);
	virtual double GetResult();
};

OperationDiv.cpp

#include "StdAfx.h"
#include "OperationDiv.h"


OperationDiv::OperationDiv(void)
{
}


OperationDiv::~OperationDiv(void)
{
}

double OperationDiv::GetResult()
{
	if (numbleB == 0)
	{
		throw ExceptionNum("The divisor is Zero");
	}
	return numbleA / numbleB;
}

其余的省略。在OperationDiv类的成员函数中，加入了异常判断，因为这里的除数不能为0.

建立了工厂类OperationFactory用来产生各种类型运算方法的对象。

OperationFactory.h

#pragma once
#include "Operation.h"
class OperationFactory
{
public:
	OperationFactory(void);
	~OperationFactory(void);
	static Operation* CreateOperation(char operate);
};

OperationFactory.cpp

#include "StdAfx.h"
#include "OperationFactory.h"
#include "OperationAdd.h"
#include "OperationDiv.h"
#include "OperationMul.h"
#include "OperationSub.h"
#include "ExceptionNum.h"


OperationFactory::OperationFactory(void)
{
}

OperationFactory::~OperationFactory(void)
{
}

Operation* OperationFactory::CreateOperation(char operate)
{
	Operation* operation;
	switch(operate)
	{
	case '+':
		operation = new OperationAdd();
		break;
	case '-':
		operation = new OperationSub();
		break;
	case '*':
		operation = new OperationMul();
		break;
	case '/':
		operation = new OperationDiv();
		break;
	default:throw ExceptionNum("error operate");
		break;
	}
	return operation;
}

这里同样加入了异常判断，因为如果目前输入的运算符号不正确，需要进行异常抛出。

以下是测试代码：

// DesignPattern.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include "Operation.h"
#include "OperationFactory.h"
#include "ExceptionNum.h"

using std::cin;
using std::cout;
using std::endl;

int _tmain(int argc, _TCHAR* argv[])
{
	char operate;
	double numbleA,numbleB;
	Operation* operation;
	int exc = -1;

	while(exc == -1)//if exc == -1,it takes enter error.
	{
		cout<<"please input two numble."<<endl;
		cin>>numbleA>>numbleB;
		cout<<"please input a operate."<<endl;
		cin>>operate;
		//Operation* operation = new Operation(numbleA,numbleB);
		try
		{
			operation = OperationFactory::CreateOperation(operate);
			operation->GetNumbles(numbleA,numbleB);

			cout<<operation->GetResult();
			exc = 0;
		}
		catch(ExceptionNum en)
		{
			exc = en.Myexport();
		}
	}
	getchar();
	getchar();
	return 0;
}

以上就是简单的实现。

我所理解的工厂模式就是指当需要扩展类似的方法时，比如扩展计算器的运算啦，数据库的迁移时带来的数据处理的类的替换啦，跨平台啦等等之类的，都需要提前用工厂模式进行设计，然后在扩展到哦时候就十分的省力气，只需要改动工厂就行了，而不必大动干戈的改动上层代码。