《大话设都计模式源代码.doc》由会员分享，可在线阅读，更多相关《大话设都计模式源代码.doc（64页珍藏版）》请在三一文库上搜索。
1、（一）简单工厂模式2（二）策略模式4策略与工厂结合6单一职责原则6开放封闭原则6里氏代换原则7依赖倒转原则7（三）装饰模式7（四）代理模式9（五）工厂方法模式11（六）原型模式13（七）模板方法模式15迪米特法则16（八）外观模式16（九）建造者模式（生成器模式）19（十）观察者模式23（十一）抽象工厂模式28（十二）状态模式32（十三）适配器模式34（十四）备忘录模式37（十五）组合模式39（十六）迭代器模式45（十七）单例模式46（十八）桥接模式47（十九）命令模式49（二十）责任链模式52（二十一）中介者模式54（二十二）享元模式56（二十三）解释器模式59（二十四）访问者模式61（一）
2、简单工厂模式主要用于创建对象。新添加类时，不会影响以前的系统代码。核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。GOOD:适用于不同情况创建不同的类时BUG：客户端必须要知道基类和工厂类，耦合性差（工厂类与基类为关联关系）例：/基类class COperationpublic:int m_nFirst;int m_nSecond;virtual double GetResult()double dResult=0;return dResult;/加法class AddOperation : public COperationpublic:v
3、irtual double GetResult()return m_nFirst+m_nSecond;/减法class SubOperation : public COperationpublic:virtual double GetResult()return m_nFirst-m_nSecond;/工厂类class CCalculatorFactorypublic:static COperation* Create(char cOperator);COperation* CCalculatorFactory:Create(char cOperator)COperation *oper; /
4、在C#中可以用反射来取消判断时用的switch，在C+中用什么呢？RTTI？switch (cOperator)case +:oper=new AddOperation();break;case -:oper=new SubOperation();break;default:oper=new AddOperation();break;return oper;客户端int main()int a,b;cinab;COperation * op=CCalculatorFactory:Create(-);op-m_nFirst=a;op-m_nSecond=b;coutGetResult()GetR
5、esult();/客户端int main()int a,b; char c;cinab;coutc; switch(c) case +: Context *context=new Context(new AddOperation(a,b);coutGetResult()GetResult();/客户端int main()int a,b;cinab;Context *test=new Context(+);coutGetResult()endl;return 0;单一职责原则就一个类而言，应该仅有一个引起它变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱
6、或者抑制这个类完成其它职责能力。这种耦合会导制脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责。开放封闭原则软件实体可以扩展，但是不可修改。即对于扩展是开放的，对于修改是封闭的。面对需求，对程序的改动是通过增加代码来完成的，而不是改动现有的代码。当变化发生时，我们就创建抽象来隔离以后发生同类的变化。开放封闭原则是面向对象的核心所在。开发人员应该对程序中呈现出频繁变化的那部分做出抽象，拒绝对任何部分都刻意抽象及不成熟的抽象。里氏代换原则一个软件实体如果使用的是一个父类的话，那么一定适用其子类。而且它察觉不出父类对象和子
7、类对象的区别。也就是说：在软件里面，把父类替换成子类，程序的行为没有变化。子类型必须能够替换掉它们的父类型。依赖倒转原则抽象不应该依赖细节，细节应该依赖抽象。即针对接口编程，不要对实现编程。高层模块不能依赖低层模块，两者都应依赖抽象。依赖倒转原则是面向对象的标志，用哪种语言编写程序不重要，如果编写时考虑的是如何针对抽象编程而不是针对细节编程，即程序的所有依赖关系都终止于抽象类或接口。那就是面向对象设计，反之那就是过程化设计。（三）装饰模式动态地给一个对象添加一些额外的职责（不重要的功能，只是偶然一次要执行），就增加功能来说，装饰模式比生成子类更为灵活。建造过程不稳定，按正确的顺序串联起来进行控
8、制。GOOD:当你向旧的类中添加新代码时，一般是为了添加核心职责或主要行为。而当需要加入的仅仅是一些特定情况下才会执行的特定的功能时（简单点就是不是核心应用的功能），就会增加类的复杂度。装饰模式就是把要添加的附加功能分别放在单独的类中，并让这个类包含它要装饰的对象，当需要执行时，客户端就可以有选择地、按顺序地使用装饰功能包装对象。例#include #include using namespace std;/人class Personprivate:string m_strName;public:Person(string strName)m_strName=strName;Person()v
9、irtual void Show()cout装扮的是:m_strNameShow();/T恤class TShirts: public Finerypublic:virtual void Show()coutT ShirtsShow();/裤子class BigTrouser :public Finerypublic:virtual void Show()cout Big TrouserShow();/客户端int main()Person *p=new Person(小李);BigTrouser *bt=new BigTrouser();TShirts *ts=new TShirts();b
10、t-Decorate(p);ts-Decorate(bt);ts-Show();return 0;（四）代理模式GOOD：远程代理，可以隐藏一个对象在不同地址空间的事实虚拟代理：通过代理来存放需要很长时间实例化的对象安全代理：用来控制真实对象的访问权限智能引用：当调用真实对象时，代理处理另外一些事例：#include #include using namespace std;/定义接口class Interfacepublic:virtual void Request()=0;/真实类class RealClass : public Interfacepublic:virtual void R
11、equest()cout真实的请求Request();delete m_realClass;客户端：int main()ProxyClass* test=new ProxyClass();test-Request();return 0;（五）工厂方法模式GOOD：修正了简单工厂模式中不遵守开放封闭原则。工厂方法模式把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。例：#include #include using namespace std;/实例基类，相当于Product(为了方便，没用抽象)class LeiFengpublic:virtual void
12、 Sweep()cout雷锋扫地endl;/学雷锋的大学生，相当于ConcreteProductclass Student: public LeiFengpublic:virtual void Sweep()cout大学生扫地endl;/学雷锋的志愿者，相当于ConcreteProductclass Volenter: public LeiFengpublic :virtual void Sweep()cout志愿者CreateLeiFeng();s-Sweep();delete s;delete sf;return 0;（六）原型模式GOOD：从一个对象再创建另外一个可定制的对象，而无需知道
13、任何创建的细节。并能提高创建的性能。 说白了就COPY技术，把一个对象完整的COPY出一份。例：#include#include #include using namespace std;class Prototype /抽象基类 private:string m_strName;public: Prototype(string strName) m_strName = strName; Prototype() m_strName = ; void Show() coutm_strNameClone();test-Show();test2-Show();return 0;（七）模板方法模式GO
14、OD：把不变的代码部分都转移到父类中，将可变的代码用virtual留到子类重写例：#include#include #include using namespace std;class AbstractClasspublic:void Show()cout我是GetName()Show();OnePice* man2 = new OnePice();man2-Show();return 0;迪米特法则如果两个类不直接通信，那么这两个类就不应当发生直接的相互作用。如果一个类需要调用另一个类的某个方法的话，可以通过第三个类转发这个调用。在类的结构设计上，每一个类都应该尽量降低成员的访问权限。 该法
15、则在后面的适配器模式、解释模式等中有强烈的体现。（八）外观模式GOOD：为子系统的一组接口提供一个一致的界面。使用户使用起来更加方便。例：#include#include using namespace std;class SubSysOnepublic:void MethodOne()cout方法一endl;class SubSysTwopublic:void MethodTwo()cout方法二endl;class SubSysThreepublic:void MethodThree()cout方法三MethodOne();sub2-MethodTwo();sub3-MethodThree
16、();/客户端int main()Facade* test = new Facade();test-FacadeMethod();return 0;（九）建造者模式（生成器模式）GOOD：在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用。 （P115页）例：#include #include #include using namespace std;/最终的产品类class Product private:vector m_product;public:void Add(string strtemp)m_product.push_back(strtemp);void S
17、how()vector:iterator p=m_product.begin();while (p!=m_product.end()cout*pAdd(one);virtual void BuilderB()m_product-Add(two);virtual Product* GetResult()return m_product;/第二种建造方式class ConcreteBuilder2 : public Builderprivate:Product * m_product;public:ConcreteBuilder2()m_product=new Product();virtual
18、void BuilderA()m_product-Add(A);virtual void BuilderB()m_product-Add(B);virtual Product* GetResult()return m_product;/指挥者类class Directpublic:void Construct(Builder* temp)temp-BuilderA();temp-BuilderB();/客户端int main()Direct *p=new Direct();Builder* b1=new ConcreteBuilder1();Builder* b2=new ConcreteBu
19、ilder2();p-Construct(b1);/调用第一种方式Product* pb1=b1-GetResult();pb1-Show();p-Construct(b2); /调用第二种方式Product * pb2=b2-GetResult();pb2-Show();return 0;例二（其实这个例子应该放在前面讲的）：#include #include #include using namespace std;class Personpublic:virtual void CreateHead()=0;virtual void CreateHand()=0;virtual void
20、CreateBody()=0;virtual void CreateFoot()=0;class ThinPerson : public Personpublic:virtual void CreateHead()coutthin headendl;virtual void CreateHand()coutthin handendl;virtual void CreateBody()coutthin bodyendl;virtual void CreateFoot()coutthin footendl;class ThickPerson : public Personpublic:virtua
21、l void CreateHead()coutThickPerson headendl;virtual void CreateHand()coutThickPerson handendl;virtual void CreateBody()coutThickPerson bodyendl;virtual void CreateFoot()coutThickPerson footCreateHead();p-CreateBody();p-CreateHand();p-CreateFoot();/客户端代码：int main() Person *p=new ThickPerson();Direct
22、*d= new Direct(p);d-Create();delete d;delete p;return 0;（十）观察者模式GOOD：定义了一种一对多的关系，让多个观察对象（公司员工）同时监听一个主题对象（秘书），主题对象状态发生变化时，会通知所有的观察者，使它们能够更新自己。 例：#include #include #include using namespace std;class Secretary;/看股票的同事类（观察对象，观察者）class StockObserverprivate:string name;Secretary* sub;public:StockObserver(
23、string strname,Secretary* strsub)name=strname;sub=strsub;void Update();/秘书类（主题对象，通知者）class Secretaryprivate:vector observers;public:string action;void Add(StockObserver ob)observers.push_back(ob);void Notify() vector:iterator p = observers.begin();while (p!=observers.end()(*p).Update();p+;void Stock
24、Observer:Update()coutname:action,不要玩股票了，要开始工作了Add(*s1);p-Add(*s2); /事件p-action=老板来了;/通知p-Notify();return 0;例：#include #include #include using namespace std;class SecretaryBase;/抽象观察者class CObserverBaseprotected:string name;SecretaryBase* sub;public:CObserverBase(string strname,SecretaryBase* strsub)
25、name=strname;sub=strsub;virtual void Update()=0;/具体的观察者，看股票的class StockObserver : public CObserverBasepublic:StockObserver(string strname,SecretaryBase* strsub) : CObserverBase(strname,strsub)virtual void Update();/具体观察者，看NBA的class NBAObserver : public CObserverBasepublic:NBAObserver(string strname,
26、SecretaryBase* strsub) : CObserverBase(strname,strsub)virtual void Update();/抽象通知者class SecretaryBasepublic:string action;vector observers;public:virtual void Attach(CObserverBase* observer)=0;virtual void Notify()=0;/具体通知者class Secretary :public SecretaryBasepublic:void Attach(CObserverBase* ob)observers.push_back(ob);void Notify() vector:iterator p = observers.begin();while (p!=observers.end()(*p)-Update();p+;void StockObserver:Update()coutname:action,不要玩股票了，要开始工作了endl;void NBAObserver:Upda