今天實現了一個簡單工廠模式， 實現四則運算。
說下對簡單工廠的理解， 個人感覺他就是利用一個工廠類的靜態函式獲取一個工廠產品的例項， 在C++中表現就是 獲取一個指向產品的派生類的基類指標， 利用多型 實現具體產品類的呼叫。
ie， 利用工廠類負責建立物件的例項
下面這是我們所繪製的C++的UML類圖

程式碼實現：
operation.h

#ifndef _OPERATION_H_
#define _OPERATION_H_

template<class T>
class COperation
{
public:
    COperation(){}
    COperation(T a, T b) :numberA(a), numberB(b){}

    /************************************************************************/
 

    /* 私有資料的訪問方法                                                   */
    /************************************************************************/
    T getNumA() const{ return numberA; }
    T getNumB() const{ return numberB; }
    void setNumA(const T & a){ numberA = a; }
    void setNumB(const
 
 T & b){ numberB = b; }

    /************************************************************************/
    /* 獲取計算結果                                                         */
    /************************************************************************/
    virtual T getResult() const = 0;

private:
    T numberA;
    T numberB;  
};

#endif // !_OPERATION_H_
 

MainOperation.h

#ifndef _MAINOPERATION_H_
#define _MAINOPERATION_H_

#include "Operation.h"
#include <iostream>

/************************************************************************/
/* 加法運算類                                                           */
/************************************************************************/
template<class T>
class CAddOperation : public COperation<T>{
public:
    CAddOperation(){}
    CAddOperation(T a, T b) : COperation(a, b){}

    T getResult() const{
        return getNumA() + getNumB();
    }
};

/************************************************************************/
/* 減法運算類                                                           */
/************************************************************************/
template<class T>
class CSubOperation : public COperation<T>{
public:
    CSubOperation(){};
    CSubOperation(T a, T b) : COperation(a, b){}

    T getResult() const {
        return getNumA() - getNumB();
    }
};

/************************************************************************/
/* 乘法運算類                                                           */
/************************************************************************/
template<class T>
class CMulOperation : public COperation<T>{
public:
    CMulOperation(){};
    CMulOperation(T a, T b) : COperation(a, b){}

    T getResult() const {
        return getNumA() * getNumB();
    }
};

/************************************************************************/
/* 除法運算類                                                           */
/************************************************************************/
template<class T>
class CDivOperation : public COperation<T>{
public:
    CDivOperation(){};
    CDivOperation(T a, T b) : COperation(a, b){}

    T getResult() const {
        T b = getNumB();
        if (b < 1e-6 && b > 1e-6){
            std::cerr << "divsion by zero" << std::endl;
            return 0;
        }
        return getNumA() / getNumB();
    }
};

#endif // _MAINOPERATION_H_

OperFactory.h

#ifndef _OPERFACTORY_H_
#define _OPERFACTORY_H_

#include <memory>
#include "MainOperation.h"

template <class T>
class COperFactory{
public:
    /************************************************************************/
    /* 對外提供一個建立運算操作的工廠函式介面                               */
    /************************************************************************/
    static std::shared_ptr<COperation<T>> createOperation(char oper){
        COperation<T> * ptr = nullptr;
        switch (oper)
        {
            case '+':
                ptr = new CAddOperation<T>();
                break;
            case '-':
                ptr = new CSubOperation<T>();
                break;
            case '*':
                ptr = new CMulOperation<T>();
                break;
            case '/':
                ptr = new CDivOperation<T>();
                break;
            default:
                ptr = nullptr;
                break;
        }

        return std::shared_ptr<COperation<T>>(ptr);
    }
};


#endif // _OPERFACTORY_H_

main.h

#include "OperFactory.h"
#include <iostream>

using namespace std;

/************************************************************************/
/* 藉助簡單工廠模式， 實現 兩個數字的加減乘除四則運算操作               */
/************************************************************************/

int main(){
    shared_ptr<COperation<double>> oper = COperFactory<double>::createOperation('/');
    oper->setNumA(3.0);
    oper->setNumB(4.0);
    cout << oper->getResult() << endl;

    system("pause");
    return 0;
}