创建型设计模式

设计模式概念

        软件开发中，经过验证的，用于解决特定环境下重复出现的特定问题的解决方案

        找稳定点和变化点(将变化点隔离出来，解耦合)

         先满足设计原则。慢慢迭代出设计模式

        抽象+分治  

设计原则

依赖倒置：高层模块不依赖低层模块，两者都应该依赖于抽象

                  抽象不依赖于具体实现，具体实现依赖于抽象

                        

开放封闭原则： 对扩展开放，对修改封闭

单一职责：一个类应该仅仅有一个引起类变化的原因                   

接口隔离：不应该强迫用户依赖他们不用的方法

组合优于继承：继承耦合度高，组合耦合度低

里氏替换：子类必须能够替换父类

设计模式的具体例子

 模板模式：

定义骨架，而将实现延后 本质：通过将算法骨架固定来约束子类行为

 模板模式案例 ：背景：某个品牌动物园，有一套固定的表演流程，但是其中有若干个表演子流程可创新替换，以尝试迭代 更新表演流程 

#include<iostream>
using namespace std;
class ZooShow{
public:
    ZooShow(){

    }
public:
    void show(){
        if(show0()){  
            play_game();
        }
        show1();
        show2();
        show3();  
    }
//这里接口隔离
protected:
    //将变化点改成virtual隔离出去
    virtual void show1(){

    }
    virtual void show2(){

    }
    virtual void show3(){

    }
private:
    void play_game(){

    }
};

bool show0(){
    return true;
}
//这里实现骨架的方法
//里氏替换
class Zooshow_levelup : public ZooShow{

};


int main(){
    return 0;
}

观察者模式 ：

对象间的一种一对多（变化）的依赖关系，以便当一个对象的状态改变时，所有依赖于他的对象都得到通知并且自动更新

 

观察者模式案列：气象站发布气象资料给数据中心，数据中心将气象信息更新到两个不同的显式终端

#include <vector>

//
class IDisplay {
public:
    //纯虚接口，可以实现面对接口编程
    virtual void Show(float temperature) = 0;
    virtual ~IDisplay() {}
};

class DisplayA : public IDisplay {
public:
    virtual void Show(float temperature);
private:
    void jianyi();
};

class DisplayB : public IDisplay{
public:
    virtual void Show(float temperature);
};

class DisplayC : public IDisplay{
public:
    virtual void Show(float temperature);
};

class WeatherData {
};

class DataCenter {
public:
    void Attach(IDisplay * ob);
    void Detach(IDisplay * ob);
    void Notify() {
        float temper = CalcTemperature();
        for (auto iter = obs.begin(); iter != obs.end(); iter++) {
            (*iter)->Show(temper);
        }
    }

// 接口隔离
private:
    virtual WeatherData * GetWeatherData();

    virtual float CalcTemperature() {
        WeatherData * data = GetWeatherData();
        // ...
        float temper/* = */;
        return temper;
    }
    std::vector<IDisplay*> obs;
};

int main() {
    DataCenter *center = new DataCenter;
    IDisplay *da = new DisplayA();
    IDisplay *db = new DisplayB();
    IDisplay *dc = new DisplayC();
    center->Attach(da);
    center->Attach(db);
    center->Attach(dc); 
    center->Notify();
    
    //-----
    center->Detach(db);
    center->Notify();
    return 0;
}

观察者模式优点：

观察者模式使得我们可以独立地改变目标与观察者，从而使二者之间的关系松耦合；

观察者自己决定是否订阅通知，目标对象并不关注谁订阅了；

观察者不要依赖通知顺序，目标对象也不知道通知顺序；

常用在基于事件的ui框架中，也是 MVC 的组成部分；

常用在分布式系统中、actor框架中； 

本质：触发联动 

策略模式           

         定义一系列算法，封装起来，并且使他们相互之间可以替换，该模式使得算法独立于使用他们的客户程序而变化

背景：商场做活动，活动的的策略会迭代升级

class Context {

};

class ProStategy {
public:
    virtual double CalcPro(const Context &ctx) = 0;
    virtual ~ProStategy(); 
};
// cpp
class VAC_Spring : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_QiXi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_QiXi1  : public VAC_QiXi {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_Wuyi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_GuoQing : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

class VAC_Shengdan : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

class Promotion {
public:
    Promotion(ProStategy *sss) : s(sss){}
    ~Promotion(){}
    double CalcPromotion(const Context &ctx){
        return s->CalcPro(ctx);
    }
private:
    ProStategy *s;
};

int main () {
    Context ctx;
    ProStategy *s = new VAC_QiXi1();
    Promotion *p = new Promotion(s);
    p->CalcPromotion(ctx);
    return 0;
}