常用设计模式总结

复习到设计模式的时候写的一些demo代码

回头可以看看

单例的几种比较简单就没写了，专栏有

目录

观察者（发布--订阅模式）模式，多个对象依赖于一个对象，或者多对多

工厂模式：主要是封装了对象的创建（简单，方法，抽象）

简单工厂，不在23种设计模式里

工厂方法：

抽象方法：

结构型模式

代理Proxy模式demo：

适配器模式

装饰器模式，Decorator

---

观察者（发布--订阅模式）模式，多个对象依赖于一个对象，或者多对多

/*subject有更改 要及时通知observer去做改变
*/
class Observer{//观察者抽象类//处理消息接口public:virtual void handleEvent(int msgid)=0;
};
class Observer1:public Observer{public:void handleEvent(int msgid){ //做出相应动作switch (msgid){case 1:cout<<"Observer1 received 1"<<endl;break;case 2:cout<<"Observer1 received 2"<<endl;break;default:cout<<"Observer1 received unknown"<<endl;break;}}
};
class Observer2:public Observer{public:void handleEvent(int msgid){ //做出相应动作switch (msgid){case 2:cout<<"Observer2 received 2"<<endl;break;default:cout<<"Observer2 received unknown"<<endl;break;}}
};
//主题
class Subject{  private:unordered_map<int,list<Observer*>> _subMap;public://给主题增加观察者对象void addObserver(Observer *obser,int msgid){_subMap[msgid].push_back(obser);}//主题改变 ，通知相应的观察者去处理事件void notifyObservers(int msgid){auto it = _subMap.find(msgid);if(it != _subMap.end()){//找到了for(Observer *ob:it->second){ob->handleEvent(msgid);}}}};int main(){Subject subject;Observer *p1=new Observer1();Observer *p2=new Observer2();subject.addObserver(p1,1);subject.addObserver(p1,2);subject.addObserver(p1,3);subject.addObserver(p2,2);subject.addObserver(p2,3);int msgid;while(1){cout<<"消息id: "<<endl;cin>>msgid;subject.notifyObservers(msgid);if(msgid==-1){break;}}system("pause");return 0;
}

工厂模式：主要是封装了对象的创建（简单，方法，抽象）

简单工厂，不在23种设计模式里

简单工厂demo：把对象的创建封装在一个接口函数里，通过传入不同的标识，返回创建的对象，好处是客户不用自己负责new对象，不用了解对象具体创建的详细过程（这种设计模式不好）

缺点：提供创建对象实例的接口函数不闭合，不能对修改关闭

class Car{public:Car(string name):_name(name){}virtual void show()=0;protected:string _name;
};
class BMW:public Car
{public:BMW(string name):Car(name){}void show(){cout<<"宝马车"<<endl;}
};
class Audi:public Car
{public:Audi(string name):Car(name){}void show(){cout<<"奥迪车"<<endl;}
};enum CarType{BMw,AUDI
};
class SimpleFactory{   //封装了 对象public:Car* CreateCar(CarType type){switch(type){case BMw:return new BMW("X1");break;case AUDI:return new Audi("A6");break;default:cout<<"type err"<<endl;break;}return nullptr;}
};
int main(){SimpleFactory *fac=new SimpleFactory();Car *car=fac->CreateCar(BMw);Car *car1=fac->CreateCar(AUDI);car->show();car1->show();delete car;delete car1;delete fac;system("pause");return 0;
}

工厂方法：

把工厂划分成基类，各个子工厂去继承方法

相应的工厂只需要创建自己厂家的东西就行，还想增加奔驰，就多个奔驰工厂去继承工厂类，重写创建方法就好

对于已有的工厂不需要做改变，做到了软件工程的开闭原则

• 工厂基类提供一个纯虚函数（创建产品），定义派生类（具体工厂），创建对应产品，可以做到不同的产品，在不同的工厂里创建，能够对现有的工厂和产品进行修改关闭
• 实际上很多产品是有关联关系的，属于一个产品簇，不应该放在不同的工厂去创建

class Car{public:Car(string name):_name(name){}virtual void show()=0;protected:string _name;
};
class BMW:public Car
{public:BMW(string name):Car(name){}void show(){cout<<"宝马车"<<endl;}
};
class Audi:public Car
{public:Audi(string name):Car(name){}void show(){cout<<"奥迪车"<<endl;}
};//工厂方法
class Factory{
public:virtual Car* create(string name)=0;
};
//宝马工厂
class BMWFactory:public Factory{
public:Car* create(string name){return new BMW(name);}
};
//奥迪工厂
class AudiFactory:public Factory{
public:Car* create(string name){return new Audi(name);}
};
int main(){Factory *fac=new BMWFactory();Factory *fac1=new AudiFactory();Car *car=fac->create("BMw");Car *car1=fac1->create("AUDI");car->show();car1->show();delete car;delete car1;delete fac;delete fac1;system("pause");return 0;
}

抽象方法：

考虑生产一类产品，比如生产手机，耳机，充电器，总不能生产一种产品就创建一个工厂

上面的问题简单工厂无法解决，引入抽象工厂

其实就是把工厂方法叠加起来了，工厂基类的方法多了一些，子工厂继承的就多

把有关联的产品簇里的所有产品创建的接口函数，放在一个抽象工厂里，派生类（具体工厂）应该负责创建该产品簇里的所有产品

//系列产品1  汽车
class Car{public:Car(string name):_name(name){}virtual void show()=0;protected:string _name;
};
class BMW:public Car
{public:BMW(string name):Car(name){}void show(){cout<<"宝马车"<<_name<<endl;}
};
class Audi:public Car
{public:Audi(string name):Car(name){}void show(){cout<<"奥迪车"<<_name<<endl;}
};//系列产品2  车灯
class Light{public:    virtual void show()=0;
};
class BMWLight:public Light
{public: void show(){cout<<"宝马 车灯"<<endl;}
};
class AudiLight:public Light
{public:void show(){cout<<"奥迪 车灯"<<endl;}
};
//抽象工厂 对一组有关联关系的产品组提供产品的统一创建
class Factory{
public:virtual Car* createCar(string name)=0;//工厂方法virtual Light* createLight()=0;//工厂方法
};
//宝马工厂
class BMWFactory:public Factory{
public:Car* createCar(string name){return new BMW(name);}Light* createLight(){return new BMWLight();}};
//奥迪工厂
class AudiFactory:public Factory{
public:Car* createCar(string name){return new Audi(name);}Light* createLight(){return new AudiLight();}
};int main(){Factory *fac=new BMWFactory();Factory *fac1=new AudiFactory();Car *car=fac->createCar("BMw");Car *car1=fac1->createCar("AUDI");Light *l1=fac->createLight();Light *l2=fac1->createLight();car->show();l1->show();car1->show();l2->show();system("pause");return 0;
}

结构型模式

代理Proxy模式demo：

通过代理类来控制实际对象（委托类）的访问权限
客户    助理proxy   老板：委托类

class VideoSite{public:virtual void freeMovie()=0;//免费电影virtual void vipMovie()=0;//vip 电影virtual void ticketMovie()=0;//用劵
};
class FixBugVideoSite:public VideoSite{//委托类 拥有所有功能public:virtual void freeMovie(){cout<<"free movie"<<endl;}virtual void vipMovie(){cout<<"vip movie"<<endl;}virtual void ticketMovie(){cout<<"ticket movie"<<endl;}
};
//代理类 
class FreeVideoProxy:public VideoSite{
public:FreeVideoProxy(){PVideo =new FixBugVideoSite();}~FreeVideoProxy(){delete PVideo;}virtual void freeMovie(){PVideo->freeMovie();//通过代理对象的freemovie去访问真正委托类方法}virtual void vipMovie(){cout<<"you are free  cant use vip"<<endl;}virtual void ticketMovie(){cout<<"no ticket cant see movie"<<endl;}
private:VideoSite* PVideo;
};
//代理类 
class VipVideoProxy:public VideoSite{
public:VipVideoProxy(){PVideo =new FixBugVideoSite();}~VipVideoProxy(){delete PVideo;}virtual void freeMovie(){PVideo->freeMovie();//通过代理对象的freemovie去访问真正委托类方法}virtual void vipMovie(){PVideo->vipMovie();}virtual void ticketMovie(){cout<<"vip no ticket cant see movie"<<endl;}
private:VideoSite* PVideo;
};
int main()
{unique_ptr<VideoSite> p1(new FreeVideoProxy());p1->freeMovie();p1->vipMovie();p1->ticketMovie();system("pause");return 0;
}

适配器模式

让不兼容的接口可以在一起工作
电脑-》 投影到 -》 投影仪上 需要的线接口：VGA HDMI TypeC

VGA接口的电脑，投影仪也是VGA接口

HDMI的投影仪，就要用适配器去转换

class VGA{
public:virtual void play()=0;
};
//TV01表示支持VGA接口的投影仪
class TV01:public VGA{
public:void play(){cout<<"use VGA接口连接投影仪,进行视频播放"<<endl;}
};//电脑类(只支持VGA接口)
class HuaweiComputer{
public:void playVideo(VGA *vga){vga->play();}
};
/*
1.换支持hdmi接口的电脑，代码重构
2.买转换头（适配器），把vga信号转成hdmi信号，添加适配器类
*///进了一批新的投影仪，但是投影仪只支持HDMI接口
class HDMI{
public:virtual void play()=0;
};class TV02:public HDMI{
public:void play(){cout<<"use HDMI接口连接投影仪,进行视频播放"<<endl;}
};
//适配器类
class VGA_TO_HDMI:public VGA{
public:VGA_TO_HDMI(HDMI *p):pp(p){}void play(){//转换头pp->play();}
private:HDMI* pp;
};int main()
{HuaweiComputer c1;c1.playVideo(new TV01());c1.playVideo(new VGA_TO_HDMI(new TV02()));system("pause");return 0;
}

装饰器模式，Decorator

装饰器：增加现有类的功能

装饰器类持有需要被装饰的对象，装饰器再可以根据功能去细分子类

class Car{//抽象基类public:virtual void show()=0;
};
//实体类
class BMW:public Car{public:void show(){cout<<"is bmw common"<<endl;}
};
class Benz:public Car{public:void show(){cout<<"is Benz common"<<endl;}
}; 
//装饰器  定速巡航的功能
class ConcreteDecorator01:public Car{public:ConcreteDecorator01(Car *p):car(p) {}void show(){car->show();cout<<"is concrete"<<endl;}private:Car* car;
};
//装饰器  自动刹车功能
class StopDecorator01:public Car{public:StopDecorator01(Car *p):car(p) {}void show(){car->show();cout<<"is Stop"<<endl;}private:Car* car;
};int main()
{Car *p1=new ConcreteDecorator01(new Benz());p1->show();p1=new StopDecorator01(p1);p1->show();Car *p2=new StopDecorator01(new BMW());p2->show();system("pause");return 0;
}