设计模式—简单工厂（一）

（一）简单工厂模式

主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类重载函数得到不同的结果。

注意只有一个工厂，工厂根据输入参数的不同来选择不同的类实现。

例子：要求写一个控制台程序，要求输入两个数和运算操作符，得到结果。

通常我们可以这样写：

#include<iostream>
#include<string>
#include<exception>
usingnamespace std;
//基类
classCOperation
{
public:
     int getResult(intnumberA, int numberB, const charoper)
    {
       int result = 0;
       switch (oper)
       {
       case'+':
           result = numberA + numberB;
           break;
       case'-':
           result = numberA - numberB;
           break;
       case'*':
           result = numberA * numberB;
           break;
       case'/':
           result = numberA / numberB;
           if (numberB == 0)
              cout<<"除数不能为0";
           break;
       default:
           cout << "运算符输入有误" << endl;
           break;
       }
       return result;
    }
};
int main()
{
       int a, b;
       char oper;
       cout << "请输入numberA：";
       cin >> a;
       cout << "请输入运算符： ";
       cin >> oper;
       cout << "请输入numberB：";
       cin >> b;
       COperation * op = new COperation();
       cout << "运算结果是：" <<op->getResult(a, b, oper) << endl;      
        return 0;
}

       可以看到，如果我们要想添加其他运算就要修改类COperation，面向对象基本三个要求：一是可维护。就是要改，只需要改要改之处，第二，可复用，第三可扩展。下面将利用简单工厂模式进行代码重写：

#include<iostream>
#include<string>
usingnamespace std;
//基类
classCOperation
{
public:
    int m_nFirst;
    int m_nSecond;
    virtualdouble GetResult()
    {
       double dResult = 0;
       return dResult;
    }
};
//加法
classAddOperation : public COperation
{
public:
     double GetResult()override
    {
       return m_nFirst + m_nSecond;
    }
};
//减法
classSubOperation : public COperation
{
public:
    double GetResult()override
    {
       return m_nFirst - m_nSecond;
    }
};
//乘法
classMulOperation : public COperation
{
public:
    double GetResult()override
    {
       return m_nFirst * m_nSecond;
    }
};
//除法
classDivOperation : public COperation
{
public:
    double GetResult()override
    {
       return m_nFirst / m_nSecond;
    }
};
 
//工厂类
classCCalculatorFactory
{
public:
    staticCOperation* Create(char cOperator);
};
 
COperation*CCalculatorFactory::Create(constchar cOperator)
{
    COperation *oper;
    switch (cOperator)
    {
    case'+':
       oper = new AddOperation();
       break;
    case'-':
       oper = new SubOperation();
       break;
    case'*':
       oper = new MulOperation();
       break;
    case'/':
       oper = new DivOperation();
       break;
    default:
       oper = new AddOperation();
       break;
    }
    return oper;
}
 
//客户端
int main()
{
    int a, b;
    char oper;
    cout << "请输入numberA：";
    cin >> a;
    cout << "请输入运算符： ";
    cin >> oper;
    cout << "请输入numberB：";
    cin >> b;
    COperation * op = CCalculatorFactory::Create(oper);
    op->m_nFirst = a;
    op->m_nSecond = b;
    cout << "运算结果是：" <<op->GetResult() << endl;
    return 0;
}

       可以看到，声明了一个运算基类COperation，它有4个子类，定义了一个工厂CCalculatorFactory，用户通过传入参数来确定用COperation的哪个子类。核心思想是用一个工厂来根据输入的条件产生不同对象，然后根据不同类重载函数得到不同的结果。