设计原则一：开闭原则

## 开闭原则
对扩展开放，对修改关闭。增加功能是通过新增源代码实现的，而不是通过修改源代码实现
## 例子
```cpp
#include <iostream>
#include <string>
using namespace std;

class Calculator{
public:
    Calculator(int a, int b, string op){
        this->m_a = a;
        this->m_b = b;
        this->m_operator = op;
    }

int getResult(){
        if (m_operator.compare("+") == 0){
            return m_a + m_b;
        } else if (m_operator.compare("-") == 0){
            return m_a - m_b;
        } else if (m_operator.compare("*") == 0){
            return m_a * m_b;
        } else if (m_operator.compare("/") == 0) {
            return m_a / m_b;
        }
    }

private:
    int m_a;
    int m_b;
    string m_operator;
    int m_ret;
};

void test01(){
    Calculator * calculator_ptr = new Calculator(10, 20, "+");
    cout << calculator_ptr->getResult() << endl;
}
```

试想一下，如果我们要增加一个取模运算，是不是要动getResult()成员函数的内容？然而我们一般情况下是不建议修改已经写好的代码。那我们该怎么做？
```cpp
#include <iostream>
#include <string>
using namespace std;
// 对扩展开放，对修改关闭。增加功能是通过新增源代码实现的，而不是通过修改源代码实现

//第一步，先写一个抽象类
class AbstractCalculator {
public:
    virtual int getResult() = 0;
    virtual void setOperatorNumber(int a, int b)= 0;
};

//第二步，加法计算器
class PlusCalculator : public AbstractCalculator{
public:
    void setOperatorNumber(int a, int b){
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult(){
        return mA + mB;
    }
private:
    int mA;
    int mB;

};

//第二步，减法计算器
class MinusCalculator : public AbstractCalculator{
public:
    void setOperatorNumber(int a, int b){
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult(){
        return mA - mB;
    }
private:
    int mA;
    int mB;
};

//第二步，乘法计算器
class MultiplyCalculator : public AbstractCalculator{
public:
    void setOperatorNumber(int a, int b){
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult(){
        return mA * mB;
    }
private:
    int mA;
    int mB;
};

//第二步，除法计算器
class DividCalculator : public AbstractCalculator{
public:
    void setOperatorNumber(int a, int b){
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult(){
        return mA / mB;
    }
private:
    int mA;
    int mB;
};

//这时，如果要增加一个取模计算器
class ModeCalculator : public AbstractCalculator{
public:
    void setOperatorNumber(int a, int b){
        this->mA = a;
        this->mB = b;
    }
    virtual int getResult(){
        return mA % mB;
    }
private:
    int mA;
    int mB;
};

// 第三步，使用
void test02(){
    AbstractCalculator* ptr = new PlusCalculator;
    ptr->setOperatorNumber(10,20);
    cout << ptr->getResult() << endl;
    delete ptr;

ptr = new MinusCalculator;
    ptr->setOperatorNumber(10,20);
    cout << ptr->getResult() << endl;
    delete ptr;

ptr = new MultiplyCalculator;
    ptr->setOperatorNumber(10,20);
    cout << ptr->getResult() << endl;
    delete ptr;

ptr = new DividCalculator;
    ptr->setOperatorNumber(20,10);
    cout << ptr->getResult() << endl;
    delete ptr;

//增加取模运算
    ptr = new ModeCalculator;
    ptr->setOperatorNumber(20,10);
    cout << ptr->getResult() << endl;
    delete ptr;

}
```