大話設計模式實現(xiàn)C版

（-）簡單工廠模式…2

（二）策略模式......4

策略與工廠結合…6

單一職責原則……6

開放一一封閉原則6

里氏代換原則7

依賴倒轉(zhuǎn)原則……7

）裝飾模式………7

（四）代理模式………9

（五）工廠方法模式

（六）原型模式………

（七）模板方法模式

迪米特法則

（A）外觀模式

（九）建造者模式（生成器模式）

（十）觀察者模式

（十一）抽象工廠模式............................................................................................................28

（十二）狀態(tài)模式….31

（十三）適配器模式34

（十四）備忘錄模式...........................................................................................................37

（十五）組合模式….39

（十六）迭代器模式,44

（十七）單例模式.…,44

（+A）橋接模式…...........................................................................................................45

（十九）命令模式.…....................................48

（二十）責任鏈模式.....................................50

（二十一）中介者模式...53

（二十二）享元模式…錯誤!未定義書簽。

（二十三）解釋器模式錯誤!未定義書簽。

（二十四）訪問者模式錯誤!未定義書簽。

（一）簡單工廠模式

主要用于創(chuàng)建對象。新添加類時，不會影響以前的系統(tǒng)代碼。核心思想是用一個工廠來

根據(jù)榆入的條件產(chǎn)生不同的類，然后根據(jù)不同類的virtual函數(shù)得到不同的結果。

GOOD:適用于不同情況創(chuàng)建不同的類時

BUG:客戶端必須要知道基類和工廠類，耦合性差

(工廠類與基類為關聯(lián)關系)

例：

〃基類

classCOperation

(

public:

intm_nFirst;

intm_nSecond;

virtualdoubleGctRcsultQ

(

doubledRcsult=0;

returndResult;

}

};

〃加法

classAddOperation:publicCOperation

(

public:

virtualdoubleGctRcsultQ

(

returnm_nFirst4-m_nSccond;

}

};

〃減法

classSubOpcration:publicCOpcration

{

public:

virtualdoubleGetResultO

{

returnm_nFirst-m_nSecond;

)

);

〃工廠類

classCCalculatorFactory-

(

public:

staticCOperation*Create(charcOperator);

};

COpcration*CCalculatorFactonr::Crcatc(charcOpcrator)

(

COpcration*opcr;

〃在C#中可以用反射來取消判斷時用的switch,在C++中用什么呢？RTTI??

switch(cOpcrator)

(

case

oper=newAddOperation0；

break;

case'，：

opcr=ncwSubOperationQ;

break;

default:

oper=ne\vAddOperationQ;

break;

)

returnopcr;

)

客戶端

intmain。

(

inta,b;

cin>>a>>b;

COpcration*op=CCalculatorFactotyziCrcatcf-*);

op->m_nFirst=a;

op->m_nSccond=b;

cout<<op->GetResultO<<：endl;

return0;

（二）策略模式

定義算法家族，分別封裝起來，讓它們之間可以互相替換，讓算法變化，不會影響

到用戶

GOOD:適合類中的成員以方法為主，算法經(jīng)常變動；簡化了單元測試（因為每個

算法都有自己的類，可以通過自己的接口單獨測試。

策略模式和簡單工廠基本相同，但簡單工廠模式只能解決對象創(chuàng)建問題，對于經(jīng)常

變動的算法應使用策略模式。

BUG:客戶端要做出判斷

策略模式（Strategy）結構圖

例

〃策略基類

classCOperation

(

public:

intm_nFirst;

intm_nSecond;

virtualdoubleGctRcsultQ

(

doubledRcsult=0;

returndResult;

)

};

〃策略具體類一加法類

classAddOpcration:publicCOperation

(

public:

AddOperation(intajntb)

m_nFirst=a;

m_nSccond=b;

}

virtualdoubleGcrRcsultQ

(

returnm_nFirst+m_nSccond;

}

};

classContext

(

private:

COperation*op;

public:

Context(COperation*temp)

{

op=temp;

)

doubleGetResultO

(

returnop->GetResult();

〃客戶端

intmain。

{

inta,b;

charc;

cin>>a>>b;

COUtVV”請輸入運算符：；

cin>>c;

switch(c)

{

case'+':

Context"context二newContcxt(nc\vAddC)pcration(a,b));

cout<<context->GetResult()<<endl;

break;

default:

break;

return0;

策略與工廠結合

GOOD:客戶端只需訪問Context類，而不用知道其它任何類信息，實現(xiàn)了低耦合。

在上例基礎上，修改下面內(nèi)容

classContext

(

private:

COperation*op;

public:

Context(charcType)

(

switch(cType)

|

case

op=newAddC)pcration(3,8);

break;

default:

op=newAddOperationQ;

break;

}

}

doubleGetResukO

{

returnop->GetResult();

)

};

〃客戶端

intmain()

(

inta,b;

cin>>a>>b;

Context*test=newContext('+);

cout<<tcst->GctRcsuk()<<cndl;

return0;

}

單一職責原則

就一個類而言，應該僅有一個引起它變化的原因。

如果一個類承擔的職責過多，就等于把這些職責耦合在一起，一個職責的變化可能會削

弱或者抑制這個類完成其它職責能力。這種耦合會導制脆弱的設計，當變化發(fā)生時，設計會

遭受到意想不到的破壞。

如果你能夠想到多于一個的動機去改變一個類，那么這個類就具有多于一個的職

責。

開放一一封閉原則

軟件實體可以擴展，但是不可修改。即對于擴展是開放的，對于修改是封閉的。面

對需求，對程序的改動是通過增加代碼來完成的，而不是改動現(xiàn)有的代碼。

當變化發(fā)生時，我們就創(chuàng)建抽象來隔離以后發(fā)生同類的變化。

開放一一封閉原則是面向?qū)ο蟮暮诵乃?。開發(fā)人員應該對程序中呈現(xiàn)出頻繁變化

的那部分做出抽象，拒絕對任何部分都刻意抽象及不成熟的抽象。

里氏代換原則

一個軟件實體如果使用的是一個父類的話，那么一定適用其子類。而且它察覺不出

父類對象和子類對象的區(qū)別。也就是說：在軟件里面，把父類替換成子類，程序的行為沒有

變化。

子類型必須能夠替換掉它們的父類型。

依賴倒轉(zhuǎn)原則

抽象不應該依賴細節(jié)，細節(jié)應該依賴抽象。即針對接口編程，不要對實現(xiàn)編程。

高層模塊不能依賴低層模塊，兩者都應依賴抽象。

依賴倒轉(zhuǎn)原則是面向?qū)ο蟮臉酥?，用哪種語言編寫程序不重要，如果編寫時考慮的

是如何針對抽象編程而不是針對細節(jié)編程，即程序的所有依賴關系都終止于抽象類或接口。

那就是面向?qū)ο笤O計，反之那就是過程化設計。

（三）裝飾模式

動態(tài)地給一個對象添加一些額外的職責（不重要的功能，只是偶然一次要執(zhí)行），就增

加功能來說，裝飾模式比生成子類更為靈活。建造過程不穩(wěn)定，按正確的順序串聯(lián)起來進行

控制。

GOOD:當你向舊的類中添加新代碼時，一般是為了添加核心職責或主要行為。而當需

要加入的僅僅是一些特定情況下才會執(zhí)行的特定的功能時（簡單點就是不是核心應用的功

能)，就會增加類的復雜度。裝飾模式就是把要添加的附加功能分別放在單獨的類中，并讓

這個類包含它要裝飾的對象，當需要執(zhí)行時，客戶端就可以有選擇地、按順序地使用裝飾功

能包裝對象。

例

#include<string>

#includc<iostrcam>

usingnamespacestd;

//人

classPerson

(

private:

stringm_strNamc;

public:

Pcrson(stringstrNamc)

(

m_strName=strName;

)

Pcrson(){}

virtualvoidShow。

{

coutvv”裝扮的^："<<m_strName<<endl;

)

)；

〃裝飾類

classFinery:publicPerson

(

protected:

Person*m_component;

public:

voidDecorate(Person*component)

(

m_component=component;

)

virtualvoidShow。

(

m_component->Show();

)

}；

〃丁恤

classTShirts:publicFinery

public:

virtualvoidShow。

(

cout<<"TShirts"vVendl;

m_component->Show()；

)

};

〃褲子

classBigTrouser:publicFinery

{

public:

virtualvoidShow。

(

cout?*fBigTrouser**<<endl;

m_component->Show();

)

};

〃客戶端

intmainQ

(

Person*p=ncwPerson("小李”)；

BigTrouser*bt=newBigTrouser。；

TShirts*ts=ncwTShirtsQ;

bt->Dccoratc(p);

ts->Decorate(bt);

ts->ShowQ;

return0;

}

(四)代理模式

GOOD:遠程代理，可以隱藏一個對象在不同地址空間的事實

虛擬代理：通過代理來存放需要很長時間實例化的對象

安全代理：用來控制真實對象的訪問權限

智能引用：當調(diào)用真實對象時，代理處理另外一些事

代理模式（Proxy）結構圖

Proxy類,保存一個引用使得代理可以訪問實體,1\

RealSubject類.定義Proxy所代表的真實實體并提供一個與Subject的接口相同的接口，這樣

代理就可以用來替代實體

例：

#includc<string>

#include<iostream>

usingnamespacestd;

〃定義接口

classInterface

(

public:

virtualvoidRequest。=0;

};

〃真實類

classRealClass:publicInterface

{

public:

virtualvoidRequest。

{

coutvv”真實的請求"vVendl;

)

}；

〃代理類

classProxyClass:publicInterface

(

private:

RealClass*m_rcalClass;

public:

virtualvoidRcquestQ

m_rcalClass=newRcalClassO；

m_realClass->Request。;

deletem_rcalClass;

}

};

客戶端：

intmain。

{

ProxyClass*test=newProxyClassf）;

tcst->RcquestQ;

return0;

(五)工廠方法模式

GOOD:修正了簡單工廠模式中不遵守開放一封閉原則。工廠方法模式把選擇

判斷移到了客戶端去實現(xiàn)，如果想添加新功能就不用修改原來的類，直接修改客戶端即可。

工廠方法模式(FactoryMethod)結構圖

例：

#include<string>

#includc<iostrcam>

usingnamespacestd;

〃實例基類，相當于Product（為了方便，沒用抽象）

classLeiFeng

public:

virtualvoidSweepQ

coutvv”雷鋒掃地"vvendl;

}

};

〃學雷鋒的大學生,相當于ConcrctcProduct

classStudent:publicLeiFeng

{

public:

virtualvoidSweepO

（

coutvv”大學生掃地“vVendl;

）

}；

〃學雷鋒的志愿者，相當于ConcrctcProduct

classVolenter:publicLeiFeng

{

public:

virtualvoidSweepQ

（

coutvv”志愿者"vvendl;

）

）；

〃工場基類Creator

classLeiFcngFactory7

（

public:

virtualIxiFeng*CreateLeiFengQ

（

returnnewT,eiFengO；

}

}；

〃工場具體類

classStuden[Factory：publicLeiFengFactoryr

（

public:

virtualLeiFeng*CrcatcLciFcngO

{

returnnewStudcntQ;

）

};

classVolenterFactory-:publicLeiFengFactory

public:

virtualLciFcng^CrcatcLciFcngO

(

returnnewVolenterQ;

}

)；

〃客戶端

intmain。

(

LciFcngFactoty*sf=ncwLciFcngFactoryO；

LeiFeng*s=sf->CreateLeiFengO；

s->Sweep0；

deletes;

deletesf;

return0;

(六)原型模式

GOOD:從一個對象再創(chuàng)建另外一個可定制的對象，而無需知道任何創(chuàng)建的細

節(jié)。并能提高創(chuàng)建的性能。說白了就COPY技術，把一個對象完整的COPY出一份。

原型模式(Prototype)結構圖

例：

#includc<iostrcam>

#include<vector>

#includc<string>

usingnamespacestd;

〃抽象基類

classPrototype

private:

stringm_strName;

public:

Prototype(stringstrName){m_strName=strName;}

PrototypeQ{m_strName="}

voidShowQ

(

cout<<m_strName<<endI;

)

virtualPrototype*Clone。=0;

};

//classConcreteProtot\'pel

classConcretePrototype1:publicPrototype

{

public:

ConcrctcPrototyrpcl(stringstrName):Prototypc(strNamc){}

ConcretePrototypel0(}

virtualPrototype*CloneQ

{

ConcretePrototype1*p=newConcreteProtot)pel0;

*p=*this;〃復制對象

returnp;

//classConcretePrototype2

classConcrctcPrototyrpc2:publicPrototype

{

public:

ConcretePrototype2(stringstrName):Prototype(strName){}

ConcrctcPrototyrpc2Q{}

virtualPrototype*CloncQ

ConcretcPrototypc2*p=newConcrctcPrototypc2Q;

*p=*this;〃復制對象

returnp;

〃客戶端

intmain。

(

ConcretePrototype1*test=newConcretePrototypel("小王”)；

ConcrctcProtot\'pc2*tcst2=(ConcrctcProtot)q3e2*)tcst->Clone0;

test->Show();

test2->Show();

return0;

(七)模板方法模式

GOOD:把不變的代碼部分都轉(zhuǎn)移到父類中，將可變的代碼用virtual留到子類重寫

模板方法模式(TemplateMethod)結構圖

Abstractclass

實現(xiàn)了一個模板方法，定義了算法的骨架,L

^,TemplateMethod0具體子類將重定義PrimiliveOperation以

^PrinitiveOperation10實現(xiàn)一個算法的步驟

+PrinitiveOperation20

A-

ConcreteClass

實現(xiàn)Primitiveoperation以完成算法中

與特定子類相關的步驟

??PrinitiveOperation10

+PriaitiveOperation20

例：

#include<iostream>

#includc<vcctor>

#include<string>

usingnamespacestd;

classAbstractClass

(

public:

voidShow。

coutvv"我是"vvGetName()vvendl;

protected:

virtualstringGetNamc()=O;

};

classNaruto:publicAbstractClass

{

protected:

virtualstringGctNameQ

(

return"火影史上最帥的六代目---一鳴驚人naruto";

)

}；

classOncPicc:publicAbstractClass

{

protected:

virtualstringGetNameQ

{

return"我是無惡不做的大海賊一路飛"；

)

)；

〃客戶端

intmain。

(

Naruto*man=newNarutoQ;

man->ShowO；

OnePice*man2=newOnePiceQ;

man2->ShowQ;

return0;

)

迪米特法則

如果兩個類不直接通信，那么這兩個類就不應當發(fā)生直接的相互作用。如果

一個類需要調(diào)用另一個類的某個方法的話，可以通過第三個類轉(zhuǎn)發(fā)這個調(diào)用。

在類的結構設計上，每一個類都應該盡量降低成員的訪問權限。

該法則在后面的適配器模式、解釋模式等中有強烈的體現(xiàn)。

(A)外觀模式

GOOD:為子系統(tǒng)的一組接口提供一個一致的界面。使用戶使用起來更加方便。

外觀模式（Facade）結構圖

例：

#include<iostream>

#include<string>

usingnamespacestd;

classSubSysOne

(

public:

voidMethodOneO

(

coutvv”方法一H<<endl;

}

}；

classSubSysTwo

(

public:

voidMethodTwoO

(

coutvv"方法二"vvendl;

)

)；

classSubSysThree

public:

voidMcthodThrecQ

(

coutvv"方法三"vvendl;

}

}；

〃外觀類

classFacade

(

private:

SubSysOnc*subl;

SubSysTwo*sub2;

SubSysThrcc*sub3;

public:

FacadeQ

(

subl=newSubSysOncQ;

sub2=newSubSysTwoO；

sub3=newSubSysThrccQ;

)

?Facade。

(

deletesubl;

deletesub2;

deletesub3;

}

voidFacadeMethodO

{

sub!->MethodOne()；

sub2->McthodTwoQ;

sub3->MethodThreeQ;

}

};

〃客戶端

intmain。

(

Facade*test=newFacade。；

test->FacadeMethod();

return0;

（九）建造者模式（生成器模式）

GOOD:在當創(chuàng)建復雜對象的算法應該獨立于該對象的組成部分以及它們的裝

配方式時適用。（P115頁）

建造者模式（Builder）結構圖

△

具體建造者,實現(xiàn)Builder接口，構造和裝配各個部件

例：

#includc<string>

#include<iostream>

#includc<vcctor>

usingnamespacestd;

〃最終的產(chǎn)品類

classProduct

{

private:

vector<string>m_product;

public:

voidAdd(stringstrtemp)

{

m_product.push_back(strtemp);

)

voidShowQ

vector<string>::iteratorp=m_product.begin();

while(p!=m_d())

{

cout<<*p<<cndl;

p++；

)

)

};

〃建造者基類

classBuilder

{

public:

virtualvoidBuilderA。=0;

virtualvoidBuilderBQ=0;

virtualProduct*GctRcsultQ=0;

};

〃第一種建造方式

classConcreteBuilderl:publicBuilder

{

private:

Product*m_product;

public:

ConcreteBuilderl0

(

m_product=newProduct。；

}

virtualvoidBuilderAQ

(

m_product->Add(noncn);

)

virtualvoidBuilderBQ

{

m_product->Add("two");

)

virtualProduct*GctRcsultQ

(

returnm_product;

)

};

〃第二種建造方式

classConcrctcBuildcr2:publicBuilder

(

private:

Product*m_product;

public:

ConcreteBuilder2()

{

m_product=newProduct。;

)

virtualvoidBuilderAQ

{

m_product->Add("A");

)

virtualvoidBuilderBQ

(

m_product->Add("B");

)

virtualProduct*GetResultQ

(

rewrnm_product;

}

};

〃指揮者類

classDirect

(

public:

voidConstructfBuikler*temp)

{

temp->BuilderAQ;

tcmp->BuildcrB();

}

)；

〃客戶端

intmainQ

(

Direct*p=newDirect。；

Builder*bl=ncwConcrctcBuildcrlQ;

Builder*b2=newConcreteBuilder2();

p->Construct(bl);〃調(diào)用第一種方式

Product*pbl=bl->GctRcsult();

pbl->Show();

p->Construct(b2);〃調(diào)用第二種方式

Product*pb2=b2->GctRcsult();

pb2->Show();

return0;

例二(其實這個例子應該放在前面講的):

#includc<string>

#include<iostream>

#includc<vcctor>

usingnamespacestd;

classPerson

{

public:

virtualvoidCreatcHcadQ=0;

virtualvoidCreateHand()=0;

virtualvoidCreatcBodyO=0;

virtualvoidCreateFootQ=0;

);

classThinPerson:publicPerson

{

public:

virtualvoidCreatcHcad()

(

cout<<Hthinhcad"<<endl;

}

virtualvoidCreatcHandQ

{

cout<<nthinhand"<<cndl;

)

virtualvoidCreatcBodyO

(

cout<<HthinbodyH<<cndl;

)

virtualvoidCrcatcFootO

(

cout<<nthinfootn<<cndl;

}

);

classThickPerson:publicPerson

(

public:

virtualvoidCreateHeadO

cout<<nThickPersonhead"VVendl;

virtualvoidCreateHand0

cout<<HThickPersonhandH<<endl;

)

virtualvoidCreateBodyO

|

cout<<HThickPersonbody"Wendi;

}

virtualvoidCreateFootO

{

cout<<HThickPersonfootn<<endl;

}

};

〃指揮者類

classDirect

|

private:

Person*p;

public:

Dircct(Pcrson*temp){p=temp;}

voidCreate。

(

p->CreateHead();

p->CrcatcBodyO；

p->CreateHand();

p->CrcatcFoot();

}

};

〃客戶端代碼：

intmain。

(

Person*p=newThickPersonQ;

Direct*d=newDircct(p);

d->Create();

deleted;

deletep;

return0;

)

(十)觀察者模式

GOOD:定義了一種一對多的關系，讓多個觀察對象（公司員工）同時監(jiān)聽一

個主題對象（秘書），主題對象狀態(tài)發(fā)生變化時，會通知所有的觀察者，使它們能夠更新自

己。

?interface?

抽象通知者

+增加（in觀察方:抽^觀察罰

本少（in觀察者:抽象觀察荀

+通知0(-

+通知者狀態(tài)0：string

老板前臺

+增加（in觀察者：抽象觀察荀+增加（in觀察者：抽象觀察者）

+減少（in觀察者：抽象觀察知+減少（in觀察者：抽象觀察耕

+通知0+通知0

，通知者狀態(tài)0:string+通知者狀態(tài)0:string

例：

#include<string>

#include<iostream>

#includc<vcctor>

usingnamespacestd;

classSecretary;

〃看股票的同事類(觀察對象，觀察者)

classStockObserver

{

private:

stringname;

Secretary*sub;

public:

StockObsen-er(stringstrname,Secretary*strsub)

(

name=strname;

sub二strsub;

}

voidUpdateQ;

};

〃秘書類(主題對象，通知者)

classSecretary

{

private:

vector<StockObserver>observers;

public:

stringaction;

voidAdd(StockObserverob)

obsenrers.push_back(ob);

voidNotifyO

{

vector<StockObservrer>::iteratorp=observers.beginQ;

while(p!=observers.end())

(

(*p).UpdatcQ;

p++；

)

}

}；

voidStock()bserver::Update()

{

cout<〈namc<<":"<<sub->action<<",不要玩股票了，要開始工作了"<<cndl;

}

〃客戶端

intmain。

{

Secretary*p=ncwSccrctaryQ;//創(chuàng)建通知者

〃觀察者

StockObservcr*sl=newStockObserver("小李",p);

StockObserver*s2=newStockObserver("小趙”,p);

〃加入通知隊列

p->Add(*sl);

p->Add(*s2);

〃事件

p->action二"老板來了”；

〃通知

p->NotifyO；

return0;

觀察者模式（Observer）結構圖

例：

#includc<string>

#include<iostream>

#include<vector>

usingnamespacestd;

classSecretatyBase;

〃抽象觀察者

classCObserverBase

(

protected:

stringname;

Secretan-Base*sub;

public:

CObserv?erBase(stringstrname,Secretar\-Base*strsub)

(

name=strname;

sub=strsub;

}

virtualvoidUpdate。=0;

);

〃具體的觀察者，看股票的

classStockObsenrer:publicCObserverBase

public:

StockObscrvrcr(stringstrnamc,SccrctatyBasc*strsub):C()bscr\^crBase(strnamc,strsub)

virtualvoidUpdate。；

};

〃具體觀察者，看NBA的

classNBAObserver:publicCObservrerBase

(

public:

NBAObscr\rcr(stringstrnamc,Sccrctary'Basc*strsub):CC)bscn-crBasc(strnamc,strsub){}

virtualvoidUpdate。；

);

〃抽象通知者

classSccrctatyBasc

(

public:

stringaction;

vcctor<CObscrvrcrBasc*>observers;

public:

virtualvoidAttach(CObserverBase*observer)=0;

virtualvoidNotifyO=0;

};

〃具體通知者

classSecretary:publicSecretaryBase

(

public:

voidAttach(CObservrerBase*ob)

(

observers.push_back(ob);

)

voidNotifyQ

(

vector<CObserverBase*>::iteratorp=observers.beginQ;

while(p!=obsenrers.end())

(

(*p)->Update();

P++；

}

｝；

voidStockObserxrer::Update()

{

coutvvnamevv":"vvsub->actionvv",不要玩股票了,要開始工作TH?endl;

)

voidNBAObser\rer::UpdateO

{

coutvvnamevv":"vvsub->actionvv",不要看NBA了,老板來了"v〈endl;

客戶端：

intmainQ

(

Sccrctary^Base*p=ncwSecretary。；〃創(chuàng)建觀察者

//被觀察的對象

CObsen-erBase*sl=newNBAObserver(“小李”,p);

CObserverBase*s2=newStockObserver。'小趙",p);

〃加入觀察隊列

p->Attach(sl);

p->Attach(s2);

〃事件

p->action二"老板來了”；

〃通知

p->NotifyO；

return0;

（十一）抽象工廠模式

GOOD:定義了一個創(chuàng)建一系列相關或相互依賴的接口，而無需指定它們的具

體類。

用于交換產(chǎn)品系列，如ACCESS->SQLSERVER;

產(chǎn)品的具體類名被具體工廠的實現(xiàn)分離

例：

#include<string>

#includc<iostrcam>

#include<vector>

usingnamespacestd;

〃用戶抽象接口

classlUser

{

public:

virtualvoidGctUscr()=0;

virtualvoidInsertUser()=O;

)；

〃部門抽象接口

classIDepartment

(

public:

virtualvoidGctDcpartmcnt()=O;

virtualvoidInsertDepartmentO=0;

};

//ACCESS用戶

classCAccessUser:publiclUser

{

public:

virtualvoidGetUserQ

(

cout<<HAcccssGctUser"<<endl;

}

virtualvoidInsertUserQ

(

cout<<HAccessInsertUserM<<endl;

)

};

//ACCESS部門

classCAccessDepartment:publicIDepartment

(

public:

virtualvoidGctDcpartmcntO

(

cout<<HAcccssGctDcpartment"<<endl;

)

virtualvoidInscrtDcpartmentQ

cout<<HAcccssInscrtDcpartmcntH<<cndl;

};

//SQL用戶

classCSqlUser:publiclUser

{

public:

virtualvoidGctUscrQ

(

cout?MSqlUserH?endl;

}

virtualvoidInsertUscrQ

(

cout?nSqlUsern<<endl;

)

);

〃SQL部門類

classCSqlDepartment:publicIDepartment

(

public:

virtualvoidGctDcpartmcntO

(

cout<<**sqlgetDepartmentH<<endl;

}

virtualvoidInscrtDcpartmentQ

(

cout<<nsqlinsertdepartment"<<endl;

)

};

〃抽象工廠

classIFactoty

(

public:

virtuallUser*CrcatcUscr()=O;

virtualIDepartment*CreateDepartmentO=0;

)；

//ACCESS工廠

classAccessFactory:public【Factory

(

public:

virtuallUser*CrcateUscrO

returnnewCAccessUscrQ;

virtualIDcpartmcnt*CrcatcDcpartmcntO

(

returnnewCAcccssDcpartmcntO；

}

);

//SQL工廠

classSqlFactory：publicIFactory

(

public:

virtuallUscr*CrcateUscrQ

(

returnnewCSqlUscrQ;

)

virtual(Department*CreateDepartmentQ

(

returnnewCSqlDepartmentO；

)

};

客戶端：

intmain。

(

IPacton*factory=newSqlFactoryQ;

lUser*user=factoty->CreateUserQ;

IDepartment*depart=factoty->CreateDepartmentO；

user->GetUser();

depart->GetDepartment();

return0;

)

(十二)狀態(tài)模式

GOOD:當一個對象的行為取決于它的狀態(tài)，并且它必須在運行時刻根據(jù)狀態(tài)

改變它的行為時，可考慮用到狀態(tài)模式。

例

#include<iostream>

usingnamespacestd;

classWork;

classForcnoonStatc;

classNoonState;

classState

(

public:

virtualvoidWriteProgram(VCork*w)=0;

);

classWork

{

private:

State*current;

public:

doublehour;

public:

WorkQ;

voidSetState(State*temp)

{

current=temp;

}

voidWrireprogram0

current->WriteProgram(this);

);

classNoonStatc:publicState

(

public:

virtualvoidWriteProgram(Work*w)

|

cout<<nexecuten<<endl;

if((\v->hour)<13)

coutvv"還不錯啦"〈Vendl;

else

coutvv”不行了,還是睡覺吧"vVendl;

}

};

classForenoonState:publicState

{

public:

virtualvoidWritcProgram(Work*w)

(

if((w->hour)<12)

coutvv”現(xiàn)在的精神無敵好”<Vendl;

else

{

w->SetState(newNoonStateQ);

w->Writeprogram();〃注意加上這句

}

)

}；

Work::WorkO

{

current=newForenoonStateO；

}

客戶端：

intmainQ

(

Work*my\vork=newWorkQ;

mywork->hour=9;

mywork->Wrireprogram0;

mywork->hour=14;

mywork->Writeprogram0;

return0;

（十三）適配器模式

GOOD:雙方都不適合修改的時候，可以考慮使用適配器模式

適配器模式（Adapter）結構圖

例：

#includc<iostrcam>

usingnamespacestd;

classTarget

(

public:

virtualvoidRcquestQ

(

coutvv”普通的請求“vvcndl;

}

)；

classAdaptce

(

public:

voidSpecificalRequest。

(

coutvv”特殊請求"vVendl;

}

}；

classAdapter:publicTarget

pnvate:

Adaptec*ada;

public:

virtualvoidRequest。

(

ada->SpccificalRcquestQ;

Target::Request();

}

AdapterO

(

ada=newAdapteeQ;

)

?Adapter。

(

deleteada;

客戶端：

intmain。

(

Adapter*ada=ncwAdapter。；

ada->Request();

deleteada;

return0;

)

例二

#include<iostream>

#includc<string>

usingnamespacestd;

classPlayer

{

protected:

stringname;

public:

Player(stringstrName){name=strNamc;}

virtualvoidAttack0=0;

virtualvoidDefense。=0;

};

classForwards:publicPlayer

public:

For\vards(stringstrName):Playcr(strNamc){}

public:

virtualvoidAttack。

(

cout?name<<11It鋒進攻"vvcndl;

)

virtualvoidDcfcnscQ

(

coutvvnamevv"前鋒防守"vvendl;

)

)；

classCenter:publicPlayer

{

public:

Center(stringstrName):Player(strName){}

public:

virtualvoidAttack0

(

cout<<nam