1.开放封闭原则
------新增操作类型时，不修改以前的代码
2.面向对象的封装，继承和多态
------实现计算类时，使用面向对象的思想

简单工厂模式和工厂模式都集中封装了对象的创建，使得更换对象时，不需要做大的改动就可以实现，降低了客户程序与产品对象的耦合。
由于使用了多态，保持了不需要知道具体实现的优点且克服了没新增一种操作就要修改工厂类的缺点。
但工厂方法的缺点也显而易见：每增加一种操作，就要增加一个工厂的类，增加了额外的开发量。

代码实现如下：

#include <stdio.h>
using namespace std;

class OperateTmp
{
public:
    double numA;
    double numB;
    virtual double GetResult() = 0;
};

class Add: public OperateTmp
{
public:
    double GetResult()
    {
        return numA + numB;
    }
};

class Sub: public OperateTmp
{
public:
    double GetResult()
    {
        return numA - numB;
    }
};


class OperateFactory
{
public:
    virtual OperateTmp* create() = 0;
};

class AddFactory:public OperateFactory
{
public:
    OperateTmp* create()
    {
        return new Add();
    }
};

class SubFactory:public OperateFactory
{
public:
    OperateTmp* create()
    {
        return new Sub();
    }
};

int main()
{
    double numA(0.0),numB(0.0);
    char OperCh;
    scanf("%lf %lf %c",&numA,&numB,&OperCh);
    
    OperateFactory* fac = NULL;
    if(OperCh == '+')
    {
        fac = new AddFactory();//后续新增操作，只需要修改这里然后新增工厂类和操作类即可。不影响以前的实现
        OperateTmp* oper = fac->create();
        if(oper)
        {
            oper->numA = numA;
            oper->numB = numB;
        
            printf("%lf",oper->GetResult());
        
            delete oper;
            oper = NULL;
        }
        delete fac;
        fac = NULL;
    }
    
    return 0;
}