设计模式之---简单工厂模式

简单工厂模式：到底要实例化哪个对象，将来会不会增加实例化对象，这时可以考虑用一个单独的类来创造实例的过程，这就是工厂。

以一个2元操作运算来说明：

operator类：

#pragma once

template <class T>
class COperator
{
public:
	COperator(void){};
	virtual	~COperator(void){};
	virtual	T GetResult(T NumberA,T NumberB);
};



#include "Operator.h"

template <class T>
 T COperator<T>::GetResult(T NumberA,T NumberB)
{
  T result=0;

  return result;
}

加法类：

#pragma once
#include "Operator.h"

template <class T>
class CAddOperator:public COperator<T>
{
public:
	CAddOperator(void){};
	~CAddOperator(void){};
	virtual T GetResult(T NumberA,T NumberB);
};

#include "AddOperator.h"


template <class T>
 T CAddOperator<T>::GetResult(T NumberA,T NumberB)
{
	T result;

	result = NumberA + NumberB;

	return result;
}

减法类：

#pragma once
#include "operator.h"

template <class T>
class CSubOperator :public COperator<T>
{
public:
	CSubOperator(void){};
	~CSubOperator(void){};
virtual T GetResult(T NumberA,T NumberB);
};


#include "SubOperator.h"

template <class T>
T CSubOperator<T>::GetResult(T NumberA,T NumberB)
{
	T result= NumberA -NumberB ;

	return result;
}

乘法类：

#pragma once
#include "operator.h"

template <class T>
class CMulOperator :public COperator<T>
{
public:
	CMulOperator(void){};
	~CMulOperator(void){};
virtual T GetResult(T NumberA,T NumberB);
};


#include "Mul.h"

template <class T>
T CMulOperator<T>::GetResult(T NumberA,T NumberB)
{
	T result = NumberA * NumberB;

	return result;
}

除法类：

#pragma once
#include "operator.h"

template <class T>
class CDivOperator :public COperator<T>
{
public:
	CDivOperator(void){};
	~CDivOperator(void){};

	virtual T GetResult(T NumberA,T NumberB);
};

#include "Div.h"
#include <assert.h>

template <class T>
T CDivOperator<T>::GetResult(T NumberA,T NumberB)
{
	assert( NumberB != 0);

	T result =  NumberA/NumberB;

	return result;
}

接下来是简单工厂类，创建具体类的实例

#pragma once
#include "Operator.h"
#include "Operator.cpp"

#include "AddOperator.h"
#include "AddOperator.cpp"

#include "Div.h"
#include "Div.cpp"

#include "SubOperator.h"
#include "SubOperator.cpp"

#include "Mul.h"
#include "Mul.cpp"

template <class T>
class CFactory
{
public:
	CFactory(void){};
	~CFactory(void){};

	
	COperator<T>* CreateOperator(const char strOpe);
};

#include "Factory.h"

template <class T>
COperator<T>* CFactory<T>::CreateOperator(const char strOpe)
{
  COperator<T> *pOpe = NULL ;

  switch(strOpe)
  {
	case '+':
			pOpe = new CAddOperator<T>;
			break;
	case '-':
			pOpe = new CSubOperator<T>;
			break;
	case '*':
			pOpe=new CMulOperator<T>;
			break;
	case '/':
			pOpe=new CDivOperator<T>;
			break;
	default:
		break;
  }

  return pOpe;
}

在实际应用时可以简单的调用：

// SimpleFactory.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Factory.h"
#include "Factory.cpp"
#include <iostream>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	CFactory<double> *pFac=new CFactory<double>;
	COperator<double>* pOpe=NULL;
	double result;

	pOpe=pFac->CreateOperator('+');
	if(pOpe!=NULL)
	{
	result = pOpe->GetResult(2,3);
	cout<<"2 + 3 = "<<result<<endl;
	delete pOpe;
	}
	
	pOpe=pFac->CreateOperator('-');
	if(pOpe!=NULL)
	{
		result = pOpe->GetResult(2,3);
		cout<<"2 - 3 = "<<result<<endl;
		delete pOpe;
	}

	pOpe=pFac->CreateOperator('*');
	if(pOpe!=NULL)
	{
		result = pOpe->GetResult(2,3);
		cout<<"2 * 3 = "<<result<<endl;
		delete pOpe;
	}

	pOpe=pFac->CreateOperator('/');
	if(pOpe!=NULL)
	{
		result = pOpe->GetResult(2,3);
		cout<<"2 / 3 = "<<result<<endl;
		delete pOpe;
	}
	
	return 0;
}

它不需要管具体实例化哪个对象，这个过程都由工厂类实现了，以后如果要增加其他的二元运算，只须让其继承至COperator类，再修改工厂类的switch分支即可。