大话设计模式源代码共34页word资料.docx
《大话设计模式源代码共34页word资料.docx》由会员分享，可在线阅读，更多相关《大话设计模式源代码共34页word资料.docx（55页珍藏版）》请在冰点文库上搜索。
大话设计模式源代码共34页word资料
（一）简单工厂模式
主要用于创建对象。
新添加类时，不会影响以前的系统代码。
核心思想是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的virtual函数得到不同的结果。
GOOD:
适用于不同情况创建不同的类时
BUG：
客户端必须要知道基类和工厂类，耦合性差
（工厂类与基类为关联关系）
例：
//基类
classCOperation
public:
intm_nFirst;
intm_nSecond;
virtualdoubleGetResult（）
doubledResult=0;
returndResult;
//加法
classAddOperation:
publicCOperation
public:
virtualdoubleGetResult（）
returnm_nFirst+m_nSecond;
//减法
classSubOperation:
publicCOperation
public:
virtualdoubleGetResult（）
returnm_nFirst-m_nSecond;
//工厂类
classCCalculatorFactory
public:
staticCOperation*Create（charcOperator）;
COperation*CCalculatorFactory:
:
Create（charcOperator）
COperation*oper;
//在C#中可以用反射来取消判断时用的switch，在C++中用什么呢？
RTTI？
？
switch（cOperator）
case'+':
oper=newAddOperation（）;
break;
case'-':
oper=newSubOperation（）;
break;
default:
oper=newAddOperation（）;
break;
returnoper;
客户端
intmain（）
inta,b;
cin>>a>>b;
COperation*op=CCalculatorFactory:
:
Create（'-'）;
op->m_nFirst=a;
op->m_nSecond=b;
cout<GetResult（）<return0;
（二）策略模式
定义算法家族，分别封装起来，让它们之间可以互相替换，让算法变化，不会影响到用户
GOOD:
适合类中的成员以方法为主，算法经常变动；简化了单元测试（因为每个算法都有自己的类，可以通过自己的接口单独测试。
策略模式和简单工厂基本相同，但简单工厂模式只能解决对象创建问题，对于经常变动的算法应使用策略模式。
BUG:
客户端要做出判断
例
//策略基类
classCOperation
public:
intm_nFirst;
intm_nSecond;
virtualdoubleGetResult（）
doubledResult=0;
returndResult;
//策略具体类—加法类
classAddOperation:
publicCOperation
public:
AddOperation（inta,intb）
m_nFirst=a;
m_nSecond=b;
virtualdoubleGetResult（）
returnm_nFirst+m_nSecond;
classContext
private:
COperation*op;
public:
Context（COperation*temp）
op=temp;
doubleGetResult（）
returnop->GetResult（）;
//客户端
intmain（）
inta,b;
charc;
cin>>a>>b;
cout<<”请输入运算符：
;
cin>>c;
switch（c）
case‘+’:
Context*context=newContext（newAddOperation（a,b））;
cout<GetResult（）<break;
default:
break;
return0;
策略与工厂结合
GOOD:
客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。
在上例基础上，修改下面内容
classContext
private:
COperation*op;
public:
Context（charcType）
switch（cType）
case'+':
op=newAddOperation（3,8）;
break;
default:
op=newAddOperation（）;
break;
doubleGetResult（）
returnop->GetResult（）;
//客户端
intmain（）
inta,b;
cin>>a>>b;
Context*test=newContext（'+'）;
cout<GetResult（）<return0;
单一职责原则
就一个类而言，应该仅有一个引起它变化的原因。
如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其它职责能力。
这种耦合会导制脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。
如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责。
开放――封闭原则
软件实体可以扩展，但是不可修改。
即对于扩展是开放的，对于修改是封闭的。
面对需求，对程序的改动是通过增加代码来完成的，而不是改动现有的代码。
当变化发生时，我们就创建抽象来隔离以后发生同类的变化。
开放――封闭原则是面向对象的核心所在。
开发人员应该对程序中呈现出频繁变化的那部分做出抽象，拒绝对任何部分都刻意抽象及不成熟的抽象。
里氏代换原则
一个软件实体如果使用的是一个父类的话，那么一定适用其子类。
而且它察觉不出父类对象和子类对象的区别。
也就是说：
在软件里面，把父类替换成子类，程序的行为没有变化。
子类型必须能够替换掉它们的父类型。
依赖倒转原则
抽象不应该依赖细节，细节应该依赖抽象。
即针对接口编程，不要对实现编程。
高层模块不能依赖低层模块，两者都应依赖抽象。
依赖倒转原则是面向对象的标志，用哪种语言编写程序不重要，如果编写时考虑的是如何针对抽象编程而不是针对细节编程，即程序的所有依赖关系都终止于抽象类或接口。
那就是面向对象设计，反之那就是过程化设计。
（三）装饰模式
动态地给一个对象添加一些额外的职责（不重要的功能，只是偶然一次要执行），就增加功能来说，装饰模式比生成子类更为灵活。
建造过程不稳定，按正确的顺序串联起来进行控制。
GOOD:
当你向旧的类中添加新代码时，一般是为了添加核心职责或主要行为。
而当需要加入的仅仅是一些特定情况下才会执行的特定的功能时（简单点就是不是核心应用的功能），就会增加类的复杂度。
装饰模式就是把要添加的附加功能分别放在单独的类中，并让这个类包含它要装饰的对象，当需要执行时，客户端就可以有选择地、按顺序地使用装饰功能包装对象。
例
#include
#include
usingnamespacestd;
//人
classPerson
private:
stringm_strName;
public:
Person（stringstrName）
m_strName=strName;
Person（）{}
virtualvoidShow（）
cout<<"装扮的是:
"<//装饰类
classFinery:
publicPerson
protected:
Person*m_component;
public:
voidDecorate（Person*component）
m_component=component;
virtualvoidShow（）
m_component->Show（）;
//T恤
classTShirts:
publicFinery
public:
virtualvoidShow（）
cout<<"TShirts"<m_component->Show（）;
//裤子
classBigTrouser:
publicFinery
public:
virtualvoidShow（）
cout<<"BigTrouser"<m_component->Show（）;
//客户端
intmain（）
Person*p=newPerson（"小李"）;
BigTrouser*bt=newBigTrouser（）;
TShirts*ts=newTShirts（）;
bt->Decorate（p）;
ts->Decorate（bt）;
ts->Show（）;
return0;
（四）代理模式
GOOD：
远程代理，可以隐藏一个对象在不同地址空间的事实
虚拟代理：
通过代理来存放需要很长时间实例化的对象
安全代理：
用来控制真实对象的访问权限
智能引用：
当调用真实对象时，代理处理另外一些事
例：
#include
#include
usingnamespacestd;
//定义接口
classInterface
public:
virtualvoidRequest（）=0;
//真实类
classRealClass:
publicInterface
public:
virtualvoidRequest（）
cout<<"真实的请求"<//代理类
classProxyClass:
publicInterface
private:
RealClass*m_realClass;
public:
virtualvoidRequest（）
m_realClass=newRealClass（）;
m_realClass->Request（）;
deletem_realClass;
客户端：
intmain（）
ProxyClass*test=newProxyClass（）;
test->Request（）;
return0;
（五）工厂方法模式
GOOD：
修正了简单工厂模式中不遵守开放－封闭原则。
工厂方法模式把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。
例：
#include
#include
usingnamespacestd;
//实例基类，相当于Product（为了方便，没用抽象）
classLeiFeng
public:
virtualvoidSweep（）
cout<<"雷锋扫地"<//学雷锋的大学生，相当于ConcreteProduct
classStudent:
publicLeiFeng
public:
virtualvoidSweep（）
cout<<"大学生扫地"<//学雷锋的志愿者，相当于ConcreteProduct
classVolenter:
publicLeiFeng
public:
virtualvoidSweep（）
cout<<"志愿者"<//工场基类Creator
classLeiFengFactory
public:
virtualLeiFeng*CreateLeiFeng（）
returnnewLeiFeng（）;
//工场具体类
classStudentFactory:
publicLeiFengFactory
public:
virtualLeiFeng*CreateLeiFeng（）
returnnewStudent（）;
classVolenterFactory:
publicLeiFengFactory
public:
virtualLeiFeng*CreateLeiFeng（）
returnnewVolenter（）;
//客户端
intmain（）
LeiFengFactory*sf=newLeiFengFactory（）;
LeiFeng*s=sf->CreateLeiFeng（）;
s->Sweep（）;
deletes;
deletesf;
return0;
（六）原型模式
GOOD：
从一个对象再创建另外一个可定制的对象，而无需知道任何创建的细节。
并能提高创建的性能。
说白了就COPY技术，把一个对象完整的COPY出一份。
例：
#include
#include
#include
usingnamespacestd;
classPrototype//抽象基类
private:
stringm_strName;
public:
Prototype（stringstrName）{m_strName=strName;}
Prototype（）{m_strName="";}
voidShow（）
cout<virtualPrototype*Clone（）=0;
//classConcretePrototype1
classConcretePrototype1:
publicPrototype
public:
ConcretePrototype1（stringstrName）:
Prototype（strName）{}
ConcretePrototype1（）{}
virtualPrototype*Clone（）
ConcretePrototype1*p=newConcretePrototype1（）;
*p=*this;//复制对象
returnp;
//classConcretePrototype2
classConcretePrototype2:
publicPrototype
public:
ConcretePrototype2（stringstrName）:
Prototype（strName）{}
ConcretePrototype2（）{}
virtualPrototype*Clone（）
ConcretePrototype2*p=newConcretePrototype2（）;
*p=*this;//复制对象
returnp;
//客户端
intmain（）
ConcretePrototype1*test=newConcretePrototype1（"小王"）;
ConcretePrototype2*test2=（ConcretePrototype2*）test->Clone（）;
test->Show（）;
test2->Show（）;
return0;
（七）模板方法模式
GOOD：
把不变的代码部分都转移到父类中，将可变的代码用virtual留到子类重写
例：
#include
#include
#include
usingnamespacestd;
classAbstractClass
public:
voidShow（）
cout<<"我是"<protected:
virtualstringGetName（）=0;
classNaruto:
publicAbstractClass
protected:
virtualstringGetName（）
return"火影史上最帅的六代目---一鸣惊人naruto";
classOnePice:
publicAbstractClass
protected:
virtualstringGetName（）
return"我是无恶不做的大海贼---路飞";
//客户端
intmain（）
Naruto*man=newNaruto（）;
man->Show（）;
OnePice*man2=newOnePice（）;
man2->Show（）;
return0;
迪米特法则
如果两个类不直接通信，那么这两个类就不应当发生直接的相互作用。
如果一个类需要调用另一个类的某个方法的话，可以通过第三个类转发这个调用。
在类的结构设计上，每一个类都应该尽量降低成员的访问权限。
该法则在后面的适配器模式、解释模式等中有强烈的体现。
（八）外观模式
GOOD：
为子系统的一组接口提供一个一致的界面。
使用户使用起来更加方便。
例：
#include
#include
usingnamespacestd;
classSubSysOne
public:
voidMethodOne（）
cout<<"方法一"<classSubSysTwo
public:
voidMethodTwo（）
cout<<"方法二"<classSubSysThree
public:
voidMethodThree（）
cout<<"方法三"<//外观类
classFacade
private:
SubSysOne*sub1;
SubSysTwo*sub2;
SubSysThree*sub3;
public:
Facade（）
sub1=newSubSysOne（）;
sub2=newSubSysTwo（）;
sub3=newSubSysThree（）;
~Facade（）
deletesub1;
deletesub2;
deletesub3;
voidFacadeMethod（）
sub1->MethodOne（）;
sub2->MethodTwo（）;
sub3->MethodThree（）;
//客户端
intmain（）
Facade*test=newFacade（）;
test->FacadeMethod（）;
return0;
（九）建造者模式（生成器模式）
GOOD：
在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用。
（P115页）
例：
#include
#include
#include
usingnamespacestd;
//最终的产品类
classProduct
private:
vectorm_product;
public:
voidAdd（stringstrtemp）
m_product.push_back（strtemp）;
voidShow（）
vector:
:
iteratorp=m_product.begin（）;
while（p!
=m_product.end（））
cout<<*p<p++;
//建造者基类
classBuilder
public:
virtualvoidBuilderA（）=0;
virtualvoidBuilderB（）=0;
virtualProduct*GetResult（）=0;
//第一种建造方式
classConcreteBuilder1:
publicBuilder
private:
Product*m_product;
public:
ConcreteBuilder1（）
m_product=newProduct（）;
virtualvoidBuilderA（）
m_product->Add（"one"）;
virtualvoidBuilderB（）
m_product->Add（"two"）;
virtualProduct*GetResult（）
returnm_product;
//第二种建造方式
classConcreteBuilder2:
publicBuilder
private:
Product*m_product;
public:
ConcreteBuilder2（）
m_product=newProduct（）;
virtualvoidBuilderA（）
m_product->Add（"A"）;
virtualvoidBuilderB（）
m_product->Add（"B"）;
virtualProduct*GetResult（）
returnm_product;
//指挥者类
classDirect
public:
voidConstruct（Builder*temp）
temp->BuilderA（）;
temp->BuilderB（）;
//客户端
intmain（）
Direct*p=newDirect（）;
Builder*b1=newConcreteBuilder1（）;
Builder*b2=newConcreteBuilder2（）;
p->Construct（b1）; //调用第一种方式
Product*pb1=b1->GetResult（）;
pb1->Show（）;
p->Construct（b2）;//调用第二种方式
Product*pb2=b2->GetResult（）;
pb2->Show（）;
return0;
升级会员 