简单工厂模式
本帖最后由 whypro 于 2010-5-25 16:58 编辑(1)头文件
COperationFactory.h（运算符工厂类）
(2)源文件
SimpleFactory.cpp（客户端应用类，主函数所在）
(3)运算类
COperation.cpp（运算符基类）
COperation.h
COperationAdd.h（加法运算符子类，继承于COperation）
COperationDiv.h （除法运算符子类，继承于COperation）
COperationMul.h （乘法运算符子类，继承于COperation）
COperationSub.h（减法运算符子类，继承于COperation）
=============代码实现部分 =============
COperationFactory.h（运算符工厂类）
/************************************************************************/
/* 运算符工厂类 */
/************************************************************************/
#ifndef _OPERATION_FACTORY_H_
#define _OPERATION_FACTORY_H_
#include "stdafx.h"
#include "COperation.h"
#include "COperationAdd.h"
#include "COperationSub.h"
#include "COperationMul.h"
#include "COperationDiv.h"
#include "COperationFactory.h"
class COperationFactory
{
public:
COperationFactory(){};
~COperationFactory(){};
// 根据入参的不同，创建其对应的运算符类指针。就像是个工厂，创建用户指定的运算符类指针
static COperation* NewOperation(const string& strOperate)
{
// 入参合法性判断，防止后面的strOperate发生越界访问
if (strOperate.size() != 1)
{
return NULL;
}
COperation* pOperation = NULL;
switch (strOperate)
{
case
'+':
pOperation = new COperationAdd();
break;
case
'-':
pOperation = new COperationSub();
break;
case
'*':
pOperation = new COperationMul();
break;
case
'/':
pOperation = new COperationDiv();
break;
default:
break;
}
return pOperation;
};
};
#endif _OPERATION_FACTORY_H_
COperation.cpp（运算符基类）
#include "stdafx.h"
#include "COperation.h"
COperation::COperation()
: _dNumA(0)
, _dNumB(0)
{
}
COperation.h
/************************************************************************/
/* 运算符基类 */
/************************************************************************/
#ifndef _COPERATION_H_
#define _COPERATION_H_
class COperation
{
public:
COperation();
~COperation(){};
// 设置被运算数
void SetNumA(double dNumA)
{
_dNumA = dNumA;
};
// 获取被运算数
double GetNumA()
{
return _dNumA;
};
// 设置运算数
void SetNumB(double dNumB)
{
_dNumB = dNumB;
};
// 获取运算数
double GetNumB()
{
return _dNumB;
};
// 计算结果且在子类中实现各自的运算方法结果
virtual
double Result()
{
double dResult = 0;
return dResult;
}
private:
double _dNumA;
double _dNumB;
};
#endif _COPERATION_H_
COperationAdd.h（加法运算符子类，继承于COperation）
/************************************************************************/
/* 加法运算符子类，继承于运算符基类 */
/************************************************************************/
#ifndef _COPERATION_ADD_H_
#define _COPERATION_ADD_H_
#include "COperation.h"
class COperationAdd : public COperation
{
public:
COperationAdd(){};
~COperationAdd(){};
double Result()
{
return (GetNumA() + GetNumB());
};
};
#endif _COPERATION_ADD_H_
COperationDiv.h （除法运算符子类，继承于COperation）
/************************************************************************/
/* 除法运算符子类，继承于运算符基类 */
/************************************************************************/
#ifndef _COPERATION_DIV_H_
#define _COPERATION_DIV_H_
#include "COperation.h"
class COperationDiv : public COperation
{
public:
COperationDiv(){};
~COperationDiv(){};
double Result()
{
double dResult = 0;
if (0 != GetNumB())
{
dResult = (GetNumA() / GetNumB());
}
else
{
cout << "error: divisor is ";
}
return dResult;
};
};
#endif _COPERATION_DIV_H_
COperationMul.h （乘法运算符子类，继承于COperation）
/************************************************************************/
/* 乘法运算符子类，继承于运算符基类 */
/************************************************************************/
#ifndef _COPERATION_MUL_H_
#define _COPERATION_MUL_H_
#include "COperation.h"
class COperationMul : public COperation
{
public:
COperationMul(){};
~COperationMul(){};
double Result()
{
return (GetNumA() * GetNumB());
};
};
#endif _COPERATION_MUL_H_
COperationSub.h（减法运算符子类，继承于COperation）
/************************************************************************/
/* 减法运算符子类，继承于运算符基类 */
/************************************************************************/
#ifndef _COPERATION_SUB_H_
#define _COPERATION_SUB_H_
#include "COperation.h"
class COperationSub : public COperation
{
public:
COperationSub(){};
~COperationSub(){};
double Result()
{
return (GetNumA() - GetNumB());
};
};
#endif _COPERATION_SUB_H_
SimpleFactory.cpp（客户端应用类，主函数所在）
// SimpleFactory.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "COperationFactory.h"
int _tmain(int argc, _TCHAR* argv[])
{
// 通过运算符工厂创建加法运算
COperation* OperAdd = COperationFactory::NewOperation("+");
if (NULL != OperAdd)
{
OperAdd->SetNumA(168);// 设置被加数
OperAdd->SetNumB(105);// 设置加数
cout << "168 + 105 = " << (OperAdd->Result()) << endl;
}
// 通过运算符工厂创建减法运算
COperation* OperSub = COperationFactory::NewOperation("-");
if (NULL != OperSub)
{
OperSub->SetNumA(168);// 设置被减数
OperSub->SetNumB(105);// 设置减数
cout << "168 - 105 = " << (OperSub->Result()) << endl;
}
// 通过运算符工厂创建乘法运算
COperation* OperMul = COperationFactory::NewOperation("*");
if (NULL != OperMul)
{
OperMul->SetNumA(168);// 设置被乘数
OperMul->SetNumB(105);// 设置乘数
cout << "168 * 105 = " << (OperMul->Result()) << endl;
}
// 通过运算符工厂创建除法运算
COperation* OperDiv = COperationFactory::NewOperation("/");
if (NULL != OperDiv)
{
OperDiv->SetNumA(168);// 设置被除数
OperDiv->SetNumB(105);// 设置除数
cout << "168 / 105 = " << (OperDiv->Result()) << endl;
OperDiv->SetNumB(0); // 改变除数
cout << (OperDiv->Result()) << endl;
}
// 阻止控制台进程结束，便于查看结果
int nEnd = 0;
cin >> nEnd;
return 0;
}
总结：（1）业务的封装：就是让业务逻辑与界面逻辑分开，让它们之间的耦合度下降，只有分离开，才可以达到容易维护或者扩展（2）如果要修改任何一个运算符类的算法，都不需要提供其他运算符类算法的代码。（3）用单独的类(COperationFactory)来做创造实例的过程，这就是工厂，简单运算工厂类。用户只需要输入运算符符号，工厂就实例化出合适的对象，通过多态，返回父类的方式实现了计算器的结果 设计模式，，还是有点看不懂 什么地方看不懂？ 现实生活中例子：
每次参加不同的聚会或者与不同的人见面，可能穿的衣服是不一样的，比如，你今天上午要与你的一个新客户见面，你可能会对你的老婆说：老婆，给拿件商务装（参数），我要去见我的一个客户，你老婆（工厂类）接到你的请求（商务装参数）后，从衣柜中取出一件商务装（具体产品），交给你。整个过程就完成了。 当我们在买早餐的时候，早餐店里都卖得写什么呢？这点你有注意吗？众多食品摆在那里，你只对营业员说你要何种食品，他便会知道给你拿什么样的食品给你，这说明什么呢？如果用面向对象的思想来理解的话，营业员在这里就充当了一个工厂的角色，他负责根据你的请求返回你需要的食品对象。而这一点正是简单工厂模式的意图。 哦，原来这样啊，谢谢版主回答，我再理解下 很好，我来学习的 厉害，学习了 我是新手 学习来了 感谢楼主分享！
页:
[1]