设计模式

• 创建型模式：如何创建对象；
• 结构型模式：如何实现类和对象的组合；
• 行为型模式：雷和对象如何交互和职责。

1.开闭原则

对扩展开放，对修改关闭。
增加功能时通过增加代码来实现的，而不是去修改源代码。

class Caculator {
public: 
    Caculator(int a,int b,string moperator){
        this->m_a = a;
        this->m_b = b;
        this->m_operator = moperator;
    }
    int getResult(){
        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(){
    Caculator *cac = new Caculator(10,20, "+");
    cout << cac->getResult() << endl;
}

//----------------优化----------------
class AbstractCaculator{ //抽象类
public:
//virtual重写，实现父类的方法。
    virtual int getResult()=0;  
    virtual void setOperatorNum(int a,int b)=0;
};
//加法计算器类 +
class PlusCaculator: public AbstractCaculator {
public:
    virtual void setOperatorNum(int a,int b){
        this.mA =a; this.mB =b;
    }
    virtual int getResult(){
        return mA +mB;
    }
public:
    int mA, mB;
};

//加法计算器类 -
class MinusCaculator: public AbstractCaculator {
public:
    void setOperatorNum(int a,int b){
        this.mA =a; this.mB =b;
    }
    int getResult(){
        return mA -mB;
    }
public:
    int mA, mB;
};
//...... TODO: 乘法计算器，除法计算器，取余计算器。

void test01(){
    AbstractCaculator* calculator = new PlusCaculator;
    calculator->setOperatorNum(10,20);
    cout << "add result:" << calculator->getResult() << endl;
    
    delete calculator;
    calculator = new MinusCaculator;
    calculator->setOperatorNum(10,20);
    cout << "minus result:" << calculator->getResult() << endl;
}

2.迪米特法则：又叫 最少支持原则

只跟中间层(中介)打交道，用户不要和具体的楼盘联系。 类似中介。
知道的越少，能把事情办好。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class AbstractBuilding {
public:
    virtual void sale() =0;
public:
    string mQuality;
};
//楼盘A
class BuildingA :public AbstractBuilding {
public:
    BuildingA(){
        mQuality = "高配置";
    }
    virtual void sale(){
        cout << "楼盘A:" << mQuality << "被售卖了!" << endl;
    }
};

//楼盘B
class BuildingB :public AbstractBuilding {
public:
    BuildingB(){
        mQuality = "低品质";
    }
    virtual void sale(){
        cout << "楼盘B:" << mQuality << "被售卖了!" << endl;
    }
};


void test01(){
    BuildingA *ba = new BuildingA;
    if(ba->mQuality == "低品质") {
        ba->sale();
    }
    BuildingB *bb = new BuildingB;
    if(bb->mQuality == "低品质") {
        bb->sale();
    }
}

// 中介类
class Midiator {
public:
    Midiator(){
        AbstractBuilding *building = new BuildingA;
        vBuilding.push_back(building);
        
        *building = new BuildingB;
        vBuilding.push_back(building);
    }
    ~Meditor() {
        for(vector<AbstractBuilding*>::iterator it=vBuilding.begin(); it!=vBuilding.end(); it++){
            if(*it != NULL){
                delete *it;
            }
        }
    }
    AbstractBuilding *fundMyBuilding(string quality){
        for(vector<AbstractBuilding*>::iterator it=vBuilding.begin(); it!=vBuilding.end(); it++){
            if((*it)->getQuality() == quality){
                return *it;//找到符合条件的
            }
        }
        return NULL;
    }
    
public:
    vector<AbstractBuilding *> vBuilding;
};

void test02() {
    Midiator* meditor = new Midiator();
    AbstractBuilding *building = meditor->fundMyBuilding("低品质");
    if(building == NULL) {
        bilding->sale();
    } else {
        cout << "没有找到符合条件的楼盘";
    }
}
// 减少与具体的类打交道。

3.合成复用原则

继承和组合，优先使用组合。

class AbstractCar{
public:
    virtual void run()=0;
};
class DaZhong: public AbstractCar{
    virtual void run(){
        coutt << "大众汽车启动..." << endl;
    }
};
class BMW: public AbstractCar{
    virtual void run(){
        coutt << "宝马汽车启动..." << endl;
    }
};
class Person: public BMW { //不建议使用继承。
public:
    void DouFeng() {
        run();
    }
};
//--------------使用组合，car 作为Person对象的属性----------------------
class Person{
public:
    void setCar(AbstractCar *car){
        this.car = car;
    }
    void DouFeng() {
        this->car->run();
        if(this->car != NULL){
            delete this->car;
            this->car = NULL;
        }
    }
public:
    AbstractCar *car;
}
void test03(){
    Person* p = new Person; 
    p->setCar(new DaZhong);
    p->DouFeng(); // 里面有析构逻辑
    
    p->setCar(new BMW);
    p->DouFeng(); 
    delete p;
}

3.

https://www.bilibili.com/video/BV1KW411t7FV?spm_id_from=333.788.player.switch&vd_source=79c2ce5a6d8005ccba7442678f514e19&p=14