与设计模式基础课程讲义

设计模式基设计模式编程基设计模式前模设计模式（Design设计模式是软件工程的基石脉络，如同的结构一样。GangofFour的“DesignPatterns:ElementsofResualbelSoftware”书将设计模式归纳为23种。创建型模式: 通常和对象的创建有关，涉及到对象实例化的方式（共5种模式)结构型模式：描述的是如何组合类和对象以获得更大的结构。(共7种模式)(11种模式创建型模式用来处理对象的创建过程，主要包含以下5种设计模式实际创建工作推子类中。 构建过以创建不同的表示。5，单例模式（SingletonPattern）是保证一个类仅有一个实例，并提供一个它的全局访结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式6，模式（Pattern）就是为其他对象提供一种以控制对这个对象的了一个接口，这个接口使得这一子系统更加容易使用。11式：13，模板方法模式（TemteMethodPattern）使得子类可以不改变一个算法的结构即可重14，命令模式（CommandPattern）是将一个请求封装为一个对象，从而使你可用不同的请Pattern17Medirern结者使各个对象不需要显示的相用，从而使其耦合性松散，而且可以独立的改变他们之间的交互。 torPattern）是提供了法顺序来一个聚合对象中的各个元设计模式基本原开放封闭原则(OCP,OpenForExtensionClosedForModification单一职责原则(SRP,SingleResponsibility接口原则(ISP,InterfaceSegegation(LSPLiskovSubstitution 迪法则(LOD,Lawof迪法与依赖倒转原则结合和抽象陌生人说话让和陌生人进行解耦创建型模单例模概的全局方法。为什么使用单例模socketservlet环境，共享同一个资源或者Singleton模式可以保证为一个类只生成唯一的实例对象，所以这些情况，Singleton模实现单例步骤常用构造函数提供一个全局的静态方法（全局点饿汉式单例和懒汉式单#include<iostream>usingnamespacestd;// {{m_singer=NULL;m_count=0;coutSingeltondo}staticSingelton{ifm_singerNULL //懒汉式：12{m_singer=new}return}staticvoid{cout<<"m_count:"<<m_count<<}staticSingelton*m_singer;staticintm_count;Singelton*Singelton::m_singer //懒汉没有创建单例对intSingelton::m_count=void{coutSingelton*p1Singelton::getInstance();只有在使用的时候，才去创建对象。Singelton*p2=Singelton::getInstance();if(p1!={cout不是同一个对象}{cout是同一个对象}p1-p2-return;}// {{m_singer=NULL;m_count=0;coutSingeltondo}staticSingelton2{ if(m_singer==NULL m_singer=new return}staticvoid {if(m_singer!={deletem_singer;m_singer=NULL;m_count=0;}}staticvoid{cout<<"m_count:"<<m_count<<}staticSingelton2*m_singer;staticintm_count;Singelton2*Singelton2::m_singer=newSingelton2;//不管你创建不创建实例，均把实例new出来intSingelton2::m_count=void{coutSingelton2*p1Singelton2::getInstance();只有在使用的时候，才去创建对象。Singelton2*p2=Singelton2::getInstance();if(p1!={cout不是同一个对象}{cout是同一个对象}p1-p2-}多线程下的懒汉式单例和饿汉式单 NULLm_instance//2多线程中会导致多个实例的产生，从而导致运行代码不正确以及内存的//3 就进行线程切换，另外一个线程拿到所后，由于内存已经分配了，但是变量初始化还没进行，因此打印成员变量的相关值会发生不一致现象。#include"stdafx.h"#include"windows.h"#include"winbase.h"#include<process.h>#include"iostream"usingnamespacestd;classSingelton{{countcout<<"Singeltonbegin\n"<<endl;cout<<"Singelton}Singelton(constSingelton&objSingelton&operator=(constSingelton&obj){;}staticSingelton{ NULLm_instance//2多线程中会导致多个实例的产生从而导致运行代码不正确以及内存的//3return}staticSingelton{if(singleNULL){deletesingle;single=}return}voidpirntS(){printf("SingeltonprintStestcount:%d\n",}staticSingelton*single;staticintcount;//noteSingelton*Singelton::single=newSingelton();intSingelton::count=0;int_tmainTTT(intargc,_TCHAR*{Singelton*s1=Singelton::getSingelton();Singelton*s2=Singelton::getSingelton();if(s1==s2){ }{}cout<<"o. return0;}unsignedintthreadfunc2(void{intid=GetCurrentThreadId();printf("\nthreadfunc%d\n",id);return1;}voidthreadfunc(void{intid=GetCurrentThreadId();printf("\nthreadfunc%d\n",id);return;}int_tmain(intargc,_TCHAR*{inti=DWORDdwThreadId[201],dwThrdParam=1;HANDLEhThread[201];intthreadnum=for(i=0;i<threadnum;{ 0,&dwThreadId[i]);hThread[i]=(HANDLE)_beginthread(&threadfunc,0,0);if(hThread[i]==NULL){printf("beginthread%derror!!!\n",i);}}//等待所有的子线程都运行完毕后,for(i=0;i<threadnum;{WaitForSingleObject(hThread[i],INFINITE}for(i=0i<threadnum;{//CloseHandle(hThread[i]}cout<<"o. return0;}多线程下懒汉式单例的Double-CheckedLocking优新建MFC框应用程序MFCDiagram应用程序#include"stdafx.h"#include"01单例优化.h"#include"01Dlg.h"#include"afxdialogex.h"#include"iostream"usingnamespacestd;//staticCCriticalSectionclassSingleton{{TRACE("Singletonbegin\n");TRACE("Singletonend\n");}Singleton&operator=(constSingletonstaticvoid{}//Double-Check2==//1）第1个、2个、3个线程执行第一个检查，都有可能进入黄域（临界区//2）123//3）1个线程执行完毕，cs.unlock()23NULL)2个线程就不需要再次创建了。保证了单例；//5）同样道理，若第2个线程，cs.unlock()后，第3个线程会竞争执行临界区代码；此时staticSingleton{if(pInstance== //double{cs.LockpInstancenull if(pInstance== pInstance=new }return}staticSingletonSingleton*Singleton::pInstance=voidCMy01{ TODO:}voidthreadfunc(void{intid=GetCurrentThreadId();TRACE("\nthreadfunc%d\n",id);}voidCMy01{inti=DWORDdwThreadId[201],dwThrdParam=1;HANDLEhThread[201];intthreadnum=for(i=0;i<threadnum;{ 0,&dwThreadId[i]);hThread[i]=(HANDLE)_beginthread(&threadfunc,0,0);if(hThread[i]==NULL){TRACE("beginthread%derror!!!\n",i);}}for(i=0;i<threadnum;{WaitForSingleObject(hThread[i],INFINITE}for(i=0;i<threadnum;i++){//CloseHandle(hThread[i]}}程序并发机制扩展程序的并发执行往往带来与时间有关的错误，甚至性的。这需（Synchronization同步，因为多个线程在共享资源时如果发生通常会带来不正确的。线程所引起的。为了在多线程程序中解决同步问题，Windows每种对象相对于线程有两种状态——信号状态（signalstate）和非信号状态（ state。当相关联的同步对象处于信号状态时，线以执行（共享资源，反（Event等待一个对象，当指定的发生时，对象通知等待线以开始执Section 该资源之前，前一个线程必须释放临界区对象，以便新的 以索对象 权Semaphore信号量（Semaphore。信号量可以允许一个或有限个线程共享资源。11于等于0，相应线程必须等待。信号量是Windo8步系统的。从本质上讲，互斥量是信号量的一种特殊形式。Windows/NTWindows95Timer总在很多人印象中，单例模式可能是23个设计模式中最简单的一个。如果不考虑多线程，的确如此，但是一旦要在多线程中运用，那么从我们 中可以了解到，它涉及到很编1、CPrimer(StanleyB.Lippman),2MSDN,interlocked3、EffectiveC++04条款(Scott -Local-Static对象初始化顺序以及 pilerOptimizations,andMeyersreset函数。6、的经典之作：设计模7、windows编程(Jeffrey简单工厂模什么是简单工厂模模式中包含的角色及其职//依赖:3案include"iostream"usingnamespacestd;//思想：思想是用一个工厂，来根据输入的条件产生不同的类，然后根据不同类virtual//////class{virtualvoidgetFruit()=classBanana:public{virtualvoid{}classPear:public{virtualvoid{}class{staticFruit*Create(char{Fruit*tmp=if(strcmp(name,"pear")=={tmp=new}elseif(strcmp(name,"banana")=={tmp=new}{return}return}void{Fruit*pear= if(pear==NULL){cout<<"pear失败}Fruit*banana= }。练。virtual函数得到不同的结果。（工厂类与基类为关联关系#include"iostream"usingnamespacestd;//用操作符工厂类生产操作符（加减乘除）,////加减乘除具体的类(2个操作数////思想用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数class{intintvirtualdoubleGetResult()=classAddOperation:public{double{returnfirst+}classSubOperation:public{double{returnfirst-}class{{COperation*tmp=NULL;{casetmp=newAddOperation();case'-tmp=newSubOperation();tmp=}return}void{op1->first=10;op1->second=op2->first=10;op2->second=cout<<"}工厂模概定义一个创建产品对象的工厂接口，将实际创建工作推子类当中。类图角色和职工厂方法模式的，任何工厂类都必须实现这个接口。具体工厂（Concrete 具体产品（ConcreteProduct）角色工厂方法模式和简单工厂模式比工厂方法模式与简单工厂模式在结构上的不同不是很明显工厂方法类的是一个抽象工厂类，而简单工厂模式把放在一个具体类上。式后可以演变成简单工厂模式。#includeusingnamespaceclass{virtualvoid{}class{virtualFruit*{returnnew}//classBanana:public{virtualvoid{cout<<"Banana}//classBananaFactory: {virtualFruit*{returnnew}//classApple:public{virtualvoid{cout<<"Apple}//classAppleFactory: {virtualFruit*{returnnew}void{FruitFactory*ff =NULL;Fruit*fruit=NULL;ff=newBananaFactory();fruit=ff->getFruit();deletefruit;deleteff;//2ff=newAppleFactory();fruit=ff->getFruit();deletefruit;deleteff; }抽象工概产品族和产品等级解释:具体工厂在开闭原则下 能生产香蕉/苹果/梨子 抽象工厂:在开闭原则下 能生产：南方香蕉/苹果/梨子(产品族北方香蕉/苹果/工厂模式只能生产一个产品（要么香蕉、要么苹果抽象工厂可以一下生产一个产品族（里面有很多产品组成模式中包含的角色及其职抽象工厂模式的，包含对多个产品结构的，任何工厂类都必须实现这个接口具体工厂（ 案class{virtualvoid{}class{virtualFruit*{returnnew}virtualFruit*{returnnew}//classSouthBanana:public{virtualvoid{cout<<"SouthBanana}//classSouthApple:public{virtualvoid{cout<<"SouthApple}//classNorthBanana:public{virtualvoid{cout<<"NorthBanana}//classNorthApple:public{virtualvoid{cout<<"NorthApple}classSourthFruitFactory:public{virtualFruit*{returnnew}virtualFruit*{returnnew}classNorthFruitFactory:public{virtualFruit*{returnnew}virtualFruit*{returnnew}void{FruitFactory*ff =NULL;Fruit*fruit=NULL;ff=newSourthFruitFactory();fruit=ff->getApple();fruit=ff->getBanana();deletefruit;deleteff;ff=newNorthFruitFactory();fruit=ff->getApple();fruit=ff->getBanana();deletefruit;deleteff; }建造者模概Builder模式也叫建造者模式或者模式是由GoF23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的-建的对象为一个具有复合属性的复合对象-（这里指builder）对产品属性有不同的创建方角色和ConcreteBuilderABCDirectorBuilderConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，一个对象的构建比较复杂，将一个对象的构建(?)和对象的表示(?)进行创建者模式和工厂模式的Factory1这样做，实现了者和生产线的。强调的是结果Builder模式2、轮胎工厂生产产品，得到汽车部件B45Factory模式不考虑对象的组装过程，而直接生成一个要的对象BuilderFactory而Builder模式所解决的问题是工厂控制产品组装各个部件的过程，然后从产品Builder设计模式就是一种思想。学个模式，花上一两个小时把此模式的意思理解了，就案FlatBuild别墅工程队VillaBuild设计者#include<iostream>usingnamespacestd;#include"string"class{voidsetFloor(string{this->m_floor=}voidsetWall(string{this->m_wall=}voidsetDoor(string{this->m_door=}string{return}string{ }string{return} class{virtualvoidmakeFloor()=0;virtualvoidmakeWall()= virtualvoidmakeDoor()=0;virtualHouse*GetHouse()=//classFlatBuild:public{{pHouse=new}virtualvoid{}virtualvoid{}virtualvoid{}virtualHouse{return}House//classVillaBuild:public{{pHouse=new}virtualvoid{}virtualvoid{}virtualvoid{}virtualHouse{return}Houseclass{voidConstruct(Builder{}void{House*pHose=newHouse;pHose->setDoor("wbm门");deletepHose;/*Builder*builder=newFlatBuild;//指挥者（设计师）Director*director=new//Builder*builder=newdirector->Construct(builder)House*house=builder->GetHouse();cout<<house->getFloor()<<endl;deletehouse;delete//builder=newdirector->Construct(builder)house=builder-cout<<house->getFloor()<<endl;deletehouse;deletebuilder;return;}原型模概Prototype模式是一种对象创建型模式它采取原型对象的方法来创建对象的实例。Prototype模式创建的实例，具有与原型一样的数据。Prototype模式创建的对象，不仅仅角色和这些对象经常着剧烈的变化，但是他们却拥有比较稳定一致的接口。一个复杂对象，具有自我功能，统一一套接口案class{virtual*Clone()=0;virtualvoidprintT()=0;classJavaProgrammer:public{{this->m_name="";this->m_age=0;m_resume=}JavaProgrammer(stringname,int{this->m_name=name;this->m_age=age;m_resume=}{if(m_resume!={m_resume=NULL;}}virtual{JavaProgrammer*p=new*p=*this;returnp;}voidsetResume(char{m_resume=newchar[strlen(resume)+1];strcpy(m_resume,resume);}virtualvoid{cout<<"m_name:"<<m_name<<"\t"<<"m_age:"<<m_age<<endl;if(m_resume!=NULL){cout<<m_resume<<}} charvoid{JavaProgrammerjava 1("",30); *p2= //对象具有自我功能注意深拷贝和浅拷贝题deletep2; return;}结构型模模概模式又叫做模式，是构造型的设计模式之一，它可以为其他对象提供一种（）以控制对这个对象的。，类图角色和职subject（抽象角色真实与的共同接口RealSubject（真实角色定义了角色所代表的真实对象（角色含有对真实角色的角色通常在将客户端调用传递给真是对象之前或适合于提示：ab类；a、bprotocol理论模提示：ab类；a、b#include<string>#include<iostream>usingnamespacestd;//class{virtualvoid//classRealClass:public{virtualvoid{}//classClass:public{virtualvoid{m_realClass=newRealClass();deletem_realClass;}int{Class*test=newClass();return}案案例2cocos2d-x中应用程序被对象，要卖，#include<iostream>usingnamespacestd;subject（抽象角色真实与的共同接口RealSubject（真实角色定义了角色所代表的真实对象（角色含有对真实角色的，角色通常在将客户端调用传递给真是对象之提示：ab类；a、b {virtualvoidSaleBook()=0; RealSubject:public{virtualvoid{cout<<"实体店买 } :publicSubject{virtualvoid{}void{cout"Double11} 2:public{{m_s=}virtualvoid{}void{cout"Double11}RealSubjectvoid{*ptb=new;deleteptb;return}#include"iostream"usingnamespacestd;//abb实现了某一个协议（一套接口class{virtualintApplicationDidFinsh()=0;//classAppDelegate:public{{;}virtualint //cocos2dx函数的{return0;}//Application是类，在类中包含一个真正的实体class{{ap=}void{ap=newdeleteap;}AppDelegate//好处：mainvoid{Application*app=newApplication();if(app=={}cout<<"}练定义真实玩家（定义玩3玩家，代替，进行升级打装饰模概装饰（Decorator）模式又叫做包装模式。通过一种对客户端透明的方式来扩展对象的类图角色和职案#include<iostream>usingnamespacestd;class{virtualvoidshow()=0;classRunCar:public{void{cout可以跑}virtualvoid{}classSwimCarDirector:public{SwimCarDirector(Car{m_p=}void{cout可以游}virtualvoid{m_p-}CarclassFlyCarDirector:public{{m_p=}void{cout可以飞}virtualvoid{m_p-}Carvoid{Car*runcar=runcar=newRunCar;coutSwimCarDirector*swimCar=newSwimCarDirector(runcar);coutFlyCarDirector*flyCar=newFlyCarDirector(swimCar);deleteflyCar;deleteswimCar;deleteruncar;return}适配器模概AdapterAdapter（或外部类）角色和适用于是将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。案#include<iostream>usingnamespacestd;class{void{cout18v的交流电}class{void{cout220v的交流电}classAdapter:public{Adapter(Current220v{m_p220v=}void{cout"adapter中使用电流endl;}Current220vvoid{Current220v*p220v=newCurrent220v;Adapter*padapter=newAdapter(p220v);deletep220v;deletepadapter;return;}练比赛中，中场球员可进攻和防守，通过翻译告诉中场球员，要进攻。 抽象的球员（Attack、Defense） classCenter:public 被适配的对组合模概Composite模式也叫组合模式，是构造型的设计模式之一。通过递归来构造树形的对象结构，并可以通过一个对象来整个对象树。角色和Component（树形结构的节点抽象Leaf（树形结构的叶节点ComponentComponent的实现子类适用于单个对象和组合对象的使用具有一致性。将对象组合成树形结构以表示“部分--案#include<iostream>usingnamespacestd;#include"list"#include"string"class{virtualvoiddisy()=virtualintadd(IFile*ifile)=virtualintremove(IFile*ifile)=0;virtuallist<IFile*>*getChild()=0;classFile:public{File(string{m_list=NULL;m_name=m_name=}{if(m_list!={delete}}virtualvoiddis{cout<<m_name<<}virtualintadd(IFile{return-}virtualintremove(IFile{return-}virtuallist<IFile*>*{return}list<IFile*>* classFolder:public{Folder(string{m_name=m_list=newlist<IFile}{if(m_list=={delete}}virtualvoiddis{cout<<m_name<<}virtualintadd(IFile{return0;}virtualintremove(IFile{return0;}virtuallist<IFile*>*{return}list<IFile*>* voidshowTree(IFile*ifile,int{list<IFile*>*l=NULL;inti=0;for(i=0;i<level;{}ifile->disl=ifile->getChild();if(l!=NULL){for(list<IFile torit=l->begin();it!=l->end();{if((*it)->getChild()=={for(i=0i<=level;i+{}(*it)->dis}{showTree((*it),level+}}}}void{Folder*root=newFolder*dir1=newFolder("111dir");File*txt1=newFile("aaa.txt");Folder*dir12=new//dir12->disFile*txt12=new//txt12->dislist<IFile*>*l=dir1-for(list<IFile torit=l->begin();it!=l->end();{(*it)->dis}//cout测试递归函数endl;showTree(root,0);deletetxt12;deletedir12;deletedir1;deletetxt1;deleteroot; return;}桥接模概把抽象（ion）与行为实现（implementation）分离开来，从而可以保持各部分的独立角色和Bridge抽象类接口（接口或抽象类）对行为实现（Implementor）的 ion子类行为实现类接口( ion接口定义了基于Implementor接口的更次的操作)Implementor适用于车安装发动机；不同型号的车，安装不同型号的发动机图形填颜色 不同形状的图形，填充上不同的颜色将“图形填颜色”这个抽象和实现进行分离，两个名字，就设计两个类案#include<iostream>usingnamespacestd;class{virtualvoidinstallEngine()=classBMW5:public{virtualvoid{cout<<"BMW53500CC"<<}classBMW6:public{virtualvoid{cout<<"BMW64000CC"<<}classJeep11:public{virtualvoid{cout<<"Jeep111100CC"<<}{{classJeep12:public{virtualvoid{cout<<"Jeep121200CC"<<}voidmain1601(){Jeep12*j12=newJeep12;deletej12;return;}class{virtualvoidinstallEngine3500()=0;virtualvoidinstallEngine4000()=0;virtualvoidinstallEngine1100()=0;virtualvoidinstallEngine1200()=classBMW:public{virtualvoid{cout<<"3500CC"<<}virtualvoid{cout<<"4000CC"<<}virtualvoidcout<<"1100CC"<<}virtualvoid{cout<<"1200CC"<<}//void{BMW*bmw5=newBMW;}//class{virtualvoidinstallEngine()=classEngine4000:public{virtualvoid{coutEngine4000"}classEngine3500:public{virtualvoid{coutEngine3500"}classCar(Engine{m_engine=}virtualvoidinstallEngine()=EngineclassBMW7:public{BMW7(Engine*p):{}//注意车的安装virtualvoid{cout<<"BMW7"}void{Engine4000*e4000=newEngine4000;BMW7*bmw7=newBMW7(e4000);deletebmw7;delete}void{}练jeep111100CCJeep11Engine1100CCmain函数中编写测试案例，体会 draw（，抽象一个颜色类color，含有getColor()：string Shape持有一个color的。形成桥接模式。 classCircle:public ClassSquare: ClassRed:publiccolorClassGreen:publiccolor{Colorcolor=newShape*shap=newSquare(color);}外观模概Facade模式也叫外观模式，是由GoF23种设计模式中的一种。Facade模式为一facade。角色和为调用方,sFacade功能提供者。指提供功能的类群（模块或子系统适用于为子系统中统一一套接口，让子系统更加容易使用案#include<iostream>usingnamespacestd;class{void{cout<<"systemA "<<}class{void{cout<<"systemA "<<}class{void{cout<<"systemA "<<}class{{a=newb=newc=new}{deletea;deleteb;delete}void{}SystemASystemBSystemCvoid{SystemA*a=newSystemA;SystemB*b=newSystemB;SystemC*c=newSystemC;deletea;deleteb;deleteFacade*f=newFacade;delete return;}练习案基金（、外汇、、国债享元模概Flyweight角色和是以共享的方式，高效的支持大量的细粒度的对象案#include<iostream>usingnamespacestd;#include"string"#include"map"class{(stringname,intage, {this->name=name;this->age=age; }string{return}int{return}intget{ } /12classTeacher:public{Teacher(stringid,stringname,intage, ):(name, {this->id=}string{return}void{cout<<"id:"<<id<<"\t"<<"name:"<<name<<"\t"<<"age:"<<age<<"\t"<< <<"\t"<<}stringclass{{}{//内存管理是c++程序员的whilem_tpool.empty()){Teacher*tmp=map<string,Teacher*>::i torit=m_tpool.begin();tmp=it->second;deletetmp;}}{ Teacher*tmp=map<string,Teacher*>::i torit= if(it==m_tpool.end()){cout"id为tid<<"的老师不存在,信息"cout<<"请输入老师：";cin>>name;cout<<"请输入老师cin>>cout<<"请输入老师1男2女：";cin>> tmp=newTeacher(tid,name, }{tmp=(it-}return}map<string,Teacher*>void{Teacher*t1=newTeacher("001","",30,1);Teacher*t2=newTeacher("002","",30,1);Teacher*t3=newTeacher("001","",30,1);Teacher*t4newTeacher("004",小吴30,coutt1t3endl;deletet1;deletet2;deletet3;deleteTeacher*t1=teacherFactory->getTeacher("001");t1-return}行为型模模板模式tem概TemteMethod模式也叫模板方法模式，是行为模式之一，它把具有特定步骤算法中应用场TemteMethod模式一般应用在具有以下条件类和操作步骤接耦合角色和案#include<iostream>usingnamespacestd;class{virtualvoidmakeHead()=0;virtualvoidmakeBody()=0;virtualvoidmakeTail()=0; //void{}classMakeBus:public{virtualvoid{cout"bus}virtualvoid{cout"bus}virtualvoid{cout"bus}classMakeJeep:public{virtualvoid{cout"Jeep}virtualvoid{cout"Jeep}virtualvoid{cout"Jeep}void{MakeCar*bus=newMakeCar*jeep=newdeletebus;deletejeep;cout<<"return;}命令模概CommandCommandCommand但在有些情况下有必要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作and类。角色和CommandCommandInvorkerCommand对象。排队或记录请求日志，以及支持可撤销的操作。案#include<iostream>usingnamespacestd;#include"list"class{void{cout卖香蕉}void{cout卖苹果}class{virtualvoidsail()= mand:public{mand(Vendor{m_v=}{return}voidsetV(Vendor{m_v=}virtualvoid{}Vendor mand:public{mand(Vendor{m_v=}{return}voidsetV(Vendor{m_v=}virtualvoid{}Vendorclass{Command { } mand(Command{mand=}void{}Command class{{m_list=newlist<Command*>;}{delete} mands(Command{}list<Command*> {return}void{for(list<Command torit=m_list->begin();it!=m_list->end();it++{}}list<Command*>//void{Vendor*v=newVendor;deletev;return;}//void{Vendor*v=newmand*ac= ac-mand*bc= bc-deletebc;deleteac;deletev;}//waitervoid{Vendor*v=newmand*ac= mand*bc= Waiter*w=newWaiter; deletew;deletebc;deleteac;deletev;}//advwaitervoid{Vendor*v=newmand*ac= mand*bc= AdvWaiter*w=newAdvWaiter; deletew;deletebc;deleteac;deletev;}void{}练责任链模概1：比如客户要完成一个任务，这个任务包括a,b,c,d首先客户把任务交给A，AaB，Bb部分，...，D完成d部分。，例2比如部分的某项工作县先完成自己能处理的部分不能处理的部分给省省再完成自己职责范围内的部分不能处理的部分交给最后完成该项工作。，例3：软件窗口的消息4：SERVLET容器的过滤器（Filter）角色和责任链优缺适用于链条式处理事情。工作流程化、消息处理流程化、事物流程化案#include<iostream>usingnamespacestd;classCarHandle{virtualvoidHandleCar()={this->carhandle=carhandle;returnthis->carhandle;}CarHandleclassCarHandleHead:public{virtualvoid{cout处理车头endl;if(this->carhandle!=NULL){}}classCarHandleBody:public{virtualvoid{cout处理车身endl;if(this->carhandle!=NULL){}}classCarHandleTail:public{virtualvoid{cout处理车尾endl;if(this->carhandle!=NULL){}}void{CarHandleHead*head=newCarHandleHead;CarHandleBody*body=newCarHandleBody;CarHandleTail*tail=newCarHandleTail;//deletehead;deletedeletereturn;}策略模概的算法选择交由客户端决定（策略。Strategy模式主要用来平滑地处理算法的切换。角色和策略（算法）各种策略（算法）适用于准备一组算法，并将每一个算法封装起来，使得它们可以互换使用策略模式可以避免使用多重条件转移语句。多重转移语句不易，它把采取哪一句里面，比使用继承的办法还要原始和。案//SymmetricencryptionclassStrategy{virtualvoidSymEncrypt()=classDes:public{virtualvoid{cout"Des加密}classAES:public{virtualvoid{cout"AES加密}class{{p=}void{p-}//voidmain(){/*不符合开闭原则Strategy*strategyNULL;strategy=newAES;deletestrategy;strategy=newdeletestrategy;Strategy*strategy=NULL;Context*ctx=NULL;strategy=newctx=newContext(strategy);deletectx;cout<<"return;}练100中介者模概Mediator模式也叫中介者模式是由GoF23种软件设计模式的一种Mediator模式是行为模式之一Mediator模式中类之间的交互行为被统一放在Mediator的对象中，Mediator对象同其他对象交互，Mediator对象起着控制器的作用。角色和Mediator（同事的相互作用，从而实现了耦合松散，而且可以独立的改变他们之间的交换。模式优12Mediator控制类与其他关联类的一对多的关系，当其案#include<iostream>usingnamespacestd;#include"string"class{(stringname, ,int{m_name=name; m_condition=}string{return}intget{return }int{return}virtualvoidgetParter(*p)= m_name; /1男2 m_condition; classMan:public{Man(stringname, ,intcondit): ,{;}virtualvoidgetParter({if(this->get()==p->get{cout<<"NoNoNo我不是"<<}if(this->getCondit()==p-{coutthis->getName()<<"p->getName()绝配}{coutthis->getName()<<"p->getName()不配}}classWoman:{Woman(stringname, ,int ,{;}virtualvoidgetParter({if(this->get()==p->get{cout<<"NoNoNo我不是"<<}if(this->getCondit()==p-{coutthis->getName()<<"p->getName()绝配}{coutthis->getName()<<"p->getName()不配}}//以 Man类的太紧密需要解耦void{Woman*w1=newWoman("",2,4);Man*m1=newMan("",1,3);Man*m2=newMan("",1,deletew1;deletem1;deletereturn}classMediator; {2(stringname, ,intcondition,Mediator{m_name=name; m_condition=condition;m_m=m;}string{return}intget{return }int{return}Mediator{return}virtualvoidgetParter(2*p)= m_name; /1男2 m_condition;// Mediator*m_m;class{{pMan=NULL;pWoman=NULL;}void 2{pWoman=}voidsetMan(2{pMan=}void{if(pMan->get()==pWoman->get{cout<<"NoNoNo我不是"<<}if(pMan->getCondit()==pWoman-{coutpMan->getName()<<"pWoman->getName()绝配}{coutpMan->getName()<<"pWoman->getName()不配}}22classWoman2:public{ ,intcondition,Mediator*m): ,{;}virtualvoidgetParter(2{}classMan2:public{Man2(stringname, ,intcondition,Mediator*m): ,condition,{;}virtualvoidgetParter(2{}void{Mediator*mediator=newWoman2*w1=newWoman2("",2,4,mediator);Man2*m1=newMan2("",1,3,mediator);Man2*m2=newMan2("",1,4,deletew1;deletem1;deletem2;}void{//main1901();main1902();}观察者模概Observer模式提供给关联对象一种同步通信的使某个对象与依赖它的其他对象之间保角色和Subject需要维持（添加，删除，通知）Subject的状态发生变化时，Observercallback函数典型应侦听驱动程序设计中的外部发布者/订阅者(publisher/subscriber)模型中当一个外部新的产品消息的出现等等）适用于象都会得到通知。（ 对象状态发生变化时，会通知所有的观察者，使它们能够更新自己案#include<iostream>usingnamespacestd;#include"vector"#include"string"classclassyserObserver{yserObserver(stringname,Secretary{m_name=m_secretary=}voidupdate(string{coutaction:"action} //类（对象，通知者class{voidaddObserver(yserObserver{}voidNotify(string{for(vector<yserObserver torit=v.begin();it!=v.end();it++{}}voidsetAction(string{m_action=}stringvector<yserObserver*>void{//subjectSecretary*s1=new//yserObserver*po1= yserObserver("", yserObserver*po2=new yserObserver("",s1);return;}练备忘录模概Memento模式也叫备忘录模式，是行为模式之一，它的作用是保存对象的内部状态，并在应用场undorollbackMemento一个类需要保存它的对象的状态（Originator角色设计一个类，该类只是用来保存上述对象的状态（Memento角色需要的时候，CaretakerOriginatorMementoundorollbackCaretakerMementoOriginator角色和OriginatorOriginator负责在适当的时间保存/Originator对象的状态。这样就可以将以后的对象状态恢复到先前保存的状态。适用于功能比较复杂的但需要记录或属性历史的类或者需要保存的属性只是多属性中的一小部分时or可以根据保存的Memo还原到前一状态。案#include<iostream>usingnamespacestd;#include"string"class{MememTo(stringname,int{this->m_name=name;this->m_age=age;}voidsetName(string{this->m_name=}string{return}void {this->m_age=}int{return} class{(stringname,int{this->m_name=name;this->m_age=age;}voidsetName(string{this->m_name=}string{return}void {this->m_age=}int{return}void{cout<<"name:"<<m_name<<"age:"<<m_age<<}//{}//{m_name=memto->getName();m_age=memto->getAge();} //class{{this->m_memto=}{return}{this->m_memto=}void{*p=new ("",18);//Caretaker*ct=newCaretaker(p-//deletereturn}void{*p=new ("",18);//p-//deletedelete}void{}者模概角色和+VisitConcreateElement(elem:*+Accept(v:抽象者（Visitor）角色：了一个或者多*+Accept(v:所的各个操作。抽象节点（Element）角色：一个接受操作，接受一个者对象作为一个参量。个复合对象或者一个，如列（List）或集合（Set把数据结构用于数据结构上的行解耦合;者。者模式将有关的行为集中到一个者对象中。那者模式的缺点是是增加新的数据结构变得优缺加一个新的者类，因此，变得很容易。2，者模式将有关的行为集中到一个者对象中，而不是分散到一个个的节点类中。3，者模式可以跨过几个类的等级结构属于不同的等级结构的成员类。迭代子只能属于同一个类型等级结构的成员对象，而不能属于不同等级结构的对象者模。4，积累状态。每一个单独的者对象都集中了相关的行为，从而也就可以在的过程1，增加新的节点类变得很。每增加一个新的节点都意味着要在抽象者角色中增加一个新的抽象操作，并在每一个具体者类中增加相应的具体操作。，2，破坏封装。者模式要求者对象并调用每一个节点对象的操作，这隐含了一个对所有节点对象的要求：它们必须一些自己的操作和内部状态。不然者的，案ABB部分，公园的管理者负责检点各项事务是行为操作，而且者的种类也可能需要根据时间的推移而变化（行为的扩展性。#include<iostream>usingnamespacestd;#include"list"#include"string" //不同的者公园完成不同的动class{virtualvoidvisit(ParkElement*park)=classParkElement{virtualvoidaccept(Visitor*v)=classParkA:public{virtualvoidaccept(Visitor{}classParkB:public{virtualvoidaccept(Visitor{}class :public{{}voidsetPart(ParkElement{}voidaccept(Visitor{for(list<ParkElement torit=m_list.begin();it!=m_list.end();{}}list<ParkElement*>classVisitorA:public{virtualvoidvisit(ParkElement{cout<<"清洁工A公园A部分，打扫卫生完毕"<<}classVisitorB:public{virtualvoidvisit(ParkElement{cout<<"清洁工B公园B部分，打扫卫生完毕"<<}classVisitorManager:public{virtualvoidvisit(ParkElement{cout}void{VisitorA*visitorA=newVisitorA;VisitorB*visitorB=newParkA*partA=newParkB*partB=new//公园接受者aVisitorManager*visitorManager=newVisitorManager;Park*park=newPark;cout<<"return;}#include<iostream>usingnamespacestd;#include"string"#include"list"//m//n//class//者柜class{virtualvoidvisit(Element*element)=//柜员接受客户classElement{virtualvoidaccept(Visitor*v)=0;virtualstringgetName()=0;//AclassEmployeeA:public{{m_name=}virtualvoidaccept(Visitor{}virtualstring{return}string//BclassEmployeeB:public{{m_name=}virtualvoidaccept(Visitor{}string{return}stringclassVisitorA:public{virtualvoidvisit(Element{cout通过element->getName()A业务}classVisitorB:public{virtualvoidvisit(Element{cout通过element->getName()B业务}void{EmployeeA*eAnewEmployeeA("VisitorA*vA=newVisitorA;VisitorB*vB=newdeleteeA;deletevA;deletevB;return;}//BclassEmployees:public{{m_list=newlist<Element}virtualvoidaccept(Visitor{for(list<Element torit=m_list->begin();it!=m_list->end(); {}}string{return}voidaddElement(Element{}voidremoveElement(Element{}list<Element*>*m_list;stringm_name;void{EmployeeA*eAnewEmployeeA("A");EmployeeA*eB=newEmployeeA("B");Employees*es=newEmployees;VisitorA*vA=newVisitorA;VisitorB*vB=newcout<< "<<deleteeA;deleteeB;deletedeletereturn}void{}状态模概角色和StateContextContext某个状态相关的行为。案#include<iostream>usingnamespacestd;classState{virtualvoiddoSomeThing(Worker*w)=class{int{return}voidsetHour(int{m_hour=}State*{return}{m_currstate=}voiddoSomeThing(){} //classState1:public{class :public{{if(w->getHour()==7||w-{cout吃早饭}{deletew->getCurrentState(); //12w->setCurrentState(newState2);}}{if(w->getHour()==9||w-{cout工作}{deletew->getCurren