前序

相信玩游戏每个人都会，今天就来讲讲关于游戏进度的保存机制，也就是备忘录模式。

备忘录模式

在不破坏封装性的前提下，捕获一个对象的内部状态，兵在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。

实现方式(UML类图)

实现代码

#include <stdio.h>

// 角色状态存信息

class RoleStateMemento

{

public:

         int vit;

         int atk;

         int def;

         int level;

         int pass;

         RoleStateMemento(int _vit, int _atk, int _def, int _level, int _pass) : vit(_vit), atk(_atk), def(_def), level(_level), pass(_pass){}

};

// 游戏角色

class GameRole : public RoleStateMemento

{

public:

         GameRole() : RoleStateMemento(100, 100, 100, 1, 1) {}

         RoleStateMemento* SaveState()

         {

                   return new RoleStateMemento(vit, atk, def, level, pass);

         }

         void RecoveryState(RoleStateMemento* pMemento)

         {

                   vit = pMemento->vit;

                   atk = pMemento->atk;

                   def = pMemento->def;

                   level = pMemento->level;

                   pass = pMemento->pass;

         }

         void Fight()

         {

                   vit -= 20; // 第一关损失了20点血

                   pass++;

                   vit -= 40; // 第二关损失了40点血

                   level++; // 升级了

                   atk++;

                   def++;

                   pass++;

                   vit = 0; // 第三关直接被Boss干掉了

         }

         void StateDisplay()

         {

                   printf("当前血量: %d\n", vit);

                   printf("当前攻击力: %d\n", atk);

                   printf("当前防御力: %d\n", def);

                   printf("当前等级: %d\n", level);

                   printf("当前关卡: %d\n\n", pass);

         }

};

// 角色状态管理者

class RoleStateCaretaker

{

public:

         RoleStateMemento* pMemento;

};

int main()

{

         // 大战Boss前

         GameRole* lixiaoyao = new GameRole();

         // 保存进度

         RoleStateCaretaker* stateAdmin = new RoleStateCaretaker();

         stateAdmin->pMemento = lixiaoyao->SaveState();

         // 大战Boss时，直接被干掉了

         lixiaoyao->Fight();

         lixiaoyao->StateDisplay();

         // 恢复之前的进度

         if(lixiaoyao->vit == 0)

         {

                   lixiaoyao->RecoveryState(stateAdmin->pMemento);

                   lixiaoyao->StateDisplay();

         }

         delete stateAdmin->pMemento;

         delete stateAdmin;

         delete lixiaoyao;

         return 0;

}

运行结果

所有文件打包下载

前序

姚明，大家都认识吧。在他刚去NBA的时候，什么都听不懂，必须在旁边配个翻译，否则就无法听懂教练在说什么。这也正符合了设计模式中的一种模式：适配器模式。

适配器模式

将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

实现方式(UML类图)

实现代码

#include <stdio.h>

// 球员

class Player

{

public:

       Player(char* _name) : name(_name){}

       virtual void Attack()=0;

       virtual void Defense()=0;

       char* name;

};

// 前锋

class Forwards : public Player

{

public:

       Forwards(char* name) : Player(name){}

       virtual void Attack()

       {

              printf("前锋 %s 进攻\n", name);

       }

       virtual void Defense()

       {

              printf("前锋 %s 防守\n", name);

       }

};

// 中锋

class Center : public Player

{

public:

       Center(char* name) : Player(name){}

       virtual void Attack()

       {

              printf("中锋 %s 进攻\n", name);

       }

       virtual void Defense()

       {

              printf("中锋 %s 防守\n", name);

       }

};

// 后卫

class Guards : public Player

{

public:

       Guards(char* name) : Player(name){}

       virtual void Attack()

       {

              printf("后卫 %s 进攻\n", name);

       }

       virtual void Defense()

       {

              printf("后卫 %s 防守\n", name);

       }

};

// 外籍中锋

class ForeignCenter

{

public:

       void Attack()

       {

              printf("外籍中锋 %s 进攻\n", name);

       }

       void Defense()

       {

              printf("外籍中锋 %s 防守\n", name);

       }

       char* name;

};

// 翻译者

class Translator : public Player

{

public:

       Translator(char* name) : Player(name)

       {

              wjzf.name = name;

       }

       virtual void Attack()

       {

              wjzf.Attack();

       }

       virtual void Defense()

       {

              wjzf.Defense();

       }

protected:

       ForeignCenter wjzf;

};

int main()

{

       Player* b = new Forwards("巴蒂尔");

       b->Attack();

       Player* m = new Guards("麦克格雷迪");

       m->Attack();

       Player* ym = new Translator("姚明");

       ym->Attack();

       ym->Defense();

       delete b;

       delete m;

       delete ym;

       return 0;

}

运行结果

所有文件打包下载

前序

小菜对大鸟说：“今天白天真的笑死人了，我们一同时在上班期间看股票行情，被老板当场看到，老板很生气，后果很严重呀。”

“最近股市这么火，也应该可以理解的，你们老板说不定也炒股票。”

“其实最近项目计划排的紧，是比较忙的。而最近的故事又特别火，所以很多人都在偷偷地通过网页看行情。老板市场会出门办事，于是打劫就可以轻松一些，看看行情，几个人聊聊买卖股票的心得什么的，但是一不小心，老板就会回来，让老板看到工作当中做这些总是不太好，你猜他们想到怎么办？”

“只能小心点，那能怎么办？”

“我们公司前台秘书是一个小美眉，她的名字叫童子喆，因为平时同事们买个饮料或零食什么的，都拿一份孝敬于她，所以关系比较好，现在他们就请小子喆帮忙，如果老板出门后回来，就一定要打个电话进来，大家也好马上各就各位，这样就不会被老板发现问题了。”

“你说的这件事的情形，是一个典型的观察者模式。”大鸟说，“你不妨把期间发生的事写成程序看看。”

观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

实现方式(UML类图)

实现代码

#include <stdio.h>

#include <list>

using namespace std;

class Observer;

// 通知者接口

class Subject

{

public:

       virtual void Attach(Observer* observer)=0;

       virtual void Detach(Observer* observer)=0;

       virtual void Notify()=0;

       virtual char*& SubjectState()=0;

};

// 抽象观察者

class Observer

{

public:

       Observer(char* _name,Subject* _sub) : name(_name),sub(_sub){}

       virtual void Update()=0;

protected:

       char* name;

       Subject* sub;

};

class Boss : public Subject

{

public:

       // 增加

       virtual void Attach(Observer* observer)

       {

              observers.push_back(observer);

       }

       // 减少

       virtual void Detach(Observer* observer)

       {

              observers.remove(observer);

       }

       // 通知

       virtual void Notify()

       {

              list<Observer*>::iterator iter;

              for(iter=observers.begin();iter!=observers.end();iter++) (*iter)->Update();

       }

       // 老板状态

       virtual char*& SubjectState()

       {

              return action;

       }

protected:

       list<Observer*> observers;

       char* action;

};

class Secretary : public Subject

{

public:

       // 增加

       virtual void Attach(Observer* observer)

       {

              observers.push_back(observer);

       }

       // 减少

       virtual void Detach(Observer* observer)

       {

              observers.remove(observer);

       }

       // 通知

       virtual void Notify()

       {

              list<Observer*>::iterator iter;

              for(iter=observers.begin();iter!=observers.end();iter++) (*iter)->Update();

       }

       // 前台秘书状态

       virtual char*& SubjectState()

       {

              return action;

       }

protected:

       list<Observer*> observers;

       char* action;

};

// 看股票的同事

class StockObserver : public Observer

{

public:

       StockObserver(char* name,Subject* sub) : Observer(name,sub){}

       virtual void Update()

       {

              printf("%s %s 关闭股票行情，继续工作！",sub->SubjectState(),name);

       }

};

// 看NBA的同事

class NBAObserver : public Observer

{

public:

       NBAObserver(char* name,Subject* sub) : Observer(name,sub){}

       virtual void Update()

       {

              printf("%s %s 关闭NBA直播，继续工作！",sub->SubjectState(),name);

       }

};

int main()

{

       Boss* huhansan = new Boss();

       // 看股票的同事

       StockObserver* tongshi1 = new StockObserver("魏关姹",huhansan);

       // 看NBA的同事

       NBAObserver* tongshi2 = new NBAObserver("易管查",huhansan);

       huhansan->Attach(tongshi1);

       huhansan->Attach(tongshi2);

       huhansan->Detach(tongshi1);

       // 老板回来

       huhansan->SubjectState() = "我胡汉三回来了！";

       huhansan->Notify();

       delete huhansan;

       delete tongshi1;

       delete tongshi2;

       return 0;

}

运行结果

由于魏关姹没有被老板通知到，应此被老板逮了个正着，那是相当的杯具啊！

所有文件打包下载

前序

小菜和大鸟两人出去吃夜宵，大鸟要了份炒饭，小菜要了份炒面。炒完后大鸟看到炒面感觉不错，于是也叫了一份。大鸟尝后感觉淡而无味，于是便问小菜：“为什么你的炒面好吃，而我再要的炒面却没有放盐？这好吃不好吃是由谁决定的？”小菜答道：“当然是烧菜的人，他感觉好，就是一盘好面，要是心情不好，或者粗心大意，就是一盘垃圾。”“：）好，那再想想，老麦老肯他们的产品，味道是由什么决定的？”“我知道，那是由他们的工作流程决定的，由于他们制定了非常规范的工作流程，原料放多少，加热几分钟，都有严格规定，估计放多少盐都是用克来计量的。而这个工作流程是在所有的门店都必须要遵照执行的，所以我们吃到的东西不管在哪在什么时候味道都一样。这里我们要吃的食物都依赖工作流程。”

于是大鸟出题让小菜实现一个画小人的程序。

建造小人第一版

#include <stdio.h>

class Graphics

{

public:

       void DrawEllipse(int x1,int y1,int x2,int y2)

       {

              printf("DrawEllipse %d,%d,%d,%d\n",x1,y1,x2,y2);

       }

       void DrawRectangle(int x1,int y1,int x2,int y2)

       {

              printf("DrawRectangle %d,%d,%d,%d\n",x1,y1,x2,y2);

       }

       void DrawLine(int x1,int y1,int x2,int y2)

       {

              printf("DrawLine %d,%d,%d,%d\n",x1,y1,x2,y2);

       }

};

class PersonThinBuilder

{

public:

       PersonThinBuilder(Graphics _g) : g(_g){}

       void Build()

       {

              g.DrawEllipse(50,20,30,30);

              g.DrawRectangle(60,50,10,50);

              g.DrawLine(60,50,40,100);

              g.DrawLine(70,50,90,100);

              g.DrawLine(60,100,45,150);

              g.DrawLine(70,100,85,150);

       }

protected:

       Graphics g;

};

class PersonFatBuilder

{

public:

       PersonFatBuilder(Graphics _g) : g(_g){}

       void Build()

       {

              g.DrawEllipse(50,20,30,30);

              g.DrawEllipse(60,50,10,50);

              g.DrawLine(60,50,40,100);

              g.DrawLine(70,50,90,100);

              g.DrawLine(60,100,45,150);

              g.DrawLine(70,100,85,150);

       }

protected:

       Graphics g;

};

int main()

{

       Graphics gThin,gFat;

       PersonThinBuilder* ptb = new PersonThinBuilder(gThin);

       ptb->Build();

       PersonFatBuilder* pfb = new PersonFatBuilder(gFat);

       pfb->Build();

       delete ptb;

       delete pfb;

       return 0;

}

“炒面忘记放盐的问题依然没有解决。比如我们现在需要你加一个高个的小人，你会不会因为编程不注意，又让他缺胳膊少腿呢？”

“是呀，最好的办法是规定，凡是建造小人，都必须要有头和身体，以及两收两脚。”

建造者模式

将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

实现方式(UML类图)

实现代码

#include <stdio.h>

class Graphics

{

public:

       void DrawEllipse(int x1,int y1,int x2,int y2)

       {

              printf("DrawEllipse %d,%d,%d,%d\n",x1,y1,x2,y2);

       }

       void DrawRectangle(int x1,int y1,int x2,int y2)

       {

              printf("DrawRectangle %d,%d,%d,%d\n",x1,y1,x2,y2);

       }

       void DrawLine(int x1,int y1,int x2,int y2)

       {

              printf("DrawLine %d,%d,%d,%d\n",x1,y1,x2,y2);

       }

};

class PersonBuilder

{

public:

       PersonBuilder(Graphics _g) : g(_g){}

       virtual void BuildHead()=0;

       virtual void BuildBody()=0;

       virtual void BuildArmLeft()=0;

       virtual void BuildArmRight()=0;

       virtual void BuildLegLeft()=0;

       virtual void BuildLegRight()=0;

protected:

       Graphics g;

};

class PersonThinBuilder : public PersonBuilder

{

public:

       PersonThinBuilder(Graphics g) : PersonBuilder(g){}

       virtual void BuildHead()

       {

              g.DrawEllipse(50,20,30,30);

       }

       virtual void BuildBody()

       {

              g.DrawRectangle(60,50,10,50);

       }

       virtual void BuildArmLeft()

       {

              g.DrawLine(60,50,40,100);

       }

       virtual void BuildArmRight()

       {

              g.DrawLine(70,50,90,100);

       }

       virtual void BuildLegLeft()

       {

              g.DrawLine(60,100,45,150);

       }

       virtual void BuildLegRight()

       {

              g.DrawLine(70,100,85,150);

       }

};

class PersonFatBuilder : public PersonBuilder

{

public:

       PersonFatBuilder(Graphics g) : PersonBuilder(g){}

       virtual void BuildHead()

       {

              g.DrawEllipse(50,20,30,30);

       }

       virtual void BuildBody()

       {

              g.DrawEllipse(60,50,10,50);

       }

       virtual void BuildArmLeft()

       {

              g.DrawLine(60,50,40,100);

       }

       virtual void BuildArmRight()

       {

              g.DrawLine(70,50,90,100);

       }

       virtual void BuildLegLeft()

       {

              g.DrawLine(60,100,45,150);

       }

       virtual void BuildLegRight()

       {

              g.DrawLine(70,100,85,150);

       }

};

class PersonDirector

{

public:

       PersonDirector(PersonBuilder* _pb) : pb(_pb){}

       void CreatePerson()

       {

              pb->BuildHead();

              pb->BuildBody();

              pb->BuildArmLeft();

              pb->BuildArmRight();

              pb->BuildLegLeft();

              pb->BuildLegRight();

       }

protected:

       PersonBuilder* pb;

};

int main()

{

       Graphics gThin,gFat;

       PersonThinBuilder* ptb = new PersonThinBuilder(gThin);

       PersonDirector* pdThin = new PersonDirector(ptb);

       pdThin->CreatePerson();

       PersonFatBuilder* pfb = new PersonFatBuilder(gFat);

       PersonDirector* pdFat = new PersonDirector(pfb);

       pdFat->CreatePerson();

       delete ptb;

       delete pdThin;

       delete pfb;

       delete pdFat;

       return 0;

}

运行结果

所有文件打包下载

前序

相信大家已经对上次小菜投递简历的过程已经非常了解了，这回小菜收到了XX公司的面试通知并去完成了面试。回来时大鸟问小菜感觉如何？小菜回答到：“书到用时方恨少呀，英语太烂，没办法。”然后两人讨论到以前微软的MCSE和MCSD认证考试，在刚开始时有很多教育机构弄到了题库，并承诺保证通过，不通过不收费。于是小菜的一位同学并不是计算机专业的，靠着背题库通过了这个世界最大软件公司的开发技术认证。

最后大鸟说到他小时候因为抄错题而没考好，回家父母说他不认真学习。其实问题并不在这里，如果使用标准化的考试卷也就不会产生抄错题的苦恼。

于是大鸟让小菜写了一份抄题的代码。

小菜的第一份作业

#include <stdio.h>

// 学生甲抄的试卷

class TestPaperA

{

public:

       void TestQuestion1()

       {

              printf("杨过得到，后来给了郭靖，炼成倚天剑、屠龙刀的玄铁可能是【】a.球磨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维\n");

              printf("答案: b\n");

       }

       void TestQuestion2()

       {

              printf("杨过、程英、陆无双铲除了情花，造成【】a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化\n");

              printf("答案: a\n");

       }

       void TestQuestion3()

       {

              printf("蓝凤凰致使华山师徒、桃谷六神呕吐不止，如果你是大夫，会给他们开什么药【】a.阿司匹林 b.牛黄解毒片 c.氟哌酸 d.让他们喝大量的升牛奶 e.以上全不对\n");

              printf("答案: c\n");

       }

};

// 学生乙抄的试卷

class TestPaperB

{

public:

       void TestQuestion1()

       {

              printf("杨过得到，后来给了郭靖，炼成倚天剑、屠龙刀的玄铁可能是【】a.球磨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维\n");

              printf("答案: d\n");

       }

       void TestQuestion2()

       {

              printf("杨过、程英、陆无双铲除了情花，造成【】a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化\n");

              printf("答案: b\n");

       }

       void TestQuestion3()

       {

              printf("蓝凤凰致使华山师徒、桃谷六神呕吐不止，如果你是大夫，会给他们开什么药【】a.阿司匹林 b.牛黄解毒片 c.氟哌酸 d.让他们喝大量的升牛奶 e.以上全不对\n");

              printf("答案: a\n");

       }

};

int main()

{

       printf("学生甲抄的试卷:\n");

       TestPaperA studentA;

       studentA.TestQuestion1();

       studentA.TestQuestion2();

       studentA.TestQuestion3();

       printf("学生乙抄的试卷:\n");

       TestPaperB studentB;

       studentB.TestQuestion1();

       studentB.TestQuestion2();

       studentB.TestQuestion3();

       return 0;

}

写完后小菜说到：“这两份试卷非常类似，除了答案不同，没什么不一样，这样写又容易错，又难以维护。”

“说的对，如果老师突然要改题目，那两个人就都需要改代码，如果某人抄错了，那真是糟糕至极。那你说怎么办？”

“老师出一份试卷，打印多份，然后让学生填写答案就可以了。在这里应该就把尸体和答案分享，抽象出一个父类，让两个子类继承于它，公共的试题代码写到父类当中，就可以了。”

模板方法模式

模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。

实现方法(UML类图)

实现代码

#include <stdio.h>

class TestPaper

{

public:

       void TestQuestion1()

       {

              printf("杨过得到，后来给了郭靖，炼成倚天剑、屠龙刀的玄铁可能是【】a.球磨铸铁 b.马口铁 c.高速合金钢 d.碳塑纤维\n");

              printf("答案: %c\n",Answer1());

       }

       void TestQuestion2()

       {

              printf("杨过、程英、陆无双铲除了情花，造成【】a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化\n");

              printf("答案: %c\n",Answer2());

       }

       void TestQuestion3()

       {

              printf("蓝凤凰致使华山师徒、桃谷六神呕吐不止，如果你是大夫，会给他们开什么药【】a.阿司匹林 b.牛黄解毒片 c.氟哌酸 d.让他们喝大量的升牛奶 e.以上全不对\n");

              printf("答案: %c\n",Answer3());

       }

protected:

       virtual char Answer1()=0;

       virtual char Answer2()=0;

       virtual char Answer3()=0;

};

class TestPaperA : public TestPaper

{

protected:

       virtual char Answer1()

       {

              return 'b';

       }

       virtual char Answer2()

       {

              return 'c';

       }

       virtual char Answer3()

       {

              return 'a';

       }

};

class TestPaperB : public TestPaper

{

protected:

       virtual char Answer1()

       {

              return 'c';

       }

       virtual char Answer2()

       {

              return 'a';

       }

       virtual char Answer3()

       {

              return 'a';

       }

};

int main()

{

       printf("学生甲抄的试卷:\n");

       TestPaper* studentA = new TestPaperA();

       studentA->TestQuestion1();

       studentA->TestQuestion2();

       studentA->TestQuestion3();

       printf("学生乙抄的试卷:\n");

       TestPaper* studentB = new TestPaperB();

       studentB->TestQuestion1();

       studentB->TestQuestion2();

       studentB->TestQuestion3();

       delete studentA;

       delete studentB;

       return 0;

}

运行结果

前序

这回小菜准备去应聘了,大鸟看了小菜的简历后感觉他都是在瞎扯.小菜准备了很多份相同的简历.于是大鸟便让小菜同学通过编写代码来实现相同的三份简历.

不久后小菜实现了第一版的代码.

小菜的第一版代码

#include <stdio.h>

class Resume

{

public:

       Resume(char* _name) : name(_name),sex(0),age(0),timeArea(0),company(0){}

       void SetPersonalInfo(char* _sex,char* _age)

       {

              sex = _sex;

              age = _age;

       }

       void SetWorkExperience(char* _timeArea,char* _company)

       {

              timeArea = _timeArea;

              company = _company;

       }

       void Display()

       {

              printf("%s %s %s\n",name,sex,age);

              printf("工作经历:%s %s",timeArea,company);

       }

protected:

       char* name;

       char* sex;

       char* age;

       char* timeArea;

       char* company;

};

int main()

{

       Resume a("大鸟");

       a.SetPersonalInfo("男","29");

       a.SetWorkExperience("1998-2000","XX公司");

       Resume b("大鸟");

       b.SetPersonalInfo("男","29");

       b.SetWorkExperience("1998-2000","XX公司");

       Resume c("大鸟");

       c.SetPersonalInfo("男","29");

       c.SetWorkExperience("1998-2000","XX公司");

       a.Display();

       b.Display();

       c.Display();

       return 0;

}

大鸟看后说到:”三份简历需要三次初始化,这样客户端的代码很麻烦,如果要二十份那就要二十次初始化.”

小菜答到:”是的.如果写错了一个字那就要改二十次.”

于是大鸟便叫小菜用原型模式重写了一遍代码.

原型模式

通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。

实现方式(UML类图)

实现代码

#include <stdio.h>

class ICloneable

{

public:

       virtual ICloneable* Clone()=0;

};

// 工作经历

class WorkExperience : public ICloneable

{

public:

       char*& WorkDate()

       {

              return workDate;

       }

       char*& Company()

       {

              return company;

       }

       virtual WorkExperience* Clone()

       {

              WorkExperience* Result = new WorkExperience();

              Result->WorkDate() = workDate;

              Result->Company() = company;

              return Result;

       }

protected:

       char* workDate;

       char* company;

};

// 简历

class Resume : public ICloneable

{

public:

       Resume(char* _name) : name(_name),work(new WorkExperience()){}

       ~Resume()

       {

              delete work;

       }

       void SetPersonalInfo(char* _sex,char* _age)

       {

              sex = _sex;

              age = _age;

       }

       void SetWorkExperience(char* _workDate,char* _company)

       {

              work->WorkDate() = _workDate;

              work->Company() = _company;

       }

       void Display()

       {

              printf("%s %s %s\n",name,sex,age);

              printf("工作经历:%s %s\n",work->WorkDate(),work->Company());

       }

       virtual Resume* Clone()

       {

              Resume* Result = new Resume(work);

              Result->name = name;

              Result->sex = sex;

              Result->age = age;

              return Result;

       }

protected:

       Resume(WorkExperience* _work)

       {

              work = _work->Clone();

       }

       char* name;

       char* sex;

       char* age;

       WorkExperience* work;

};

int main()

{

       Resume* a = new Resume("大鸟");

       a->SetPersonalInfo("男","29");

       a->SetWorkExperience("1998-2000","XX公司");

       Resume* b = a->Clone();

       b->SetWorkExperience("1998-2006","YY企业");

       Resume* c = a->Clone();

       c->SetPersonalInfo("男","24");

       c->SetWorkExperience("1998-2003","ZZ企业");

       a->Display();

       b->Display();

       c->Display();

       delete a;

       delete b;

       delete c;

       return 0;

}

运行结果

前序

小菜同学有个同学叫薛磊风,他做人很低调,经常去勤工俭学.但不巧的是星期天他走在路上被车撞了,并送进了医院.他在医院中对小菜和他的同学们说,他经常去帮助以为老奶奶,但是现在他被车撞伤了,没办法继续去帮助那位老奶奶了.应此他希望小菜和其他同学能够帮助他去照顾那位老奶奶,如果老奶奶问起他们的名字时不要提任何人的名字,说是学雷锋做好事就行了.

社区志愿者也可以帮助老奶奶,应此帮助老奶奶的对象就可分为(学雷锋的大学生和社区志愿者),请你用工厂方法模式来设计出帮助老奶奶这件事.

工厂方法模式

核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

实现方法(UML类图)

实现代码

#include <stdio.h>

// 雷锋

class LeiFeng

{

public:

       void Sweep()

       {

              printf("扫地\n");

       }

       void Wash()

       {

              printf("洗衣\n");

       }

       void BuyRice()

       {

              printf("买米\n");

       }

};

// 学雷锋的大学生

class Undergraduate : public LeiFeng

{

public:

};

// 社区志愿者

class Volunterr : public LeiFeng

{

public:

};

// 雷锋工厂

class IFactory

{

public:

       virtual LeiFeng* CreateLeiFeng()=0;

};

// 学雷锋的大学生工厂

class UndergraduateFactory : public IFactory

{

public:

       virtual LeiFeng* CreateLeiFeng()

       {

              return new Undergraduate();

       }

};

// 社区志愿者工厂

class VolunterrFactory : public IFactory

{

public:

       virtual LeiFeng* CreateLeiFeng()

       {

              return new Volunterr();

       }

};

int main()

{

       IFactory* factory = new UndergraduateFactory();

       LeiFeng* student = factory->CreateLeiFeng();

       student->BuyRice();

       student->Sweep();

       student->Wash();

       delete factory;

       delete student;

       return 0;

}

运行结果

买米

扫地

洗衣

前序

卓贾易同学为了追求娇娇同学,于是要戴励同学帮他送洋娃娃,花和巧克力给娇娇同学.请你用代理模式来设计这些送东西的过程.

代理模式

代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。

实现方式(UML类图)

实现代码

#include <stdio.h>

class IGiveGift

{

public:

       virtual void GiveDolls()=0;

       virtual void GiveFlowers()=0;

       virtual void GiveChocolate()=0;

};

class SchoolGirl

{

public:

       char*& Name()

       {

              return name;

       }

protected:

       char* name;

};

class Pursuit : public IGiveGift

{

public:

       Pursuit(SchoolGirl* _mm) : mm(_mm){}

       virtual void GiveDolls()

       {

              printf("%s 送你洋娃娃\n",mm->Name());

       }

       virtual void GiveFlowers()

       {

              printf("%s 送你鲜花\n",mm->Name());

       }

       virtual void GiveChocolate()

       {

              printf("%s 送你巧克力\n",mm->Name());

       }

protected:

       SchoolGirl* mm;

};

class Proxy : public IGiveGift

{

public:

       Proxy(SchoolGirl* mm)

       {

              gg = new Pursuit(mm);

       }

       ~Proxy()

       {

              delete gg;

       }

       virtual void GiveDolls()

       {

              gg->GiveDolls();

       }

       virtual void GiveFlowers()

       {

              gg->GiveFlowers();

       }

       virtual void GiveChocolate()

       {

              gg->GiveChocolate();

       }

protected:

       Pursuit* gg;

};

int main()

{

       SchoolGirl* jiaojiao = new SchoolGirl();

       jiaojiao->Name() = "李娇娇";

       Proxy* daili = new Proxy(jiaojiao);

       daili->GiveDolls();

       daili->GiveFlowers();

       daili->GiveChocolate();

       delete jiaojiao;

       delete daili;

       return 0;

}

运行结果

前序

制作一个可以给人搭配不同的服饰的系统,比如类似QQ,网络游戏或论坛都有的Avatar系统.

装饰模式

装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

实现方式(UML类图)

实现代码

#include <stdio.h>

class Person

{

public:

       Person() : name(0){}

       Person(char* _name) : name(_name){}

       virtual void Show()

       {

              printf("装扮的%s",name);

       }

protected:

       char* name;

};

class Finery : public Person

{

public:

       Finery() : component(0){}

       void Decorate(Person* component)

       {

              this->component = component;

       }

       virtual void Show()

       {

              if(component) component->Show();

       }

protected:

       Person* component;

};

class TShirts : public Finery

{

public:

       virtual void Show()

       {

              printf("大T恤 ");

              __super::Show();

       }

};

class BigTrouser : public Finery

{

public:

       virtual void Show()

       {

              printf("跨裤 ");

              __super::Show();

       }

};

class Sneakers : public Finery

{

public:

       virtual void Show()

       {

              printf("破球鞋 ");

              __super::Show();

       }

};

class Suit : public Finery

{

public:

       virtual void Show()

       {

              printf("西装 ");

              __super::Show();

       }

};

class Tie : public Finery

{

public:

       virtual void Show()

       {

              printf("领带 ");

              __super::Show();

       }

};

class LeatherShoes : public Finery

{

public:

       virtual void Show()

       {

              printf("皮鞋 ");

              __super::Show();

       }

};

int main()

{

       Person* xc = new Person("小菜");

       printf("第一种装扮:\n");

       Sneakers* pqx = new Sneakers();

       BigTrouser* kk = new BigTrouser();

       TShirts* dtx = new TShirts();

       pqx->Decorate(xc);

       kk->Decorate(pqx);

       dtx->Decorate(kk);

       dtx->Show();

       printf("\n第二种装扮:\n");

       LeatherShoes* px = new LeatherShoes();

       Tie* ld = new Tie();

       Suit* xz = new Suit();

       px->Decorate(xc);

       ld->Decorate(px);

       xz->Decorate(ld);

       xz->Show();

       delete xc;

       delete pqx;

       delete kk;

       delete dtx;

       delete px;

       delete ld;

       delete xz;

       return 0;

}

运行结果

策略模式

前序

请实现一个商场收银软件,包含正常收费,打折收费和返利收费三种具体策略

策略模式

策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

实现方式(UML类图)

实现代码

#include <stdio.h>

class CashSuper

{

public:

       virtual double acceptCash(double money)=0;

};

class CashNormal : public CashSuper

{

public:

       virtual double acceptCash(double money)

       {

              return money;

       }

};

class CashRebate : public CashSuper

{

protected:

       double moneyRebate;

public:

       CashRebate() : moneyRebate(1){}

       CashRebate(double _moneyRebate) : moneyRebate(_moneyRebate){}

       virtual double acceptCash(double money)

       {

              return money * moneyRebate;

       }

};

class CashReturn : public CashSuper

{

protected:

       double moneyCondition;

       double moneyReturn;

public:

       CashReturn() : moneyCondition(0),moneyReturn(0){}

       CashReturn(double _moneyCondition,double _moneyReturn)

              : moneyCondition(_moneyCondition),moneyReturn(_moneyReturn)

       {}

       virtual double acceptCash(double money)

       {

              double result = money;

              if(money >= moneyCondition) result -= (int)(money / moneyCondition) * moneyReturn;

              return result;

       }

};

class CashContext

{

protected:

       CashSuper* cs;

public:

       CashContext() : cs(0){}

       ~CashContext()

       {

              if(cs) delete cs;

       }

       CashContext& operator=(CashSuper* csuper)

       {

              if(cs) delete cs;

              cs = csuper;

              return *this;

       }

       double GetResult(double money)

       {

              return cs->acceptCash(money);

       }

};

int main()

{

       double total = 0;

       int Type;

       while(1)

       {

              printf("请输入收费方式(0~2,-1退出):");

              scanf("%d",&Type);

              if(Type == -1) break;

              CashContext cc;

              switch(Type)

              {

              case 0:

                     cc = new CashNormal();

                     break;

              case 1:

                     cc = new CashReturn(300,100);

                     break;

              case 2:

                     cc = new CashRebate(0.8);

                     break;

              default:

                     cc = new CashNormal();

                     break;

              }

              double Price,Num;

              printf("请输入单价:");

              scanf("%lf",&Price);

              printf("请输入数量:");

              scanf("%lf",&Num);

              total += cc.GetResult(Price * Num);

       }

       printf("总价:%f\n",total);

       return 0;

}

运行结果

前序:

请用一种面向对象的语言来实现一个计算器控制台程序,要求输入两个数和运算符并得到结果

简单工厂模式:

从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

实现方式(UML类图):

实现代码:

#include <stdio.h>

class Operation

{

public:

       double NumberA;

       double NumberB;

       virtual double GetResult()

       {

              return 0;

       }

};

class OperationAdd : public Operation

{

public:

       virtual double GetResult()

       {

              return NumberA + NumberB;

       }

};

class OperationSub : public Operation

{

public:

       virtual double GetResult()

       {

              return NumberA - NumberB;

       }

};

class OperationMul : public Operation

{

public:

       virtual double GetResult()

       {

              return NumberA * NumberB;

       }

};

class OperationDiv : public Operation

{

public:

       virtual double GetResult()

       {

              if(NumberB == 0) return 0;

              return NumberA / NumberB;

       }

};

class OperationFactory

{

public:

       static Operation* createOperate(char operate)

       {

              Operation* oper = 0;

              switch(operate)

              {

                     case '+':

                            oper = new OperationAdd();

                            break;

                     case '-':

                            oper = new OperationSub();

                            break;

                     case '*':

                            oper = new OperationMul();

                            break;

                     case '/':

                            oper = new OperationDiv();

                            break;

              }

              return oper;

       }

};

int main()

{

       Operation* oper = OperationFactory::createOperate('+');

       oper->NumberA = 1;

       oper->NumberB = 2;

       printf("%f",oper->GetResult());

       delete oper;

       return 0;

}

运行结果:

3.0000

http://www.cppblog.com/lwch

lwch4@163.com

一、       设计模式概述

a)      简单工厂模式

b)      策略模式

c)      装饰模式

d)      代理模式

e)      工厂方法模式

f)      原型模式

g)      模板方法模式

h)      外观模式

i)      建造者模式

j)      观察者模式

k)      抽象工厂模式

l)      状态模式

m)      适配器模式

n)      备忘录模式

o)      组合模式

p)      迭代器模式

q)      单例模式

r)      桥接模式

s)      命令模式

t)      职责链模式

u)      中介者模式

v)      享元模式

w)      解释器模式

x)      访问者模式

二、       设计模式应用

 
所有代码及部分资料出自《大话设计模式》