當前位置：首頁 > 编程语言 > asp.net >内容正文

asp.net

设计模式3—行为型模式

發布時間：2024/7/23 asp.net 30 豆豆

生活随笔收集整理的這篇文章主要介紹了设计模式3—行为型模式小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述，主要包含以下11種設計模式：

模板方法模式（Template Method Pattern）
使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。

命令模式（Command Pattern）
是將一個請求封裝為一個對象，從而使你可用不同的請求對客戶端進行參數化；對請求排隊或記錄請求日志，以及支持可撤銷的操作。

責任鏈模式（Chain of Responsibility Pattern）
在該模式里，很多對象由每一個對象對其下家的引用而連接起來形成一條鏈。請求在這個鏈上傳遞，直到鏈上的某一個對象決定處理此請求，這使得系統可以在不影響客戶端的情況下動態地重新組織鏈和分配責任。

策略模式（Strategy Pattern）
就是準備一組算法，并將每一個算法封裝起來，使得它們可以互換。

中介者模式（Mediator Pattern）
就是定義一個中介對象來封裝系列對象之間的交互。終結者使各個對象不需要顯示的相互調用，從而使其耦合性松散，而且可以獨立的改變他們之間的交互。

觀察者模式（Observer Pattern）
定義對象間的一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴于它的對象都得到通知并被自動更新。

備忘錄模式（Memento Pattern）
是在不破壞封裝的前提下，捕獲一個對象的內部狀態，并在該對象之外保存這個狀態。

訪問者模式（Visitor Pattern）
就是表示一個作用于某對象結構中的各元素的操作，它使你可以在不改變各元素的類的前提下定義作用于這些元素的新操作。

狀態模式（State Pattern）
就是對象的行為，依賴于它所處的狀態。

解釋器模式（Interpreter Pattern）
就是描述了如何為簡單的語言定義一個語法，如何在該語言中表示一個句子，以及如何解釋這些句子。

迭代器模式（Iterator Pattern）
是提供了一種方法順序來訪問一個聚合對象中的各個元素，而又不需要暴露該對象的內部表示。

1. 模板方法模式

#include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std;// /*所謂的模板模式：把業務邏輯給做好（和外觀模式類似，只是按一定順序調用）就是按一定次序調用 */ // class Car { public:virtual void makeCarHead() = 0;virtual void makeCarBody() = 0;virtual void makeCarTail() = 0;void makeCar(){//直接按一定順序調度函數makeCarBody(); //先造車身makeCarHead(); //再造車頭makeCarTail(); //最后造車尾} protected: private: }; // class Jeep : public Car { public:virtual void makeCarHead(){cout << "jeep head" << endl;}virtual void makeCarBody(){cout << "jeep body" << endl;}virtual void makeCarTail(){cout << "jeep tail" << endl;} };class Bus : public Car { public:virtual void makeCarHead(){cout << "Bus head" << endl;}virtual void makeCarBody(){cout << "Bus body" << endl;}virtual void makeCarTail(){cout << "Bus tail" << endl;} };int main() {Car *car = new Bus;car->makeCar();delete car;Car *car2 = new Jeep;car2->makeCar();delete car2;system("pause");return 0; }

2. 命令模式

#include <stdlib.h> #include <stdio.h> #include <list> #include <iostream> using namespace std;// /* Command模式也叫命令模式，是行為設計模式的一種。Command模式通過被稱為 Command的類封裝了對目標對象的調用行為以及調用參數。在面向對象的程序設計中，一個對象調用另一個對象，一般情況下的調用過程是：創建目標對象實例；設置調用參數；調用目標對象的方法。但在有些情況下有必要使用一個專門的類對這種調用過程加以封裝，我們把這種專門的類稱作command類。*/ //class Doctor { public:void treat_eye(){cout << "醫生治療眼睛" << endl;}void treat_nose(){cout << "醫生治療鼻子" << endl;} protected: private: };class CommandTreatEye { public:CommandTreatEye(Doctor *doctor){m_doctor = doctor;}void treat(){m_doctor->treat_eye();} private:Doctor *m_doctor; };class CommandTreatNose { public:CommandTreatNose(Doctor *doctor){m_doctor = doctor;}void treat(){m_doctor->treat_nose();} private:Doctor *m_doctor; };//命令可以在抽象 class Command { public:virtual void treat() = 0; protected: private: }; class TreatEye : public Command { public:TreatEye(Doctor* doctor) :m_doctor(doctor){}virtual void treat(){m_doctor->treat_eye();} protected: private:Doctor *m_doctor; }; class TreatNose :public Command { public:TreatNose(Doctor* doctor) :m_doctor(doctor){}virtual void treat(){m_doctor->treat_nose();} protected: private:Doctor *m_doctor; };class BeautyNurse { public:BeautyNurse(Command* command):m_command(command){}void submitCase(){m_command->treat();} protected: private:Command *m_command; }; class HeadNurse { public:HeadNurse(){m_list.clear();} public:void setCommand(Command *command){m_list.push_back(command);}void SubmittedCase() //提交病例下單命令{for (list<Command *>::iterator it = m_list.begin(); it != m_list.end(); it++){(*it)->treat();}} private:list<Command *> m_list; };int main() {//1 一般的醫生直接看病cout << "一般的醫生直接看病" << endl;Doctor *doctor = new Doctor ;doctor->treat_eye();delete doctor;cout << endl;//2 通過一個命令醫生通過命令治療治病cout << "通過一個命令醫生通過命令治療治病" << endl;doctor = new Doctor;CommandTreatEye * commandtreateye = new CommandTreatEye(doctor); //shift +u //轉小寫 shift+ctl + u轉大寫commandtreateye->treat();delete commandtreateye;delete doctor;cout << endl;//護士提交簡歷給以上看病BeautyNurse *beautynurse = NULL; Command *command = NULL;cout << "\n護士發送號令" << endl;command = new TreatNose(doctor); //shift +u //轉小寫 shift+ctl + u轉大寫beautynurse = new BeautyNurse(command);beautynurse->submitCase(); delete command;delete beautynurse;//通過護士長批量的下單命令//護士提交簡歷給以上看病cout << "\n護士長發送號令" << endl;HeadNurse *headnurse = NULL;Command *command1 = NULL;Command *command2 = NULL;command1 = new TreatEye(doctor); //shift +u //轉小寫 shift+ctl + u轉大寫command2 = new TreatNose(doctor); //shift +u //轉小寫 shift+ctl + u轉大寫headnurse = new HeadNurse(); //new 護士長headnurse->setCommand(command1);headnurse->setCommand(command2);headnurse->SubmittedCase(); // 護士長批量下單命令delete command1;delete command2;delete headnurse;system("pause");return 0; }

3. 責任鏈模式

#include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std;// /*Chain of Responsibility（CoR）模式也叫職責鏈模式或者職責連鎖模式，是行為模式之一，該模式構造一系列分別擔當不同的職責的類的對象來共同完成一個任務，這些類的對象之間像鏈條一樣緊密相連，所以被稱作職責鏈模式。例1：比如客戶Client要完成一個任務，這個任務包括a,b,c,d四個部分。首先客戶Client把任務交給A，A完成a部分之后，把任務交給B，B完成b部分，...，直到D完成d部分。例2：比如政府部分的某項工作，縣政府先完成自己能處理的部分，不能處理的部分交給省政府，省政府再完成自己職責范圍內的部分，不能處理的部分交給中央政府，中央政府最后完成該項工作。例3：軟件窗口的消息傳播。例4：SERVLET容器的過濾器（Filter）框架實現。（就是按順序一個一個執行（鏈表）） */ //class Car { public:virtual void makeCar() = 0;virtual void improveMakeCar() = 0;Car *setNextHandle(Car *car){m_car = car;return m_car;} protected:Car* m_car; //下一個處理單元 private: }; class MakeCarHead : public Car { public:virtual void makeCar(){cout << "造車頭" << endl;}virtual void improveMakeCar(){cout << "造車頭" << endl;m_car->makeCar();} protected: private:}; class MakeCarBody : public Car { public:virtual void makeCar(){cout << "造車身" << endl;}virtual void improveMakeCar(){cout << "造車身" << endl;m_car->makeCar(); } protected: private:}; class MakeCarTail : public Car { public:virtual void makeCar(){cout << "造車尾" << endl;}virtual void improveMakeCar(){cout << "造車尾" << endl;m_car->makeCar(); } protected: private:};int main() {cout << "----------問題拋出-------------- " << endl;Car *makeCarHead = new MakeCarHead;Car *makeCarBody = new MakeCarBody;Car *makeCarTail = new MakeCarTail;//業務邏輯寫死在客戶端了..makeCarHead->makeCar();makeCarBody->makeCar();makeCarTail->makeCar();delete makeCarTail;delete makeCarBody;delete makeCarHead;cout << "\n----------改進后（即責任鏈模式）-------------- " << endl;makeCarHead = new MakeCarHead;makeCarBody = new MakeCarBody;makeCarTail = new MakeCarTail;//任務的處理關系makeCarBody->setNextHandle(makeCarHead);makeCarHead->setNextHandle(makeCarTail);makeCarTail->setNextHandle(makeCarBody);makeCarBody->makeCar();makeCarHead->makeCar();makeCarTail->makeCar();delete makeCarTail;delete makeCarBody;delete makeCarHead;system("pause");return 0; }

4. 策略模式

#include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std;class Policy { public:virtual void crypt() = 0; protected: private: };class AES : public Policy { public:virtual void crypt(){cout << "AES加密算法" << endl;} protected: private: };class Context { public:void setPolicy(Policy* policy){this->policy = policy;this->policy->crypt();} protected: private:Policy* policy; };class DES : public Policy { public:virtual void crypt(){cout << "DES 加密算法" << endl;} protected: private: };int main() { DES *des = new DES;des->crypt();delete des;Policy *policy = NULL;policy = new AES;Context *context = new Context;context->setPolicy(policy);delete policy;delete context;system("pause");return 0; }

5. 中介者模式

#include <stdlib.h> #include <stdio.h> #include <iostream> #include <string> using namespace std; // /*適用于：用一個中介對象，封裝一些列對象（同事）的交換，中介者是各個對象不需要顯示的相互作用，從而實現了耦合松散，而且可以獨立的改變他們之間的交換。模式優點1，將系統按功能分割成更小的對象，符合類的最小設計原則2，對關聯對象的集中控制3，減小類的耦合程度，明確類之間的相互關系：當類之間的關系過于復雜時，其中任何一個類的修改都會影響到其他類，不符合類的設計的開閉原則，而Mediator模式將原來相互依存的多對多的類之間的關系簡化為Mediator控制類與其他關聯類的一對多的關系，當其中一個類修改時，可以對其他關聯類不產生影響（即使有修改，也集中在Mediator控制類）。4，有利于提高類的重用性 */ //class Person { public:Person(string name, int sex, int condition):m_name(name), m_sex(sex), m_condition(condition){}string getName(){return m_name;}int getSex(){return m_sex;}int getCondi(){return m_condition;}virtual void getParter(Person *p) = 0; protected:string m_name; //名字int m_sex;// 性別int m_condition; //條件 private:};class Man : public Person { public:Man(string name, int sex, int condition):Person(name, sex, condition){}virtual void getParter(Person *p){if (this->m_sex == p->getSex()){cout << "我喜歡女人" << endl;}if (this->getCondi() == p->getCondi()){cout << this->getName() << " 和 " << p->getName() << "絕配 " << endl;}else{cout << this->getName() << " 和 " << p->getName() << "不配 " << endl;}}protected: private: };class Woman : public Person { public:Woman(string name, int sex, int condition):Person(name,sex,condition){}virtual void getParter(Person *p){if (this->m_sex == p->getSex()){cout << "我喜歡男人" << endl;}if (this->getCondi() == p->getCondi()){cout << this->getName() << " 和 " << p->getName() << "絕配 " << endl;}else{cout << this->getName() << " 和 " << p->getName() << "不配 " << endl;}}protected: private: };// /*中介者模式 */ //class Mediator; //前向聲明 class PersonM { public:PersonM(string name, int sex, int condi, Mediator *m){m_name = name;m_sex = sex;m_condi = condi;mediator = m;}string getName(){return m_name;}int getSex(){return m_sex;}int getCondi(){return m_condi;}virtual void getParter(PersonM *p) = 0;protected:string m_name;int m_sex;int m_condi;Mediator *mediator; };class Mediator { public:void setMan(PersonM *man){pMan = man;}void setWoman(PersonM *woman){pWoman = woman;}public:virtual void getParter(){if (pWoman->getSex() == pMan->getSex()){cout << "同性相斥 " << endl;}if (pWoman->getCondi() == pMan->getCondi()){cout << pWoman->getName() << " 和 " << pMan->getName() << "絕配 " << endl;}else{cout << pWoman->getName() << " 和 " << pMan->getName() << "不配 " << endl;}} private: private:PersonM *pMan;//list<Person *> m_list;PersonM *pWoman; // };class WomanM : public PersonM { public:WomanM(string name, int sex, int condi, Mediator *m) : PersonM(name, sex, condi, m){}virtual void getParter(PersonM *p){mediator->setMan(p);mediator->setWoman(this);mediator->getParter(); //找對象 } };class ManM : public PersonM { public:ManM(string name, int sex, int condi, Mediator *m) : PersonM(name, sex, condi, m){}virtual void getParter(PersonM *p){mediator->setMan(this);mediator->setWoman(p);mediator->getParter(); //找對象 } };int main() {Person *xiaofang = new Woman("小芳", 2, 5);Person *zhangsan = new Man("張三", 1, 4);Person *lisi = new Man("李四", 1, 5);xiaofang->getParter(zhangsan);xiaofang->getParter(lisi);delete lisi; lisi = NULL;delete zhangsan; zhangsan = NULL;delete xiaofang; xiaofang = NULL;cout << "\n----------------------中介者模式------------------------" << endl;Mediator *m = new Mediator;PersonM *xiaofangM = new WomanM("小芳", 2, 5, m);PersonM *zhangsanM = new ManM("張三", 1, 4, m);PersonM *lisiM = new ManM("李四", 1, 5, m);xiaofangM->getParter(zhangsanM);xiaofangM->getParter(lisiM);system("pause");return 0; }

6. 觀察者模式

#include <stdlib.h> #include <stdio.h> #include <iostream> #include <string> #include <list> using namespace std; // /*觀察者模式(就是相互注入到對方的類中，成為對方的成員。然后通過成員調用對方的成員)Observer模式是行為模式之一，它的作用是當一個對象的狀態發生變化時，能夠自動通知其他關聯對象，自動刷新對象狀態。Observer模式提供給關聯對象一種同步通信的手段，使某個對象與依賴它的其他對象之間保持狀態同步。秘書通知觀察者 */ //class Secretary; //前向聲明class PlayserObserver //觀察者 { public:PlayserObserver(Secretary* secretarty){this->m_secretary = secretarty;}void update(string action){cout << "action:" << action << endl;cout << "老板來了,注意隱蔽" << endl;}void update2(string action){cout << "action:" << action << endl;cout << "老板走了,歡呼吧" << endl;} protected: private:Secretary* m_secretary; };class Secretary { public:Secretary(){m_list.clear();}void Notify(string info){//給所有的觀察者發送情報for (list<PlayserObserver *>::iterator it = m_list.begin(); it != m_list.end(); it++){(*it)->update(info); //}}void setPlayserObserver(PlayserObserver *o){m_list.push_back(o);}protected: private:list<PlayserObserver *> m_list; };int main() {Secretary *secretary = NULL;PlayserObserver *po1 = NULL;PlayserObserver *po2 = NULL;secretary = new Secretary;po1 = new PlayserObserver(secretary);po2 = new PlayserObserver(secretary);secretary->setPlayserObserver(po1);secretary->setPlayserObserver(po2);secretary->Notify("老板come back");secretary->Notify("老板has gone");delete secretary;delete po1;delete po2;system("pause");return 0; }

7. 備忘錄模式

#include <stdlib.h> #include <stdio.h> #include <iostream> #include <string> using namespace std;// /*Memento模式也叫備忘錄模式，是行為模式之一，它的作用是保存對象的內部狀態，并在需要的時候（undo/rollback）恢復對象以前的狀態。(注意當有指針時發生深拷貝、淺拷貝的問題)其實就是用“一個類的對象保存另一個類的對象的數據” */ ////Caretaker 管理者 // MememTo 備忘錄class MememTo { public:MememTo(string name, int age){m_name = name;m_age = age;}string getName(){ return m_name; }int getAge(){ return m_age; }void setName(string name){ this->m_name = name; }void setAge(int age){ this->m_age = age; } protected: private:string m_name;int m_age; };class Person { public:Person(string name, int age){ m_name = name; m_age = age; }string getName(){ return m_name; }int getAge(){ return m_age; }void setName(string name){ this->m_name = name; }void setAge(int age){ this->m_age = age; }//保存MememTo* createMememTo(){ return new MememTo(m_name, m_age); }//還原 void setMememTo(MememTo* memto){this->m_age = memto->getAge();this->m_name = memto->getName();} public:void printT(){cout << "m_name:" << m_name << " m_age:" << m_age << endl;} private:string m_name;int m_age; };class Caretaker { public:Caretaker(MememTo *memto){this->memto = memto;}MememTo *getMememTo(){return memto;}void setMememTo(MememTo *memto){this->memto = memto;} protected: private:MememTo *memto; };int main() {MememTo *memto = NULL;Person *p = new Person("張三", 32);p->printT();//創建 Person對象的一個狀態printf("---------\n");memto = p->createMememTo(); //保存p的數據成員的值到 memto 中p->setAge(42);p->printT();printf("還原舊的狀態\n");p->setMememTo(memto); //從 memto中還原p原來的數據p->printT();delete memto;delete p;//MememTo *memto = NULL;Caretaker *caretaker = NULL;p = new Person("張三", 32);p->printT();//創建 Person對象的一個狀態printf("---------\n");caretaker = new Caretaker(p->createMememTo());p->setAge(42);p->printT();printf("還原舊的狀態\n");p->setMememTo(caretaker->getMememTo());p->printT();delete caretaker;delete p;system("pause");return 0; }

8. 訪問者模式

#include <stdlib.h> #include <stdio.h> #include <string> #include <iostream> #include <list> using namespace std;// /*Visitor模式也叫訪問者模式，是行為模式之一，它分離對象的數據和行為，使用Visitor模式，可以不修改已有類的情況下，增加新的操作角色和職責。抽象訪問者（Visitor）角色：聲明了一個或者多個訪問操作，形成所有的具體元素角色必須實現的接口。具體訪問者（ConcreteVisitor）角色：實現抽象訪問者角色所聲明的接口，也就是抽象訪問者所聲明的各個訪問操作。抽象節點（Element）角色：聲明一個接受操作，接受一個訪問者對象作為一個參量。具體節點（ConcreteElement）角色：實現了抽象元素所規定的接受操作。結構對象（ObiectStructure）角色：有如下的一些責任，可以遍歷結構中的所有元素；如果需要，提供一個高層次的接口讓訪問者對象可以訪問每一個元素；如果需要，可以設計成一個復合對象或者一個聚集，如列（List）或集合（Set）。適用于：兩批人事物；隨意的增加操作。相互解耦合。(多對多的操作)*/ //// Visitor ParkElement //訪問者訪問公園（多對多的關系） //不同類型的訪問者<-------->公園中不同的部分(園中園)class ParkElement; class Visitor { public:virtual void visit(ParkElement *parkelement) = 0; };class ParkElement { public:virtual void accept(Visitor *visit) = 0; }; class ParkA : public ParkElement //園中園A { public:virtual void accept(Visitor *v){v->visit(this); //公園接受訪問者訪問讓訪問者做操作} }; class ParkB : public ParkElement //園中園B { public:virtual void accept(Visitor *v){v->visit(this); //公園接受訪問者訪問讓訪問者做操作} }; //整個公園 class Park : public ParkElement //整個公園 { public:Park(){m_list.clear();}void setParkElement(ParkElement *pe){m_list.push_back(pe); //添加公園的各個部分}public:virtual void accept(Visitor *v){//v->visit(this); //公園接受訪問者訪問讓訪問者做操作for (list<ParkElement *>::iterator it = m_list.begin(); it != m_list.end(); it++){(*it)->accept(v); //公園A 公園B 接受管理者v訪問}}private:list<ParkElement *> m_list; //公園的每一部分 //應該讓公園的每一個部分都讓管理者訪問 };class VisitorA : public Visitor //訪問者A { public:virtual void visit(ParkElement *parkelement){cout << "訪問者 A 訪問園中園A " << endl; //parkelement->getName();} };class VisitorB : public Visitor //訪問者B { public:virtual void visit(ParkElement *parkelement){cout << "訪問者 B 訪問園中園B " << endl; //parkelement->getName();} };class ManagerVisitor : public Visitor { public:virtual void visit(ParkElement *parkelement){cout << "管理者訪問公園的各個部分 " << endl; //parkelement->getName();} };int main() {Visitor *vA = new VisitorA;Visitor *vB = new VisitorB;ParkA *parkA = new ParkA;ParkB *parkB = new ParkB;//parkA->accept(vA);parkB->accept(vB);delete vA;delete vB;delete parkA;delete parkB;cout << "-------------------------------" << endl;Visitor *vManager = new ManagerVisitor;Park *park = new Park;ParkElement *parkAA = new ParkA;ParkElement *parkBB = new ParkB;park->setParkElement(parkAA); //添加園中園Apark->setParkElement(parkBB); //添加園中園B//整個公園接受管理者訪問park->accept(vManager); //因為有 A、B公園，所以A、B個輸出一次delete parkAA;delete parkBB;delete park;delete vManager;system("pause");return 0; }

9. 狀態模式

#include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std; // /* 狀態模式適用于：對象的行為，依賴于它所處的當前狀態。行為隨狀態改變而改變的場景。 */ //class Worker; //前向聲明class State { public:virtual void doSomeThing(Worker *w) = 0; }; class State1 : public State { public:void doSomeThing(Worker *w); };class State2 : public State { public:void doSomeThing(Worker *w); };class Worker { public:Worker(){m_currstate = new State1;}int getHour(){return m_hour;}void setHour(int hour) //改變狀態 7 {m_hour = hour;}State* getCurrentState(){return m_currstate;}void setCurrentState(State* state) //參數是父類的指針{m_currstate = state;}void doSomeThing() //處于不同的狀態做不同的事情{m_currstate->doSomeThing(this);} private:int m_hour;State *m_currstate; //對象的當前狀態 };void State1::doSomeThing(Worker *w) {if (w->getHour() == 7 || w->getHour() == 8){cout << "吃早飯" << endl;}else{//-----------------------重點---------------------//狀態1 不滿足時轉向狀態2delete w->getCurrentState(); //狀態1 不滿足要轉到狀態2w->setCurrentState(new State2);w->getCurrentState()->doSomeThing(w); //} }void State2::doSomeThing(Worker *w) {if (w->getHour() == 9 || w->getHour() == 10){cout << "工作" << endl;}else{//-----------------------重點---------------------//狀態1 不滿足時轉向狀態2delete w->getCurrentState(); //狀態2 不滿足要轉到狀態3 后者恢復到初始化狀態w->setCurrentState(new State1); //恢復到當初狀態cout << "當前時間點：" << w->getHour() << "未知狀態" << endl;} }int main() {Worker *w1 = new Worker;w1->setHour(7);w1->doSomeThing();w1->setHour(9);w1->doSomeThing();delete w1; system("pause");return 0; }

10. 解釋器模式

#include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std; // /*Context解釋器上下文環境類。用來存儲解釋器的上下文環境，比如需要解釋的文法等。 AbstractExpression解釋器抽象類。ConcreteExpression解釋器具體實現類。 */ // // Context // Expression // PlusExpression 加法 // MinusExpression 減法class Context { public:Context(int num){ this->m_num = num;}int getNum(){ return m_num;}int getRes(){ return m_res;}void setNum(int num){ this->m_num = num;}void setRes(int res){ this->m_res = res;} private:int m_num;int m_res; };class Expression { public:virtual void interpreter(Context *context) = 0; private:Context *m_context; };//加法 class PlusExpression : public Expression { public:PlusExpression(){this->context = NULL;}virtual void interpreter(Context *context){int num = context->getNum();num++;context->setNum(num);context->setRes(num);} private:Context *context; };// 減法 class MinusExpression : public Expression { public:MinusExpression(){this->context = NULL;}virtual void interpreter(Context *context){int num = context->getNum();num--;context->setNum(num);context->setRes(num);} private:Context *context; };int main() {Expression *expression = NULL;Context *context = NULL;Expression *expression2 = NULL;context = new Context(10);cout << context->getNum() << endl;expression = new PlusExpression;expression->interpreter(context);cout << context->getRes() << endl;//expression2 = new MinusExpression;expression2->interpreter(context);cout << context->getRes() << endl;system("pause");return 0; }

11. 迭代器模式

#include <iostream> using namespace std;// MyIterator Aggregate ContreteIterator ConcreteAggregate // a b c d // ▲typedef int Object; #define SIZE 5 class MyIterator { public:virtual void First() = 0;virtual void Next() = 0;virtual bool IsDone() = 0;virtual Object CurrentItem() = 0; };class Aggregate { public:virtual MyIterator *CreateIterator() = 0;virtual Object getItem(int index) = 0;virtual int getSize() = 0; };class ContreteIterator : public MyIterator { public:ContreteIterator(Aggregate *ag){_ag = ag;_current_index = 0;}virtual void First(){_current_index = 0; //讓當前游標回到位置0}virtual void Next(){if (_current_index < _ag->getSize()){_current_index++;}}virtual bool IsDone(){return (_current_index == _ag->getSize());}virtual Object CurrentItem(){return _ag->getItem(_current_index);} protected: private:int _current_index;Aggregate *_ag; };class ConcreteAggregate : public Aggregate { public:ConcreteAggregate(){for (int i = 0; i < SIZE; i++){object[i] = i + 100;}}virtual MyIterator *CreateIterator(){return new ContreteIterator(this); //讓迭代器持有一個集合的引用 }virtual Object getItem(int index){return object[index];}virtual int getSize(){return SIZE;} private:Object object[SIZE]; };void main() {Aggregate * ag = new ConcreteAggregate;MyIterator *it = ag->CreateIterator();for (; !(it->IsDone()); it->Next()){cout << it->CurrentItem() << " ";}delete it;delete ag;system("pause");return; }

總結

以上是生活随笔為你收集整理的设计模式3—行为型模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

模式

上一篇： MediaWiki初探：安装及使用入门
下一篇： Python 的 requests 库的