简单工厂模式

• 一个工厂类根据传入的参数，动态的决定去创建哪一个产品类。、

前言介绍

如果想要实现一个计算器功能，前台页面输入数字和运算符号，后台该如何去实现

1. 简单版本
   • 直接将输入的数字和运算符号做运算，返回结果
   • 不同的运算符使用不同的函数计算，根据运算符调用不同函数；
2. 面向对象版本
   • 通过封装，使用一个运算类，将要执行的运算逻辑放到该类中，当前台调用计算功能时，就调用该类中的对应的函数。
   • 缺点：如果要增加功能，比如开根号，就会重新修改该运算类，并且重新编译，如果有误修改，则会对已经验证测试完后的代码造成影响。
3. 继承版本
   • 将运算的逻辑抽象成一个操作类，该类中保存运算的两个数，然后有一个返回的虚函数，供具体的实现类重载。

简单工厂模式介绍

1. 结构

• 简单工厂模式包含了三个角色：
  • 抽象产品角色：所有产品的父类，它是一个抽象出来的类，是对有所有产品的子类的公共属性的抽象。
  • 具体产品角色：产品的具体属性，从抽象产品类中继承过来。
  • 工厂角色：根据指定参数，创造出所需要的具体产品的类，并返回。

2. 优点

• 对象创建和使用分离，权责明确，利于整个软件结构的优化。

3. 缺点

• 违反了开闭原则，即一个软件如类、模块、和函数应该对扩展开放，对修改关闭。
• 工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑；
• 当产品类过多时，会导致工厂方法类过于复杂。

4. 使用场景：

• 工厂类负责创建的对象比较少；
• 客户端只知道传入的工厂的参数，对如何创建对象不关系

5. 代码

#include<cstdio>
#include<cstdlib>
#include<iostream>

// 抽象产品角色
class Operation
{
private:
    double A,B;
public:
    Operation(/* args */):A(0),B(0){}
    ~Operation(){}

    double getNumberA(){
        return A;
    }
    double getNumberB(){
        return B;
    }

    void setNumberA(double x){
        A = x;
    }
    void setNumberB(double x){
        B = x;
    }

    double virtual getResult(){
        return 0;
    }
};

// 具体产品角色
class OperationAdd : public Operation{
public:
    double getResult(){
        return getNumberA() + getNumberB();
    }
};

class OperationSub : public Operation
{
public:
    double getResult(){
        return getNumberA() - getNumberB();
    }
};

class OperationMul : public Operation
{
public:
    double getResult(){
        return getNumberA() * getNumberB();
    }
};

class OperationDiv : public Operation
{
public:
    double getResult(){
        if(getNumberB() != 0) {
            return getNumberA()/getNumberB();
        }
        else{
            return 0;
        }
    }
};

// 工厂角色
class SimplyFactory
{
public:
    static Operation* createOperation(char ch){
        Operation* p;
        switch (ch)
        {
        case '+':
            p = new OperationAdd();
            break;
        case '-':
            p = new OperationSub();
            break;
        case '*':
            p = new OperationMul();
            break;
        case '/':
            p = new OperationDiv();
            break;
        
        default:
            break;
        }
        return p;
    }
};

void test(int x, int y, char ch){
    Operation* COpera = SimplyFactory::createOperation(ch);
    COpera->setNumberA(x);
    COpera->setNumberB(y);
    std::cout << "x " << ch << " y : ";
    std::cout << COpera->getResult() << std::endl;
}

int main()
{
    double x = 10;
    double y = 5;
    
    test(x,y,'+');
    test(x,y,'-');
    test(x,y,'*');
    test(x,y,'/');

    return 0;
}