在读大话模式, 进行笔记,简单工厂模式,C++代码
引入这个模式之前, 首先是面向对象的三大特性, 封装,继承,和多态;
首先看有一个 计算器的功能:
如果按照 过程化写的代码,就是数据输入和业务逻辑是合在一起的;
所以用到了c++的封装的特性,将计算的业务封装成了一个类:
class Operation
{
public:
static double GetResult(double dNumA, double dNumB, char ch)
{
switch (ch) {
case '+':
return dNumA + dNumB;
case '-':
return dNumA - dNumB;
case '*':
return dNumA * dNumB;
case '/':
return dNumA / dNumB;
case '^':
return dNumA * dNumA + dNumB * dNumB;
}
}
};
在这里, 如果要去新增一种运算,需要直接去修改Operation这个类的代码, 可能会影响其他的运算的代码, 就是说扩展性不好 ;
接下来的过程中, 就是将上面的类,加入继承和多态的特性, OperatIon 只是运算类,并不负责具体的运算, 所以就抽象成一个基类,
和具体的子类;
class Operator_1
{
public:
Operator_1(double numbA, double numbB)
: m_dNumberA(numbA)
, m_dNumberB(numbB)
{
}
virtual ~Operator_1() {}
virtual double GetResult()
{
return 0;
}
protected:
double m_dNumberA;
double m_dNumberB;
};
class Oper_Add : public Operator_1
{
public:
Oper_Add(double dNumA, double dNumB)
: Operator_1(dNumA, dNumB)
{
}
virtual double GetResult()
{
return m_dNumberA + m_dNumberB;
}
};
class Oper_Sub : public Operator_1
{
public:
Oper_Sub(double dNumaA, double dNumbB)
: Operator_1(dNumaA, dNumbB)
{
}
virtual double GetResult()
{
return m_dNumberA - m_dNumberB;
}
};
class Oper_Mul : public Operator_1
{
public:
Oper_Mul(double dNumaA, double dNumbB)
: Operator_1(dNumaA, dNumbB)
{
}
virtual double GetResult()
{
return m_dNumberA * m_dNumberB;
}
};
class Oper_Div : public Operator_1
{
public:
Oper_Div(double dNumaA, double dNumbB)
: Operator_1(dNumaA, dNumbB)
{
}
virtual double GetResult()
{
return m_dNumberA / m_dNumberB;
}
};
那么这样写的好处是什么呢? 就是去增加新的运算,不影响其他的运算,修改某一个运算的子类,也不影响其他的对象;
简单工厂就是一个专门用于生产对象的地方,因为简单,所以叫简单工厂;
class OperatorFactory
{
public:
static Operator_1* CreateObject(double d1, double d2, char ch)
{
Operator_1* pObject;
switch (ch) {
case '+':
pObject = new Oper_Add(d1, d2);
break;
case '-':
pObject = new Oper_Sub(d1, d2);
break;
case '*':
pObject = new Oper_Mul(d1, d2);
break;
case '/':
pObject = new Oper_Div(d1, d2);
break;
default:
pObject = new Operator_1(d1, d2);
}
return pObject;
}
static void Destroy(Operator_1* pObject)
{
if (NULL != pObject) {
delete pObject;
pObject = NULL;
}
}
};
从上面可以看出, 简单工厂创建的都是一类对象,就是Operator_1, 返回的是一个基类的指针, 这是关键, 其次是封装了 new操作符;
客户使用:
int main()
{
Operator_1* pObj = OperatorFactory::CreateObject(10, 20, '+');
cout << pObj->GetResult() << endl;
system("pause");
return 0;
}
用户使用起来是不是很简单;