设计模式之---简单工厂模式(一)

简单工厂模式：到底要实例化哪个对象，将来会不会增加实例化对象，这时可以考虑用一个单独的类来创造实例的过程，这就是工厂。
以一个2元操作运算来说明：
operator类：
[cpp]
#pragma once

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



#include "Operator.h"

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

return result;
}
加法类：
[cpp]
#pragma once
#include "Operator.h"

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

#include "AddOperator.h"


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

result = NumberA + NumberB;

return result;
}

减法类：
[cpp]
#pragma once
#include "operator.h"

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


#include "SubOperator.h"

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

return result;
}

乘法类：
[cpp]
#pragma once
#include "operator.h"

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


#include "Mul.h"

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

return result;
}

除法类：
[cpp]
#pragma once
#include "operator.h"

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

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

#include "Div.h"
#include

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

T result = NumberA/NumberB;

return result;
}

接下来是简单工厂类，创建具体类的实例
[cpp]
#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 CFactory
{
public:
CFactory(void){};
~CFactory(void){};


COperator* CreateOperator(const char strOpe);
};

#include "Factory.h"

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

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

return pOpe;
}

在实际应用时可以简单的调用：
[cpp]
// SimpleFactory.cpp : Defines the entry point for the console application.
//

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

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

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

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