001 --- 第1章 简单工厂模式

简述：

　　简单工厂模式，如其名，简单，简单到明明是24种设计模式，却只归类为23种设计模式，把它排除了，但我还是写了出来。

　　简单工厂模式包括：工厂类、抽象产品类、具体产品类。

　　　　工厂类：制造产品，会有一个Create之类得函数，可以根据不同的标识符生产不同的具体产品，当然这些具体产品都继承自抽象产品。

　　　　抽象产品类：具体产品类的基类。

　　　　具体产品类：抽象产品类的派生类，当需要增加新的产品时，可以根据需要增加一个继承自抽象产品类的具体产品类，然后在工厂类中增加相应的处理分支即可。

　　简单工厂模式实现了松耦合，当需要新增一种产品时，只需要做两点改动：

　　　　增加一个继承自抽象类的具体产品类。

　　　　在工厂类中增加响应的处理分支。

例：加减乘除四则运算

代码如下：

#include <iostream>
using namespace std;

// 运算基类（抽象产品类）
class COperation
{
private:
    double m_dA = 0;
    double m_dB = 0;
public:
    void SetA(double dA)
    {
        m_dA = dA;
    }
    double GetA()
    {
        return m_dA;
    }
    void SetB(double dB)
    {
        m_dB = dB;
    }
    double GetB()
    {
        return m_dB;
    }
    virtual double GetResult()
    {
        double dResult = 0;
        return dResult;
    }
};

// 加法类（具体产品类）
class COperationAdd : public COperation
{
public:
    virtual double GetResult()
    {
        double dResult = 0;
        dResult = GetA() + GetB();
        return dResult;
    }
};

// 减法类（具体产品类）
class COperationSub : public COperation
{
public:
    virtual double GetResult()
    {
        double dResult = 0;
        dResult = GetA() - GetB();
        return dResult;
    }
};

// 乘法类（具体产品类）
class COperationMul : public COperation
{
public:
    virtual double GetResult()
    {
        double dResult = 0;
        dResult = GetA() * GetB();
        return dResult;
    }
};

// 除法类（具体产品类）
class COperationDiv : public COperation
{
public:
    virtual double GetResult()
    {
        double dResult = 0;
        if (0 == GetB())
            throw "除数不能为0！";
        dResult = GetA() / GetB();
        return dResult;
    }
};

// 简单工厂类
class COperationFactory
{
public:
    static COperation* CreateOperate(char chOperate)
    {
        COperation* pOperation = NULL;
        switch (chOperate)
        {
        case '+':
            pOperation = new COperationAdd();
            break;
        case '-':
            pOperation = new COperationSub();
            break;
        case '*':
            pOperation = new COperationMul();
            break;
        case '/':
            pOperation = new COperationDiv();
            break;
        }
        return pOperation;
    }
};

int main()
{
    COperation* pOperation;
    char chType = '/';
    pOperation = COperationFactory::CreateOperate(chType);
    pOperation->SetA(10);
    pOperation->SetB(2);

    double dResult = pOperation->GetResult();
    cout << dResult << endl;

    // C++堆区创建的对象需要手动释放资源
    if (pOperation)
        delete pOperation;

    system("pause");
    return 0;
}

输出结果：