（一）简单工厂模式

实例化对象的时候不再使用 new Object()形式，可以根据用户的选择条件来实例化相关的类。对于客户端来说，去除了具体的类的依赖。只需要给出具体实例的描述给工厂，工厂就会自动返回具体的实例对象。

场景：采用简单工厂模式设计一款运算器可以自由添加运算规则

#include<iostream>
#include<string>
#include<vector>
#include<stack>

using namespace std;

/**
 * 计算器运算抽象类
 */
class Operation {
private:
    double numberA;//操作数A
    double numberB;//操作数B
public:
    /**
     * 抽象方法
     * 获得操作结果
     */
    virtual double getResult() = 0;

    /**
     * 获取 操作数A
     */
    double getNumberA() {
        return this->numberA;
    }

    /**
     * 设置 操作数A
     */
    void setNumberA(double numberA) {
        this->numberA = numberA;
    }

    /**
     * 获取 操作数B
     */
    double getNumberB() {
        return this->numberB;
    }

    /**
     * 设置 操作数B
     */
    void setNumberB(double numberB) {
        this->numberB = numberB;
    }
};

/**
 * 加法运算类
 */
class OperationAdd: public Operation {
public:
    double getResult() {
        return getNumberA() + getNumberB();
    }
};

/**
 * 减法运算类
 */
class OperationSub: public Operation {
    double getResult() {
        return getNumberA() - getNumberB();
    }
};

/**
 * 乘法运算类
 */
class OperationMul: public Operation {
    double getResult() {
        return getNumberA() * getNumberB();
    }
};

/**
 * 除法运算类
 */
class OperationDiv: public Operation {
    double getResult() {
        double num = getNumberB();
        if(num == 0)
            throw "Division by zero condition!";
        return getNumberA() / getNumberB();
    }
};

/**
 * 运算静态工厂类
 */
class OperationFactory {
    /**
     * 创建运算工厂
     * @param operate 操作符(+ - * /)
     * @return 匹配运算类
     */
public:
    Operation* createOperation(char c)
    {
        Operation *operation;
        switch (c)
        {
            case '+':
                operation=new OperationAdd();//创建加法运算类
                break;
            case '-':
                operation=new OperationSub();//创建减法运算类
                break;
            case '*':
                operation=new OperationMul();//创建乘法运算类
                break;
            case '/':
                operation=new OperationDiv();//创建除法运算类
                break;
        }
        return operation;
    }
};

/**
 * 大话设计模式（C++实现）
 * 第一章:简单工厂模式(静态工厂模式)
 */


int main()
{
        Operation *operation;
        double result;
        operation = OperationFactory().createOperation('+');
        operation->setNumberA(1.1);
        operation->setNumberB(2.2);
        result = operation->getResult();
        cout<<"加法结果："<<result<<endl;

        operation = OperationFactory().createOperation('-');
        operation->setNumberA(3.3);
        operation->setNumberB(2.2);
        result = operation->getResult();
        cout<<"减法结果："<<result<<endl;

        operation = OperationFactory().createOperation('*');
        operation->setNumberA(3.3);
        operation->setNumberB(2.2);
        result = operation->getResult();
        cout<<"乘法结果："<<result<<endl;

        operation = OperationFactory().createOperation('/');
        operation->setNumberA(3.3);
        operation->setNumberB(2.2);
        result = operation->getResult();
        cout<<"除法结果："<<result<<endl;

        return 0;
}

优点：我们可以对创建的对象进行一些 “加工” ，而且客户端并不知道，因为工厂隐藏了这些细节。如果，没有工厂的话，那我们是不是就得自己在客户端上写这些代码，这就好比本来可以在工厂里生产的东西，拿来自己手工制作，不仅麻烦以后还不好维护。

缺点：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建的对象还不少的话，我们要在这个简单工厂类里编写很多个方法，每个方法里都得写很多相应的业务代码，而每次增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改。这会导致这个简单工厂类很庞大臃肿、耦合性高，而且增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开-闭原则。