使用简单工厂模式实现四则运算 C++

今天实现了一个简单工厂模式， 实现四则运算。
说下对简单工厂的理解， 个人感觉他就是利用一个工厂类的静态函数获取一个工厂产品的实例， 在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;
}