设计模式之一： 简单工厂模式

在读大话模式， 进行笔记，简单工厂模式，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;
}

用户使用起来是不是很简单；