简介

概念

设计模式是在特定环境下人们解决某类重复出现问题的一套成功 或有效的解决方案。一开始出现于建筑行业,后来被引入到计算机领域.

软件设计模式，是指在软件设计中，被反复使用的一种代码设计经验。使用设计模式的目的是为了可重用代码，提高代码的可扩展性和可维护性。

设计模式这个术语是上个世纪90年代由Erich Gamma、Richard Helm、Raplh Johnson和Jonhn Vlissides四个人总结提炼出来的，并且写了一本Design Patterns的书。这四人也被称为四人帮（GoF）。

种类

GoF 提出的设计模式有 23 个，包括：

  1. 创建型(Creational)模式： 如何创建对象；
  2. 结构型(Structural )模式： 如何实现类或对象的组合；

  3. 行为型(Behavioral)模式： 类或对象怎样交互以及怎样分配职责。

    有一个“简单工厂模式”不属于 GoF 23 种设计模式，但大部分的设计模式 书籍都会对它进行专门的介绍.
    所以,设计模式目前种类： GoF 的 23 种 + “简单工厂模式” = 24 种。
    这里只学习一部分比较常用的设计模式,看全部可以—>

    设计原则

    为什么要使用设计模式？根本原因还是软件开发要实现可维护、可扩展，就必须尽量复用代码，并且降低代码的耦合度。(高内聚,低耦合)设计模式主要是基于OOP编程提炼的，它基于以下几个原则：

  4. 单一职责原则: 类的职责单一，对外只提供一种功能，而引起类变化的 原因都应该只有一个

  5. 开闭原则:软件应该对扩展开放，而对修改关闭。这里的意思是在增加新功能的时候，能不改代码就尽量不要改，如果只增加代码就完成了新功能，那是最好的。
  6. 里氏替换原则: 任何抽象类出现的地方都可以用他的实现类进行替换， 实际就是虚拟机制，语言级别实现面向对象功能.
  7. 接口隔离原则: 不应该强迫用户的程序依赖他们不需要的接口方法。一 个接口应该只提供一种对外功能，不应该把所有操作都 封装到一个接口中去
  8. 合成复用原则: 如果使用继承，会导致父类的任何变换都可能影响到子 类的行为。如果使用对象组合，就降低了这种依赖关系。 对于继承和组合，优先使用组合
  9. 迪米特法则:一个对象应当对其他对象尽可能少的了解，从而降 低各个对象之间的耦合，提高系统的可维护性。 ```cpp //开闭原则:新增功能,尽量不修改代码,而是增加代码 class Caculator { private: double mA; string mOpt; double mB;

public: Caculator(double a, string opt, double b) : mA(a), mOpt(opt), mB(b) {} double getResult() { if (this->mOpt == “+”) { return this->mA + this->mB; } else if (this->mOpt == “-“) { return this->mA - this->mB; } //… } }; //开闭原则写法—> class AbstractCaculator { public: double mA; double mB;

public: AbstractCaculator(double a, double b) : mA(a), mB(b) {} virtual double getResult() = 0; };

class PlusCaculator : public AbstractCaculator { public: PlusCaculator(double a, double b) : AbstractCaculator(a,b){} double getResult() { return mA + mB; } }; class MinusCaculator : public AbstractCaculator { public: MinusCaculator(double a, double b) : AbstractCaculator(a,b){} double getResult() { return mA - mB; } }; //…使用这种写法,可扩展性强

  1. 其他案例:<br />迪米特原则(最少知识原则):租房客有很多出租屋可选择.租房客只需要租金..信息,不需要知道建筑材料..信息,可添加一个中介,提供给租房客需要的信息和服务.<br />合成复用原则:优先使用组合而不是继承<br />依赖倒转原则:传统高层依赖于底层,耦合性高,在中间加入抽象层.
  2. <a name="RGZVQ"></a>
  3. ## 创建型模型
  4. <a name="og80m"></a>
  5. ### 1.简单工厂模式
  6. ![简单工厂模式.png](https://cdn.nlark.com/yuque/0/2022/png/21546446/1657023914446-8a2f7684-aa35-4d0d-aaf8-b7412e61ee8a.png#clientId=u691de596-70cd-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u68e3919d&margin=%5Bobject%20Object%5D&name=%E7%AE%80%E5%8D%95%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F.png&originHeight=604&originWidth=1360&originalType=binary&ratio=1&rotation=0&showTitle=false&size=45685&status=done&style=none&taskId=u26ea860d-e533-464c-a71b-fdbadfb3b16&title=)
  7. ```cpp
  8. #include <iostream>
  9. using namespace std;
  11. class AbstractPhone
  12. {
  13. public:
  14.     virtual void show() = 0;
  15. };
  16. class HuaWei : public AbstractPhone
  17. {
  18. public:
  19.     void show()
  20.     {
  21.         cout << "我是爱国牌手机!" << endl;
  22.     }
  23. };
  24. class RedMi : public AbstractPhone
  25. {
  26. public:
  27.     void show()
  28.     {
  29.         cout << "我是红米,干翻小米!" << endl;
  30.     }
  31. };
  33. class PhoneFactory
  34. {
  35. public:
  36.     static AbstractPhone *CreateObject(string name)
  37.     {
  38.         if (name == "huawei")
  39.         {
  40.             return new HuaWei;
  41.         }
  42.         else if (name == "redmi")
  43.         {
  44.             return new RedMi;
  45.         }
  46.     }
  47. };
  49. int main(int argc, char const *argv[])
  50. {
  51.     AbstractPhone * phone = NULL;
  52.     phone = PhoneFactory::CreateObject("huawei");
  53.     phone->show();
  54.     delete phone;
  55.     phone = NULL;
  56.     return 0;
  57. }

2. 工厂方法模式

工厂方法模式.png

  1. #include <iostream>
  2. using namespace std;
  4. class AbstractPhone
  5. {
  6. public:
  7.     virtual void show() = 0;
  8. };
  9. class HuaWei : public AbstractPhone
  10. {
  11. public:
  12.     void show()
  13.     {
  14.         cout << "我是爱国牌手机!" << endl;
  15.     }
  16. };
  17. class RedMi : public AbstractPhone
  18. {
  19. public:
  20.     void show()
  21.     {
  22.         cout << "我是红米,干翻小米!" << endl;
  23.     }
  24. };
  25. class AbstractFactory
  26. {
  27. public:
  28.     virtual AbstractPhone *CreateObject() = 0;
  29. };
  30. class HuaweiFactory : public AbstractFactory
  31. {
  32. public:
  33.     AbstractPhone *CreateObject()
  34.     {
  35.         return new HuaWei;
  36.     }
  37. };
  38. class RedMiFactory : public AbstractFactory
  39. {
  40. public:
  41.     AbstractPhone *CreateObject()
  42.     {
  43.         return new RedMi;
  44.     }
  45. };
  47. int main(int argc, char const *argv[])
  48. {
  49.     AbstractPhone *phone = NULL;
  50.     AbstractFactory *factroy = new HuaweiFactory;
  51.     phone = factroy->CreateObject();
  52.     phone->show();
  53.     delete phone;
  54.     phone = NULL;
  55.     delete factroy;
  56.     factroy = NULL;
  57.     return 0;
  58. }

3.抽象工厂模式

由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统 中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一些相关 的产品组成一个“产品族，由同一个工厂来统一生产 .

  1. //在以上案例扩展,假如每个品牌的工厂都生产两类手机,高端和低端.
  2. //华为高端机,华为低端机,红米高端机,红米低端机.
  3. //再定义一种抽象工厂类,包括生产高端,生产低端的方法
  4. #include <iostream>
  5. using namespace std;
  7. class AbstractPhone
  8. {
  9. public:
  10.     virtual void show() = 0;
  11. };
  12. class HuaWeiHigh : public AbstractPhone
  13. {
  14. public:
  15.     virtual void show()
  16.     {
  17.         cout << "我是爱国牌高端手机!" << endl;
  18.     }
  19. };
  20. class HuaWeiLow : public AbstractPhone
  21. {
  22. public:
  23.     virtual void show()
  24.     {
  25.         cout << "我是爱国牌低端手机!" << endl;
  26.     }
  27. };
  28. class RedMiHigh : public AbstractPhone
  29. {
  30. public:
  31.     virtual void show()
  32.     {
  33.         cout << "我是红米高端机" << endl;
  34.     }
  35. };
  36. class RedMiLow : public AbstractPhone
  37. {
  38. public:
  39.     virtual void show()
  40.     {
  41.         cout << "我是红米低端机!" << endl;
  42.     }
  43. };
  45. class AbstractFactory
  46. {
  47. public:
  48.     virtual AbstractPhone *CreateHigh() = 0;
  49.     virtual AbstractPhone *CreateLow() = 0;
  50. };
  51. class HuaweiFactory : public AbstractFactory
  52. {  
  53. public:
  54.     AbstractPhone *CreateHigh()
  55.     {
  56.         return new HuaWeiHigh;
  57.     }
  58.     AbstractPhone *CreateLow()
  59.     {
  60.         return new HuaWeiLow;
  61.     }
  62. };
  63. class RedMiFactory : public AbstractFactory
  64. {
  65. public:
  66.     AbstractPhone *CreateHigh()
  67.     {
  68.         return new RedMiHigh;
  69.     }
  70.     AbstractPhone *CreateLow()
  71.     {
  72.         return new RedMiLow;
  73.     }
  74. };
  76. int main(int argc, char const *argv[])
  77. {
  78.     AbstractPhone *phone = NULL;
  79.     AbstractFactory *factroy = new HuaweiFactory;
  80.     phone = factroy->CreateHigh();
  81.     phone->show();
  82.     delete phone;
  83.     phone = NULL;
  84.     delete factroy;
  85.     factroy = NULL;
  86.     return 0;
  87. }

4.生成器模式

将一个复杂的对象的构建（builder）和它的表示（director）分离，使得同样的构建过程可以创建不同的表示。核心是给指导者一个生成器，但具体方式不指定。

  1. #include <iostream>
  2. #include <list>
  3. using namespace std;
  5. //产品类，由多个部件组成
  6. class Product
  7. {
  8. private:
  9.     list<string> parts;
  11. public:
  12.     // 添加产品部件
  13.     void add(string part)
  14.     {
  15.         parts.push_back(part);
  16.     }
  17.     // 列举所有的产品部件
  18.     void show()
  19.     {
  20.         cout << "---产品 创建---"<<parts.size() << endl;
  21.         for (string part : parts)
  22.         {
  23.             cout << part << endl;
  24.         }
  25.     }
  26. };
  27. //抽象类或接口
  28. class Builder
  29. {
  31. public:
  32.     Product product;
  33.     Product getProduct()
  34.     {
  35.         return product;
  36.     }
  37.     virtual void buildPartA() = 0;
  38.     virtual void buildPartB() = 0;
  39. };
  40. //指挥者类，用来指挥建造过程
  41. class Director
  42. {
  43. public:
  44.     void construct(Builder * builder)
  45.     {
  46.         builder->buildPartA();
  47.         builder->buildPartB();
  48.     }
  49. };
  50. //具体建造者类
  51. class ConcreteBuilder1 : public Builder
  52. {
  53. public:
  54.     virtual void buildPartA()
  55.     {
  56.         product.add("部件A");
  57.     }
  58.     virtual void buildPartB()
  59.     {
  60.         product.add("部件B");
  61.     }
  62. };
  63. // 具体建造者类，建造的对象时Product，通过build使Product完善
  64. class ConcreteBuilder2 : public Builder
  65. {
  66. public:
  67.     void buildPartA()
  68.     {
  69.         product.add("部件X");
  70.     }
  71.     void buildPartB()
  72.     {
  73.         product.add("部件Y");
  74.     }
  75. };
  77. //建造客户端
  78. int main(int argc, char const *argv[])
  79. {
  80.     Director director;
  81.     Builder * builder1 = new ConcreteBuilder1;
  82.     Builder * builder2 = new ConcreteBuilder2;
  84.     director.construct(builder1);
  85.     Product product1 = builder1->getProduct();
  86.     product1.show();
  87.     director.construct(builder2);
  88.     Product product2 = builder2->getProduct();
  89.     product2.show();
  90.     return 0;
  91. }

5.单例模式

通过单例模式可以保证系统中一个类只有一个实例而且该实例易 于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某 个类的对象只能存在一个，单例模式是最好的解决方案。

实现步骤:

  1. 构造方法私有,不给new
  2. 提供静态方法返回唯一的对象 ```cpp //懒汉式:线程不安全

    include

    using namespace std; class singleton { private: singleton(){}//不给new static singleton s_singleton; public: static singleton getInstance(){
    1.  if(s_singleton == NULL){//多线程时,可能同时判断为NULL
    2.      s_singleton = new singleton;
    3.  }
    4.  return s_singleton;
    }

}; singleton singleton::s_singleton = NULL; int main(int argc, char const argv[]) { singleton s1 = singleton::getInstance(); singleton s2 = singleton::getInstance();

  1. cout<<"同一对象?"<<(s1==s2?"是":"否")<<endl;
  2. return 0;

} //饿汉式

include

using namespace std; class singleton { private: singleton(){}//不给new static singleton s_singleton; public: static singleton getInstance(){ return s_singleton; }

}; singleton singleton::s_singleton = new singleton;//区别处 int main(int argc, char const argv[]) { singleton s1 = singleton::getInstance(); singleton s2 = singleton::getInstance();

  1. cout<<"同一对象?"<<(s1==s2?"是":"否")<<endl;
  2. return 0;

}

  1. <a name="Ji5Ex"></a>
  2. ## 结构型模式
  3. <a name="EkZey"></a>
  4. ### 6.代理模式
  5.  代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某 些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客 户端和目标对象之间起到中介的作用。  
  6. ```cpp
  7. #include <iostream>
  8. using namespace std;
  9. class AbstractCommonInterface
  10. {
  11. public:
  12.     virtual void run() = 0;
  13. };
  14. class System : public AbstractCommonInterface
  15. {
  16. public:
  17.     void run()
  18.     {
  19.         cout << "系统功能" << endl;
  20.     }
  21. };
  22. class systemProxy : public AbstractCommonInterface
  23. {
  24. public:
  25.     System *system;
  26.     bool isOK()
  27.     {
  28.         return true; //验证权限,这里直接给通过
  29.     }
  30.     void run()
  31.     {
  32.         if (isOK())
  33.         {
  34.             this->system = new System;
  35.             this->system->run();
  36.         }
  37.     }
  38.     ~systemProxy()
  39.     {
  40.         if (this->system != NULL)
  41.         {
  42.             delete this->system;
  43.         }
  44.     }
  45. };
  46. int main(int argc, char const *argv[])
  47. {
  48.     systemProxy sProxy;
  49.     sProxy.run();
  50.     return 0;
  51. }

7.外观模式

Facade 模式也叫外观模式，是由 GoF 提出的 23 种设计模式中的一种。 Facade 模式为一组具有类似功能的类群，比如类库，子系统等等，提供一个一 致的简单的界面。这个一致的简单的界面被称作 facade 

  1. #include <iostream>
  2. using namespace std;
  3. //电视
  4. class Television
  5. {
  6. public:
  7.     void On()
  8.     {
  9.         cout << "电视打开!" << endl;
  10.     }
  11.     void Off()
  12.     {
  13.         cout << "电视关闭!" << endl;
  14.     }
  15. };
  16. //灯
  17. class Lamp
  18. {
  19. public:
  20.     void On()
  21.     {
  22.         cout << "灯打开!" << endl;
  23.     }
  24.     void Off()
  25.     {
  26.         cout << "灯关闭!" << endl;
  27.     }
  28. };
  29. //音响
  30. class Audio
  31. {
  32. public:
  33.     void On()
  34.     {
  35.         cout << "音响打开!" << endl;
  36.     }
  37.     void Off()
  38.     {
  39.         cout << "音响关闭!" << endl;
  40.     }
  41. };
  42. //麦克风
  43. class Microphone
  44. {
  45. public:
  46.     void On()
  47.     {
  48.         cout << "麦克风打开!" << endl;
  49.     }
  50.     void Off()
  51.     {
  52.         cout << "麦克风关闭!" << endl;
  53.     }
  54. };
  55. // DVD 播放机
  56. class DVDPlayer
  57. {
  58. public:
  59.     void On()
  60.     {
  61.         cout << "DVDPlayer 打开!" << endl;
  62.     }
  63.     void Off()
  64.     {
  65.         cout << "DVDPlayer 关闭!" << endl;
  66.     }
  67. };
  68. //游戏机
  69. class GameMachine
  70. {
  71. public:
  72.     void On()
  73.     {
  74.         cout << "游戏机打开!" << endl;
  75.     }
  76.     void Off()
  77.     {
  78.         cout << "游戏界关闭!" << endl;
  79.     }
  80. };
  81. //外观抽象类
  82. class AbstractFacede
  83. {
  84. public:
  85.     virtual void On() = 0;
  86.     virtual void Off() = 0;
  87. };
  88. //游戏模式
  89. class GameMode : public AbstractFacede
  90. {
  91. public:
  92.     GameMode()
  93.     {
  94.         pTelevision = new Television;
  95.         pAudio = new Audio;
  96.         pGameMachine = new GameMachine;
  97.     }
  98.     virtual void On()
  99.     {
  100.         pTelevision->On();
  101.         pAudio->On();
  102.         pGameMachine->On();
  103.     }
  104.     virtual void Off()
  105.     {
  106.         pTelevision->Off();
  107.         pAudio->Off();
  108.         pGameMachine->Off();
  109.     }
  111. private:
  112.     Television *pTelevision;
  113.     Audio *pAudio;
  114.     GameMachine *pGameMachine;
  115. };
  116. // KTV 模式
  117. class KTVMode : public AbstractFacede
  118. {
  119. public:
  120.     KTVMode()
  121.     {
  122.         pTelevision = new Television;
  123.         pAudio = new Audio;
  124.         pDVDPlayer = new DVDPlayer;
  125.         pLamp = new Lamp;
  126.         pMicrophone = new Microphone;
  127.     }
  128.     virtual void On()
  129.     {
  130.         pTelevision->On();
  131.         pAudio->On();
  132.         pDVDPlayer->On();
  133.         pLamp->Off();
  134.         pMicrophone->On();
  135.     }
  136.     virtual void Off()
  137.     {
  138.         pTelevision->Off();
  139.         pAudio->Off();
  140.         pDVDPlayer->Off();
  141.         pLamp->On();
  142.         pMicrophone->Off();
  143.     }
  145. private:
  146.     Television *pTelevision;
  147.     Audio *pAudio;
  148.     DVDPlayer *pDVDPlayer;
  149.     Lamp *pLamp;
  150.     Microphone *pMicrophone;
  151. };
  152. //测试游戏模式和 KTV 模式
  153. void test01()
  154. {
  155.     AbstractFacede *facede = NULL;
  156.     facede = new GameMode;
  157.     facede->On(); //启动游戏模式
  158.     delete facede;
  159.     cout << "--------------------------" << endl;
  160.     facede = new KTVMode;
  161.     facede->On(); //启动 KTV 模式
  162.     delete facede;
  163. }
  164. int main()
  165. {
  166.     test01();
  167.     return EXIT_SUCCESS;
  168. }

8.适配器模式

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

  1. #include <iostream>
  2. #include <list>
  3. using namespace std;
  5. // A 需要治疗感冒
  6. class PersonA
  7. {
  8. public:
  9.     void treatGanmao()
  10.     {
  11.         cout << "A 需要治疗感冒!" << endl;
  12.     }
  13. };
  14. // B 需要治疗头疼
  15. class PersonB
  16. {
  17. public:
  18.     void treatTouteng()
  19.     {
  20.         cout << "B 需要治疗头疼!" << endl;
  21.     }
  22. };
  24. //目标接口
  25. class Target
  26. {
  27. public:
  28.     virtual void treat() = 0;
  29. };
  31. //将 PersonA 的 treatGanmao 接口适配成 treat
  32. class AdapterPersonA : public Target
  33. {
  34. public:
  35.     AdapterPersonA()
  36.     {
  37.         pPerson = new PersonA;
  38.     }
  39.     virtual void treat()
  40.     {
  41.         pPerson->treatGanmao();
  42.     }
  44. private:
  45.     PersonA *pPerson;
  46. };
  47. //将 PersonB 的 treatTouteng 接口适配成 treat
  48. class AdapterPersonB : public Target
  49. {
  50. public:
  51.     AdapterPersonB()
  52.     {
  53.         pPerson = new PersonB;
  54.     }
  55.     virtual void treat()
  56.     {
  57.         pPerson->treatTouteng();
  58.     }
  60. private:
  61.     PersonB *pPerson;
  62. };
  63. //医生
  64. class Doctor
  65. {
  66. public:
  67.     void addPatient(Target *patient)
  68.     {
  69.         m_list.push_back(patient);
  70.     }
  71.     void startTreat()
  72.     {
  73.         for (list<Target *>::iterator it = m_list.begin(); it != m_list.end(); it++)
  74.         {
  75.             (*it)->treat();
  76.         }
  77.     }
  79. private:
  80.     list<Target *> m_list;
  81. };
  82. void test01()
  83. {
  84.     //创建三个病人
  85.     Target *patient1 = new AdapterPersonA;
  86.     Target *patient2 = new AdapterPersonB;
  88.     //创建医生
  89.     Doctor *doctor = new Doctor;
  90.     doctor->addPatient(patient1);
  91.     doctor->addPatient(patient2);
  93.     //医生逐个对病人进行治疗
  94.     doctor->startTreat();
  95. }
  96. int main()
  97. {
  98.     test01();
  99.     return EXIT_SUCCESS;
  100. }

9.装饰器模式

装饰模式又叫包装模式，通过一种对客户端透明的方式来扩展对象功能，是 继承关系的一种替代。 装饰模式就是把要附加的功能分别放在单独的类中，并让这个类包含它要装 饰的对象，当需要执行时，客户端就可以有选择的、按顺序的使用装饰功能包装 对象。 

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. //抽象手机类
  5. class AbstractCellphone
  6. {
  7. public:
  8.     virtual void showPhone() = 0;
  9. };
  10. //小米手机
  11. class XiaomiCellphone : public AbstractCellphone
  12. {
  13. public:
  14.     XiaomiCellphone(string model)
  15.     {
  16.         m_name = "小米 " + model + "手机";
  17.     }
  18.     virtual void showPhone()
  19.     {
  20.         cout << m_name << endl;
  21.     }
  23. private:
  24.     string m_name;
  25. };
  26. // Apple 手机
  27. class AppleCellphone : public AbstractCellphone
  28. {
  29. public:
  30.     AppleCellphone(string model)
  31.     {
  32.         m_name = "苹果 " + model + "手机";
  33.     }
  34.     virtual void showPhone()
  35.     {
  36.         cout << m_name << endl;
  37.     }
  39. private:
  40.     string m_name;
  41. };
  42. //装饰类
  43. class Decorator : public AbstractCellphone
  44. {
  45. public:
  46.     Decorator(AbstractCellphone *cellphone)
  47.     {
  48.         pCellphone = cellphone;
  49.     }
  50.     virtual void showPhone()
  51.     {
  52.         pCellphone->showPhone();
  53.     }
  55. protected:
  56.     AbstractCellphone *pCellphone;
  57. };
  58. //给手机贴膜
  59. class CellphoneFilm : public Decorator
  60. {
  61. public:
  62.     CellphoneFilm(AbstractCellphone *cellphone) : Decorator(cellphone) {}
  63.     void addCellphoneFilm()
  64.     {
  65.         cout << "手机已贴膜!" << endl;
  66.     }
  67.     virtual void showPhone()
  68.     {
  69.         addCellphoneFilm();
  70.         pCellphone->showPhone();
  71.     }
  72. };
  73. //给手机装上手机壳
  74. class CellphoneShell : public Decorator
  75. {
  76. public:
  77.     CellphoneShell(AbstractCellphone *cellphone) : Decorator(cellphone) {}
  78.     void addShell()
  79.     {
  80.         cout << "手机已装上保护壳!" << endl;
  81.     }
  82.     virtual void showPhone()
  83.     {
  84.         addShell();
  85.         pCellphone->showPhone();
  86.     }
  87. };
  88. void test01()
  89. {
  90.     //创建小米手机
  91.     AbstractCellphone *cellphone = NULL;
  92.     cellphone = new XiaomiCellphone("Note 女神版");
  93.     cellphone->showPhone();
  94.     cout << "-----------------------------" << endl;
  95.     //给小米手机贴膜
  96.     Decorator *cellphoneFilm = new CellphoneFilm(cellphone);
  97.     cellphoneFilm->showPhone();
  98.     cout << "-----------------------------" << endl;
  99.     //给贴膜的小米手机再装上保护壳
  100.     Decorator *cellphoneShell = new CellphoneShell(cellphoneFilm);
  101.     cellphoneShell->showPhone();
  102.     delete cellphoneShell;
  103.     delete cellphoneFilm;
  104.     delete cellphone;
  105. }
  106. int main()
  107. {
  108.     test01();
  109.     system("pause");
  110.     return EXIT_SUCCESS;
  111. }

行为型模式

10.模板方法模式

定义一个操作中算法的框架，而将一些步骤延迟到子类中。 也就是基类定义了有固定步骤的抽象方法,各派生类实现不同功能

  1. #include<iostream>
  2. using namespace std;
  3. class DrinkTemplate{
  4. public:
  5.     //煮水
  6.     virtual void BoildWater() = 0;
  7.     //冲泡
  8.     virtual void Brew() = 0;
  9.     //倒入杯中
  10.     virtual void PourInCup() = 0;
  11.     //加辅助料
  12.     virtual void AddSomething() = 0;
  13.     //模板方法
  14.     void Make(){
  15.         BoildWater();
  16.         Brew();
  17.         PourInCup();
  18.         AddSomething();
  19.     }
  20. };
  21. //冲泡咖啡
  22. class Coffee : public DrinkTemplate{
  23. public:
  24.     virtual void BoildWater(){
  25.         cout << "煮山泉水..." << endl;
  26.     }
  27.     //冲泡
  28.     virtual void Brew(){
  29.         cout << "冲泡咖啡..." << endl;
  30.     }
  31.     //倒入杯中
  32.     virtual void PourInCup(){
  33.         cout << "咖啡倒入杯中..." << endl;
  34.     }
  35.     //加辅助料
  36.     virtual void AddSomething(){
  37.         cout << "加糖，加牛奶,加点醋..." << endl;
  38.     }
  39. };
  41. //冲泡茶水
  42. class Tea : public DrinkTemplate{
  43. public:
  44.     virtual void BoildWater(){
  45.         cout << "煮自来水..." << endl;
  46.     }
  47.     //冲泡
  48.     virtual void Brew(){
  49.         cout << "冲泡铁观音..." << endl;
  50.     }
  51.     //倒入杯中
  52.     virtual void PourInCup(){
  53.         cout << "茶水倒入杯中..." << endl;
  54.     }
  55.     //加辅助料
  56.     virtual void AddSomething(){
  57.         cout << "加糖..加柠檬...加生姜..." << endl;
  58.     }
  59. };
  60. void test01(){
  61.     Tea* tea = new Tea;
  62.     tea->Make();
  63.     cout << "-----------" << endl;
  64.     Coffee* coffee = new Coffee;
  65.     coffee->Make();
  66. }
  67. int main(){
  69.     test01();
  71.     system("pause");
  72.     return 0;
  73. }

11.策略模式

  1. #include <iostream>
  2. using namespace std;
  5. //抽象武器 武器策略
  6. class WeaponStrategy{
  7. public:
  8.     virtual void UseWeapon() = 0;
  9. };
  11. class Knife : public WeaponStrategy{
  12. public:
  13.     virtual void UseWeapon(){
  14.         cout << "使用匕首！" << endl;
  15.     }
  16. };
  18. class AK47 :public WeaponStrategy{
  19. public:
  20.     virtual void UseWeapon(){
  21.         cout << "使用AK47！" << endl;
  22.     }
  23. };
  25. class Character {
  26. public:
  27.     void setWeapon(WeaponStrategy* weapon){
  28.         this->pWeapon = weapon;
  29.     }
  30.     void ThrowWeapon(){
  31.         this->pWeapon->UseWeapon();
  32.     }
  33. public:
  34.     WeaponStrategy* pWeapon;
  35. };
  38. void test01(){
  40.     //创建角色
  41.     Character* character = new Character;
  43.     //武器策略
  44.     WeaponStrategy* knife = new Knife;
  45.     WeaponStrategy* ak47 = new AK47;
  47.     character->setWeapon(knife);
  48.     character->ThrowWeapon();
  50.     character->setWeapon(ak47);
  51.     character->ThrowWeapon();
  53.     delete ak47;
  54.     delete knife;
  55.     delete character;
  56. }
  58. int main(void){
  59.     test01();
  60.     return 0;
  61. }

12.命令模式

  1. #include <iostream>
  2. #include<queue>
  3. //#include<Windows.h>
  4. using namespace std;
  7. //协议处理类
  8. class HandleClientProtocol{
  9. public:
  10.     //处理增加金币
  11.     void AddMoney(){
  12.         cout << "给玩家增加金币！" << endl;
  13.     }
  15.     //处理增加钻石
  16.     void AddDiamond(){
  17.         cout << "给玩家增加钻石!" << endl;
  18.     }
  20.     //处理玩家装备
  21.     void AddEquipment(){
  22.         cout << "给玩家穿装备！" << endl;
  23.     }
  25.     //处理玩家升级
  26.     void addLevel(){
  27.         cout << "给玩家升级!" << endl;
  28.     }
  29. };
  31. //命令接口
  32. class AbstractCommand{
  33. public:
  34.     virtual void handle() = 0; //处理客户端请求的接口
  35. };
  38. //处理增加金币请求
  39. class AddMoneyCommand :public AbstractCommand{
  40. public:
  41.     AddMoneyCommand(HandleClientProtocol* protocol){
  42.         this->pProtocol = protocol;
  43.     }
  44.     virtual void handle(){
  45.         this->pProtocol->AddMoney();
  46.     }
  47. public:
  48.     HandleClientProtocol* pProtocol;
  49. };
  51. //处理增加钻石的请求
  52. class AddDiamondCommand :public AbstractCommand{
  53. public:
  54.     AddDiamondCommand(HandleClientProtocol* protocol){
  55.         this->pProtocol = protocol;
  56.     }
  57.     virtual void handle(){
  58.         this->pProtocol->AddDiamond();
  59.     }
  60. public:
  61.     HandleClientProtocol* pProtocol;
  62. };
  65. //处理玩家穿装备的请求
  66. class AddEquipmentCommand : public AbstractCommand{
  67. public:
  68.     AddEquipmentCommand(HandleClientProtocol* protocol){
  69.         this->pProtocol = protocol;
  70.     }
  71.     virtual void handle(){
  72.         this->pProtocol->AddEquipment();
  73.     }
  74. public:
  75.     HandleClientProtocol* pProtocol;
  76. };
  78. //处理玩家升级的请求
  79. class AddLevelCommand : public AbstractCommand{
  80. public:
  81.     AddLevelCommand(HandleClientProtocol* protocol){
  82.         this->pProtocol = protocol;
  83.     }
  84.     virtual void handle(){
  85.         this->pProtocol->addLevel();
  86.     }
  87. public:
  88.     HandleClientProtocol* pProtocol;
  90. };
  93. //服务器程序
  94. class Serser{
  95. public:
  96.     void addRequest(AbstractCommand* command){
  97.         mCommands.push(command);
  98.     }
  100.     void startHandle(){
  101.         while (!mCommands.empty()){
  103.             //Sleep(2000);
  104.             AbstractCommand* command = mCommands.front();
  105.             command->handle();
  106.             mCommands.pop();
  107.         }
  108.     }
  109. public:
  110.     queue<AbstractCommand*> mCommands;
  111. };
  113. void test01(){
  115.     HandleClientProtocol* protocol = new HandleClientProtocol;
  116.     //客户端增加金币的请求
  117.     AbstractCommand* addmoney = new AddMoneyCommand(protocol);
  118.     //客户端增加钻石的请求
  119.     AbstractCommand* adddiamond = new AddDiamondCommand(protocol);
  120.     //客户端穿装备的请求
  121.     AbstractCommand* addequpment = new AddEquipmentCommand(protocol);
  122.     //客户端升级请求
  123.     AbstractCommand* addlevel = new AddLevelCommand(protocol);
  125.     Serser* server = new Serser;
  126.     //将客户端请求加入到处理的队列中
  127.     server->addRequest(addmoney);
  128.     server->addRequest(adddiamond);
  129.     server->addRequest(addequpment);
  130.     server->addRequest(addlevel);
  132.     //服务器开始处理请求
  133.     server->startHandle();
  134. }
  136. int main(void){
  137.     test01();
  138.     return 0;
  139. }

13.观察者模式

观察者模式是用于建立一种对象与对象之间的依赖关系，一个对象发生改变 时将自动通知其他对象，其他对象将相应作出反应。在观察者模式中，发生改变 的对象称为观察目标，而被通知的对象称为观察者，一个观察目标可以对应多个 观察者，而且这些观察者之间可以没有任何相互联系，可以根据需要增加和删除 观察者，使得系统更易于扩展。 

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include<list>
  4. using namespace std;
  6. //抽象的英雄 抽象的观察者
  7. class AbstractHero{
  8. public:
  9.     virtual void Update() = 0;
  10. };
  13. //具体英雄  具体观察者
  14. class HeroA :public AbstractHero{
  15. public:
  16.     HeroA(){
  17.         cout << "英雄A正在撸BOSS ..." << endl;
  18.     }
  19.     virtual void Update(){
  20.         cout << "英雄A停止撸,待机状态..." << endl;
  21.     }
  22. };
  24. class HeroB :public AbstractHero{
  25. public:
  26.     HeroB(){
  27.         cout << "英雄B正在撸BOSS ..." << endl;
  28.     }
  29.     virtual void Update(){
  30.         cout << "英雄B停止撸,待机状态..." << endl;
  31.     }
  32. };
  34. class HeroC :public AbstractHero{
  35. public:
  36.     HeroC(){
  37.         cout << "英雄C正在撸BOSS ..." << endl;
  38.     }
  39.     virtual void Update(){
  40.         cout << "英雄C停止撸,待机状态..." << endl;
  41.     }
  42. };
  44. class HeroD :public AbstractHero{
  45. public:
  46.     HeroD(){
  47.         cout << "英雄D正在撸BOSS ..." << endl;
  48.     }
  49.     virtual void Update(){
  50.         cout << "英雄D停止撸,待机状态..." << endl;
  51.     }
  52. };
  54. class HeroE :public AbstractHero{
  55. public:
  56.     HeroE(){
  57.         cout << "英雄E正在撸BOSS ..." << endl;
  58.     }
  59.     virtual void Update(){
  60.         cout << "英雄E停止撸,待机状态..." << endl;
  61.     }
  62. };
  65. //观察目标抽象
  66. class AbstractBoss{
  67. public:
  68.     //添加观察者
  69.     virtual void addHero(AbstractHero* hero) = 0;
  70.     //删除观察者
  71.     virtual void deleteHero(AbstractHero* hero) = 0;
  72.     //通知所有观察者
  73.     virtual void notify() = 0; 
  74. };
  77. //具体的观察者 BOSSA
  78. class BOSSA : public AbstractBoss{
  79. public:
  80.     virtual void addHero(AbstractHero* hero){
  81.         pHeroList.push_back(hero);
  82.     }
  83.     //删除观察者
  84.     virtual void deleteHero(AbstractHero* hero){
  85.         pHeroList.remove(hero);
  86.     }
  87.     //通知所有观察者
  88.     virtual void notify(){
  89.         for (list<AbstractHero*>::iterator it = pHeroList.begin(); it != pHeroList.end();it ++){
  90.             (*it)->Update();
  91.         }
  92.     }
  93. public:
  94.     list<AbstractHero*> pHeroList;
  95. };
  99. void test01(){
  102.     //创建观察者
  103.     AbstractHero* heroA = new HeroA;
  104.     AbstractHero* heroB = new HeroB;
  105.     AbstractHero* heroC = new HeroC;
  106.     AbstractHero* heroD = new HeroD;
  107.     AbstractHero* heroE = new HeroE;
  109.     //创建观察目标
  110.     AbstractBoss* bossA = new BOSSA;
  111.     bossA->addHero(heroA);
  112.     bossA->addHero(heroB);
  113.     bossA->addHero(heroC);
  114.     bossA->addHero(heroD);
  115.     bossA->addHero(heroE);
  118.     cout << "heroC阵亡..." << endl;
  119.     bossA->deleteHero(heroC);
  121.     cout << "Boss死了...通知其他英雄停止攻击，抢装备..." << endl;
  122.     bossA->notify();
  124. }
  127. int main(void){
  128.     test01();
  129.     return 0;
  130. }