设计模式——简单工厂

以简单工厂类为接口，工厂类根据不同输入参数创建具体的对象，实现界面和业务的解耦（界面需求改变和业务需求改变不互相影响）
对业务进行封装，利用继承使程序容易扩展，利用多态，用工厂类来实现对象实例的创建维护
工厂方法模式是一种创建型设计模式， 其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。

工厂模式的使用场景：

• 当我们无法预知对象确切类别以及其依赖关系时(创建产品代码与使用产品代码分离，便于扩展；当要增加新产品时，只需要开发新的创建者子类，然后重写工厂方法即可)
• 希望用户能扩展你软件库或框架的内部组件
• 希望复用现有对象来节省系统资源， 而不是每次都重新创建对象
  

#include <iostream>
#include <string>

using namespace std;

// 简单工厂模式
// 实现一个计算器
// 定义一个运算基类，用于管理两个运算数
// 定义加减乘除运算类，后续添加开根号之类的操作只需要添加相应的类，并且在工厂类中添加相应的分支即可
// 工厂类，选择实例化哪一个



// 运算基类
class Operation
{
public:
    void setNumberA(double const num)
    {
        numberA = num;
    }
    void setNumberB(double const num)
    {
        numberB = num;
    }

    virtual double GetResult() = 0;

protected:
    double numberA;
    double numberB;
};

// 加法类
class OperationAdd : public Operation
{
public:
    virtual double GetResult()
    {
        return numberA + numberB;
    }
};

// 减法类
class OperationSub : public Operation
{
public:
    virtual double GetResult()
    {
        return numberA - numberB;
    }
};

// 乘法类
class OperationMul : public Operation
{
public:
    virtual double GetResult()
    {
        return numberA * numberB;
    }
};

// 除法类
class OperationDiv : public Operation
{
public:
    virtual double GetResult()
    {
        return numberA / numberB;
    }
};

// 工厂类
class OperatorFactory
{
public:
    static Operation *CreateOperation(char ope)
    {
        Operation *operation = nullptr;
        switch (ope)
        {
        case '+':
            operation = new OperationAdd();
            break;
        case '-':
            operation = new OperationSub();
            break;
        case '*':
            operation = new OperationMul();
            break;
        case '/':
            operation = new OperationDiv();
            break;
        default:
            operation = nullptr;
        }

        return operation;
    }
};

int main()
{
    Operation *operation = nullptr; // 静态绑定的是Operation基类，但是动态绑定的是OperationSub这样的运算类
    float num1, num2, result;
    char ope;
    while (1)
    {

        do
        {
            if (cin.fail())
            {
                cin.clear(); // 清除错误标志
                cout << "输入错误， 请重新输入" << endl;
            }
            else
            {
                cout << "请输入第一个参数" << endl;
            }

            cin >> num1;
            cin.sync(); // 清除缓存
        } while (cin.fail());

        do
        {
            if (cin.fail())
            {
                cin.clear();
                cout << "输入错误，请重新输入" << endl;
            }
            else
            {
                cout << "请输入第二个参数：" << endl;
            }
            cin >> num2;
            cin.sync();
        } while (cin.fail());

        cout << "输入运算符(+, -, *, /):" << endl;
        cin >> ope;
        cin.sync();

        operation = OperatorFactory::CreateOperation(ope);

        if (operation != nullptr)
        {
            operation->setNumberA(num1); // 派生类指针调用父类方法，
            operation->setNumberB(num2);
            result = operation->GetResult();
            cout << "计算结果： " << result << endl;
            delete operation;
            operation = nullptr; // 防止野指针
        }
        else
        {
            cout << "计算结果：" << "error" << endl;
        }
    }
}