C++设计模式（全23种）

设计模式概述

��计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的解决某一类问题的一种编码方案。

文章目录

• 设计模式概述
• 设计模式特点
• 一、创建型模式
• • Factory 模式（工厂模式）
  • AbstactFactory 模式（抽象工厂模式）
  • Singleton 模式（ 单例模式）
  • Builder 模式（建造者模式）
  • Prototype 模式（原型模式）
  • 二、结构型模式
  • • Bridge 模式（桥接模式）
    • Adapter 模式（适配器模式）
    • Decorator 模式（装饰器模式）
    • Composite 模式（组合实体模式）
    • Flyweight 模式（享元模式）
    • Facade 模式（外观模式）
    • Proxy 模式（代理模式）
    • 三、行为模式
    • • Template 模式（模板模式）
      • Strategy 模式（策略模式）
      • State 模式（状态模式）
      • Observer 模式(观察者模式)
      • Memento 模式（备忘录模式）
      • Mediator 模式（中介者模式）
      • Command 模式（命令模式）
      • Visitor 模式（访问者模式）
      • Chain of Responsibility 模式（责任链模式）
      • Iterator 模式（迭代器模式）
      • Interpreter 模式（解释器模式）
      • 引用

        ---

        设计模式特点

        类型	设计模式	描述
        创建型	Factory 模式	被实例化的子类
        AbstactFactory 模式	产品对象家族
        Singleton 模式	针对一个类的唯一实例
        Builder 模式	如何创建一个组合对象
        Prototype 模式	针对被实例化的类
        结构型	Bridge 模式	对象的实现
        Adapter 模式	针对对象的接口
        Decorator 模式	对对象的职责，不生成子类
        Composite 模式	一个对象的结构和组成
        Flyweight 模式	对象的存储开销
        Facade 模式	对一个子系统的接口
        Proxy 模式	如何访问一个对象；该对象的位置
        行为型	Template 模式	对算法中的某些步骤
        Strategy 模式	算法
        State 模式	对象的状态
        Observer 模式	对多个对象依赖于另外一个对象，而这些对象又如何保持一致
        Memento 模式	对一个对象中哪些私有信息存放在该对象之外，以及在对什么时候进行存储
        Mediator 模式	对象间怎样交互、和谁交互
        Command 模式	何时、怎样满足一个请求
        Visitor 模式	某些可作用于一个（组）对象上的操作，但不修改这些对象的类
        Chain of Responsibility 模式	满足一个请求的对象链
        Iterator 模式	如何遍历、访问一个聚合的各元素
        Interpreter 模式	对一个语言的文法及解释

        一、创建型模式

        Factory 模式（工厂模式）

        在面向对象系统设计中经常可以遇到以下的两类问题：

        • 我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。所以就不得不在要用到子类的地方写new 对象。这样实体类的使用者必须知道实际的子类名称，以及会使程序的扩展性和维护变得越来越困难。
        • 还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。只能在父类中写方法调用，具体调用哪一个类的方法交给子类实现。

          1）定义创建对象的接口，封装了对象的创建。

          2）使得具体化类的工作延迟到了子类中。

          举例：

          代码：

          //Product.h #ifndef _PRODUCT_H_ #define _PRODUCT_H_ class Product { public: virtual ~Product() = 0;  protected:  Product(); private: }; class ConcreteProduct:public Product { public:  ~ConcreteProduct();  ConcreteProduct();  protected: private: }; #endif //~_PRODUCT_H_//Product.cpp #include "Product.h" #include  using namespace std; Product::Product() {  } Product::~Product() { } ConcreteProduct::ConcreteProduct() {  cout } //Factory.h #ifndef _FACTORY_H_ #define _FACTORY_H_ class Product; class Factory { public: virtual ~Factory() = 0;virtual Product* CreateProduct() = 0; protected:  Factory(); private: class ConcreteFactory:public Factory{ public:  ~ConcreteFactory();  ConcreteFactory();  Product* CreateProduct(); protected: private: }; #endif //~_FACTORY_H_ //Factory.cpp #include "Factory.h" #include "Product.h" #include  } Factory::~Factory() {} ConcreteFactory::ConcreteFactory() {  cout } Product* ConcreteFactory::CreateProduct() { return new ConcreteProduct(); } //main.cpp #include "Factory.h" #include "Product.h"#include  Factory* fac = new ConcreteFactory(); Product* p = fac-CreateProduct();  return 0;} public:    virtual void showName() = 0;};//中国苹果class ChinaApple :public AbstractApple {public:    virtual void showName() {        cout public:    virtual void showName() {        cout public:    virtual void showName() {        cout public:    virtual void showName() = 0;};//中国香蕉class ChinaBanana :public AbstractBanana {public:    virtual void showName() {        cout public:    virtual void showName() {        cout public:    virtual void showName() {        cout public:    virtual void showName() = 0;};//中国鸭梨class ChinaPear :public AbstractPear {public:    virtual void showName() {        cout public:    virtual void showName() {        cout public:    virtual void showName() {        cout public:    virtual AbstractApple* CreateApple() = 0;    virtual AbstractBanana* CreateBanana() = 0;    virtual AbstractPear* CreatePear() = 0;};//中国工厂class ChinaFactory :public AbstractFactory {    virtual AbstractApple* CreateApple() {        return new ChinaApple;    }    virtual AbstractBanana* CreateBanana() {        return new ChinaBanana;    }    virtual AbstractPear* CreatePear() {        return new ChinaPear;    }};//美国工厂class USAFactory :public AbstractFactory {    virtual AbstractApple* CreateApple() {        return new USAApple;    }    virtual AbstractBanana* CreateBanana() {        return new USABanana;    }    virtual AbstractPear* CreatePear() {        return new USAPear;    }};//日本工厂class JapanFactory :public AbstractFactory {    virtual AbstractApple* CreateApple() {        return new JapanApple;    }    virtual AbstractBanana* CreateBanana() {        return new JapanBanana;    }    virtual AbstractPear* CreatePear() {        return new JapanPear;    }};void test01() {    AbstractFactory* factory = NULL;    AbstractApple* apple = NULL;    AbstractBanana* Banana = NULL;    AbstractPear* Pear = NULL;    //中国工厂    factory = new ChinaFactory;    apple = factory-CreateApple();    Banana = factory-CreateBanana();    Pear = factory-CreatePear();    apple-showName();    Banana-showName();    Pear-showName();    delete Pear;    delete apple;    delete Banana;    delete factory;}int main(){    test01();}public:    static A* getInstace() {        return a;    }private :    A() {        a = new A;    }    static A* a; };A* A::a = NULL;//懒汉式   对象的创建在第一次调用getInstance函数时创建//懒汉式是线程不安全的class SingletonLazy {public:    static SingletonLazy* getInstance() {        if (pSingleton == NULL) {            pSingleton = new SingletonLazy;        }        return pSingleton;    }private:    SingletonLazy() {}    static SingletonLazy* pSingleton;};//在类外面进行初始化SingletonLazy* SingletonLazy::pSingleton=NULL;//饿汉式    对象在程序执行时优先创建//饿汉式是线程安全的class SingletonHungry {public:    static SingletonHungry* getInstance() {        return pSingleton;    }    static void freeSpace() {        if (pSingleton != NULL) {            delete pSingleton;        }    }private:    SingletonHungry() {}    static SingletonHungry* pSingleton;};//以下语句将会在main函数运行前执行SingletonHungry* SingletonHungry::pSingleton=new SingletonHungry;void test01() {    SingletonLazy* p1 = SingletonLazy::getInstance();    SingletonLazy* p2 = SingletonLazy::getInstance();    if (p1 == p2) {        cout         cout         cout         cout     test01();} public:  Product();  ~Product();  void ProducePart(); protected: private: }; class ProductPart { public:  ProductPart();  ~ProductPart();  ProductPart* BuildPart(); protected: private: }; #endif //~_PRODUCT_H_//Component.cpp#include "Component.h" Component::Component() { } Component::~Component() { } void Component::Add(const Component&com){ } Component* Component::GetChild(int index) {  return 0;} void Component::Remove(const Component& com){ }//Builder.h #ifndef _BUILDER_H_ #define _BUILDER_H_ #include  public:  virtual ~Builder(); virtual void BuildPartA(const string& buildPara) = 0; virtual void BuildPartB(const string& buildPara) = 0; virtual void BuildPartC(const string& buildPara) = 0; virtual Product* GetProduct() = 0;protected:  Builder(); private: }; class ConcreteBuilder:public Builder { public:  ConcreteBuilder();  ~ConcreteBuilder(); void BuildPartA(const string& buildPara);void BuildPartB(const string& buildPara);void BuildPartC(const string& buildPara); Product* GetProduct(); protected: private: }; #endif //~_BUILDER_H_//Builder.cpp #include "Builder.h" #include "Product.h" #include  } Builder::~Builder() { } ConcreteBuilder::ConcreteBuilder() { } ConcreteBuilder::~ConcreteBuilder() { } void ConcreteBuilder::BuildPartA(const string& buildPara) {  cout  cout  cout  BuildPartA("pre-defined");  BuildPartB("pre-defined");  BuildPartC("pre-defined"); return new Product(); }//Director.h #ifndef _DIRECTOR_H_ #define _DIRECTOR_H_ class Builder; class Director { public:  Director(Builder* bld);  ~Director();  void Construct();protected: private:  Builder* _bld; }; #endif //~_DIRECTOR_H_//Director.cpp #include "director.h" #include "Builder.h" Director::Director(Builder* bld){ _bld = bld; } Director::~Director() {  } void Director::Construct() {  _bld-BuildPartA("user-defined");  _bld-BuildPartB("user-defined");  _bld-BuildPartC("user-defined"); }//main.cpp #include "Builder.h" #include "Product.h" #include "Director.h" #include  Director* d = new Director(newConcreteBuilder());  d-Construct(); return 0;} public:  virtual ~Prototype(); virtual Prototype* Clone() const = 0; protected:  Prototype(); private: }; class ConcretePrototype:public Prototype { public:  ConcretePrototype();  ConcretePrototype(const ConcretePrototype& cp);  ~ConcretePrototype(); Prototype* Clone() const; protected: private: }; #endif //~_PROTOTYPE_H_ //Prototype.cpp#include "Prototype.h" #include  } Prototype::~Prototype() { } Prototype* Prototype::Clone() const {  return 0;} ConcretePrototype::ConcretePrototype() { } ConcretePrototype::~ConcretePrototype() { } ConcretePrototype::ConcretePrototype(const ConcretePrototype& cp) {  cout return new ConcretePrototype(*this); }//main.cpp #include "Prototype.h" #include  Prototype* p = new ConcretePrototype(); Prototype* p1 = p-Clone();  return 0;} public:  virtual ~Abstraction(); virtual void Operation() = 0; protected:  Abstraction();private: }; class RefinedAbstraction:public Abstraction { public:  RefinedAbstraction(AbstractionImp* imp);  ~RefinedAbstraction();  void Operation();protected: private:  AbstractionImp* _imp; }; #endif //~_ABSTRACTION_H_//Abstraction.cpp #include "Abstraction.h" #include "AbstractionImp.h" #include  } Abstraction::~Abstraction() { } RefinedAbstraction::RefinedAbstraction(AbstractionImp* imp){ _imp = imp; } RefinedAbstraction::~RefinedAbstraction() { } void RefinedAbstraction::Operation() {  _imp-Operation(); } //AbstractionImp.h #ifndef _ABSTRACTIONIMP_H_ #define _ABSTRACTIONIMP_H_ class AbstractionImp { public:  virtual ~AbstractionImp(); virtual void Operation() = 0; protected:  AbstractionImp(); private: }; class ConcreteAbstractionImpA:public AbstractionImp{ public:  ConcreteAbstractionImpA();  ~ConcreteAbstractionImpA(); virtual void Operation();protected: private: }; class ConcreteAbstractionImpB:public AbstractionImp{ public:  ConcreteAbstractionImpB();  ~ConcreteAbstractionImpB(); virtual void Operation();protected: private: }; #endif //~_ABSTRACTIONIMP_H_ //AbstractionImp.cpp #include "AbstractionImp.h" #include  } AbstractionImp::~AbstractionImp() { } void AbstractionImp::Operation() {  cout } ConcreteAbstractionImpA::~ConcreteAbstractionImpA() { } void ConcreteAbstractionImpA::Operation() {  cout } ConcreteAbstractionImpB::~ConcreteAbstractionImpB() { } void ConcreteAbstractionImpB::Operation() {  cout AbstractionImp* imp = new ConcreteAbstractionImpA(); Abstraction* abs = new RefinedAbstraction(imp); abs-Operation();   return 0;} public:  Target();  virtual ~Target();virtual void Request(); }; class Adaptee{ public:  Adaptee(); ~Adaptee(); void SpecificRequest(); }; class Adapter:public Target { public:  Adapter(Adaptee* ade);  ~Adapter();  void Request(); private:  Adaptee* _ade;}; #endif //~_ADAPTER_H_ //Adapter.cpp #include "Adapter.h" #include  } Target::~Target(){ } void Target::Request() {  std::cout } Adaptee::~Adaptee() { } void Adaptee::SpecificRequest(){  std::cout  this-_ade = ade;} Adapter::~Adapter() { } void Adapter::Request() {  _ade-SpecificRequest(); }//main.cpp #include "Adapter.h" #include  Adaptee* ade = new Adaptee;Target* adt = new Adapter(ade); adt-Request(); return 0;} public:virtual void showStatus() = 0;int mHp;int mMp;int mAt;int mDf;};class HeroA:public AbstractHero{public:HeroA(){mHp = 0;mMp = 0;mAt = 0;mDf = 0;}virtual void showStatus(){cout public:AbstractEquipment(AbstractHero* hero){this-pHero = hero;}virtual void showStatus(){}AbstractHero* pHero;};//给英雄穿上狂徒铠甲class KuangtuEquipment:public AbstractEquipment{public:KuangtuEquipment(AbstractHero* hero):AbstractEquipment(hero){}//增加额外的功能void AddKuangtu(){cout AddKuangtu();cout public:Wujinzhireng(AbstractHero* hero) :AbstractEquipment(hero) {}//增加额外的功能void AddKuangtu(){cout AddKuangtu();cout AbstractHero* hero = new HeroA;hero-showStatus();cout test01();} public:  Component(){}  virtual ~Component(){}  // 纯虚函数,只提供接口,没有默认的实现 virtual void Operation() = 0;  // 虚函数,提供接口,有默认的实现就是什么都不做 virtual void Add(Component* pChild);  virtual void Remove(Component* pChild);  virtual Component* GetChild(int nIndex); }; // 派生自 Component,是其中的叶子组件的基类class Leaf  : public Component { public:  Leaf(){}  virtual ~Leaf(){}  virtual void Operation(); }; // 派生自 Component,是其中的含有子件的组件的基类class Composite  : public Component { public:  Composite(){}  virtual ~Composite();  virtual void Operation();  virtual void Add(Component* pChild);  virtual void Remove(Component* pChild);  virtual Component* GetChild(int nIndex); private:  // 采用 list 容器去保存子组件 std::list } void Component::Remove(Component* pChild) { } Component* Component::GetChild(int nIndex) {  return NULL; } /*-------------------------------------------------------------------  Leaf 成员函数的实现-------------------------------------------------------------------*/void Leaf::Operation() {  std::cout   std::list  temp = iter1;  ++iter1;  delete (*temp);  } } void Composite::Add(Component* pChild) {  m_ListOfComponent.push_back(pChild); } void Composite::Remove(Component* pChild) {  std::list  m_ListOfComponent.erase(iter);  } } Component* Composite::GetChild(int nIndex) {  if (nIndex   if (i == nIndex)  break;  } PDF created with pdfFactory trial version www.pdffactory.com return *iter1; } void Composite::Operation() {  std::cout   (*iter1)-Operation();  } }#include "Composite.h" #include   Leaf *pLeaf1 = new Leaf();  Leaf *pLeaf2 = new Leaf();  Composite* pComposite = new Composite;  pComposite-Add(pLeaf1);  pComposite-Add(pLeaf2);  pComposite-Operation();  pComposite-GetChild(2)-Operation();  delete pComposite;  public:  virtual ~Flyweight(){}  STATE GetIntrinsicState();  virtual void Operation(STATE& ExtrinsicState) = 0; protected:  Flyweight(const STATE& state)  :m_State(state)  {  } private:  STATE m_State; }; class FlyweightFactory { public:  FlyweightFactory(){}  ~FlyweightFactory();  Flyweight* GetFlyweight(const STATE& key); private:  std::list public:  ConcreateFlyweight(const STATE& state)  : Flyweight(state)  {  }  virtual ~ConcreateFlyweight(){}  virtual void Operation(STATE& ExtrinsicState); }; #endif//Flyweight.cpp#include "FlyWeight.h" #include   return m_State; } FlyweightFactory::~FlyweightFactory() {  std::list  temp = iter1;  ++iter1;  delete (*temp);  }  m_listFlyweight.clear(); } Flyweight* FlyweightFactory::GetFlyweight(const STATE& key) {  std::list  if ((*iter1)-GetIntrinsicState() == key)  {  std::cout  }#include "FlyWeight.h" int main() {  FlyweightFactory flyweightfactory;  flyweightfactory.GetFlyweight("hello");  flyweightfactory.GetFlyweight("world");  flyweightfactory.GetFlyweight("hello");  system("pause");  return 0; }public:    void on() {        cout         cout public:    void on() {        cout         cout public:    void on() {        cout         cout public:    void on() {        cout         cout public:    void on() {        cout         cout public:    void on() {        cout         cout public:    KTVMode() {        pTV = new Television;        pLight = new Light;        pAudio = new Audio;        pMicrophone = new Microphone;        pDvd = new DVDplayer;    }    void onKTV() {        pTV-on();        pLight-off();        pAudio-on();        pMicrophone-on();        pDvd-on();    }    void offKTV() {        pTV-off();        pLight-off();        pAudio-off();        pMicrophone-off();        pDvd-off();    }    ~KTVMode() {        delete pTV;        delete pLight;        delete pAudio;        delete pMicrophone;        delete pDvd;    }private:    Television* pTV;    Light* pLight;    Audio* pAudio;    Microphone* pMicrophone;    DVDplayer* pDvd;};void test01() {    KTVMode* ktv = new KTVMode;    //KTV包厢来人了    ktv-onKTV();}int main(){    test01();}public:    virtual void run() = 0;};//下面是操作系统类class MySystem :public AbstractCommonInterface{public:    virtual void run() {        cout public:    MySystemProxy(string userName, string password) {        this-mUserName = userName;        this-mPassword = password;        pMySystem = new MySystem;    }    bool checkUserNameAndPassword() {        if (mUserName == "admin" && mPassword == "admin") {            return true;        }        return false;    }    virtual void run() {        if (checkUserNameAndPassword() == true) {            cout             cout         if (pMySystem != NULL) {            delete pMySystem;        }    }private:    string mUserName;    string mPassword;    MySystem* pMySystem;};void test01() {    MySystemProxy* proxy = new MySystemProxy("admin", "admin");    proxy-run();}int main(){    test01();}public:    //煮水    virtual void BoildWater() = 0;    //冲泡    virtual void Brew() = 0;    //倒入杯中    virtual void PourInCup() = 0;    //加辅助材料    virtual void AddSomething() = 0;    //模板方法    void Make() {        BoildWater();        Brew();        PourInCup();        AddSomething();    }};//做咖啡：  实现做饮料模板class Coffee :public DrinkTemplate {    virtual void BoildWater() {        cout         cout         cout         cout     virtual void BoildWater() {        cout         cout         cout         cout     Tea* tea = new Tea;    tea-Make();    Coffee* coffee = new Coffee;    coffee-Make();}int main(){    test01();}public:    virtual void UseWeapon() = 0;};//具体的策略使用匕首作为武器class Knife :public WeaponStrategy {public:    virtual void UseWeapon() {        cout public:    virtual void UseWeapon() {        cout public:    WeaponStrategy* pWeapon;    void setWeapon(WeaponStrategy* pWeapon) {        this-pWeapon = pWeapon;    }    void ThrowWeapon() {        this-pWeapon-UseWeapon();    }};void test01() {    Character* character = new Character;    WeaponStrategy* knife = new Knife;    WeaponStrategy* ak47 = new AK47;    //用匕首当作武器    character-setWeapon(knife);    character-ThrowWeapon();    character-setWeapon(ak47);    character-ThrowWeapon();    delete ak47;    delete knife;    delete character;}int main(){    test01();}public://扣除50积分virtual void deductMeney() = 0;//是否中奖virtual bool raffle() = 0;//发放奖品virtual void dispensePrize() = 0;};//CanRaffleState.h#pragma once#include public:CanRaffleState(RaffleActivity* activity);//已经扣除积分了，不能再扣了void deductMeney() override;//可以抽奖，根据抽奖情况改成新的状态bool raffle() override;void dispensePrize() override;private:RaffleActivity* activity;};//CanRaffleState.cpp#include "CanRaffleState.h"#include "RaffleActivity.h"CanRaffleState::CanRaffleState(RaffleActivity* activity){srand(time(NULL));this-activity = activity;}//已经扣除积分了，不能再扣了void CanRaffleState::deductMeney() {cout cout //将activity的状态设置为发放奖品的状态activity-setState(activity-getDispenseState());return true;}else{cout cout public:DispenseOutState(RaffleActivity* activity);void deductMeney() override;bool raffle() override;//发放奖品void dispensePrize() override;private:RaffleActivity* activity;};//RaffleActivity.cpp#include "DispenseOutState.h"#include "RaffleActivity.h"DispenseOutState::DispenseOutState(RaffleActivity* activity){this-activity = activity;}void DispenseOutState::deductMeney(){cout cout cout public:DispenseState(RaffleActivity* activity);void deductMeney() override;bool raffle() override;//发放奖品void dispensePrize() override;private:RaffleActivity* activity;};//DispenseState.cpp#include "DispenseState.h"#include "RaffleActivity.h"DispenseState::DispenseState(RaffleActivity* activity){this-activity = activity;}void DispenseState::deductMeney(){cout cout if (activity-getCount()  0){cout cout public:NoRaffleState(RaffleActivity* activity);//在不能抽奖状态是可以扣积分的，扣除积分后设置成可以抽奖状态void deductMeney() override;bool raffle() override;void dispensePrize() override;private://初始化时传入活动，扣除积分后改变其状态RaffleActivity* activity;};//NoRaffleState.cpp#include "NoRaffleState.h"#include "RaffleActivity.h";NoRaffleState::NoRaffleState(RaffleActivity* activity){this-activity = activity;}//在不能抽奖状态是可以扣积分的，扣除积分后设置成可以抽奖状态void NoRaffleState::deductMeney(){std::cout cout cout public:State* getState() const{return state;}void setState(State* const state){this-state = state;}int getCount(){return count--;}void setCount(const int count){this-count = count;}State* getNoRaffleState() const{return noRaffleState;}void setNoRaffleState(State* const noRaffleState){this-noRaffleState = noRaffleState;}State* getCanRaffleState() const{return canRaffleState;}void setCanRaffleState(State* const canRaffleState){this-canRaffleState = canRaffleState;}State* getDispenseState() const{return dispenseState;}void setDispenseState(State* const dispenseState){this-dispenseState = dispenseState;}State* getDispenseOutState() const{return dispenseOutState;}void setDispenseOutState(State* const dispenseOutState){this-dispenseOutState = dispenseOutState;}RaffleActivity(int count){//初始化当前状态为 不能抽奖状态this-state = getNoRaffleState();//初始化奖品数量this-count = count;}//扣分，调用当前状态的deductMoneyvoid deductMoney(){state-deductMeney();}//抽奖void raffle(){//如果抽中奖了，则领奖品if (state-raffle()){state-dispensePrize();}}private://state表示活动当前的状态State* state = nullptr;//奖品数量int count = 0;//四个属性 表示四种状态State* noRaffleState = new NoRaffleState(this);State* canRaffleState = new CanRaffleState(this);State* dispenseState = new DispenseState(this);State* dispenseOutState = new DispenseOutState(this);};//main.cpp#include RaffleActivity* activity = new RaffleActivity(1);for(int i=0;icout public:    virtual void Update() = 0;};//具体的英雄 具体的观察者 class HeroA :public AbstractHero {public:    HeroA() {        cout         cout public:    HeroB() {        cout         cout public:    HeroC() {        cout         cout public:    HeroD() {        cout         cout public:    HeroE() {        cout         cout public:    //    添加观察者    virtual void addHero(AbstractHero* hero) = 0;    //    删除观察者    virtual void deleteHero(AbstractHero* hero) = 0;    //    通知所有观察者    virtual void notifv() = 0;};//相对于 concreteSubjectclass BOSSA :public AbstractBoss {public:    //    添加观察者    virtual void addHero(AbstractHero* hero) {        pHeroList.push_back(hero);    }    //    删除观察者    virtual void deleteHero(AbstractHero* hero) {        pHeroList.remove(hero);    }    //    通知所有观察者    virtual void notifv() {        for (list            (*it)-Update();        }    }    list    //    创建观察者    AbstractHero* heroA = new HeroA;    AbstractHero* heroB = new HeroB;    AbstractHero* heroC = new HeroC;    AbstractHero* heroD = new HeroD;    AbstractHero* heroE = new HeroE;    //    创建观察目标    AbstractBoss* bossA = new BOSSA;    bossA-addHero(heroA);    bossA-addHero(heroB);    bossA-addHero(heroC);    bossA-addHero(heroD);    bossA-addHero(heroE);    cout     test01();    return 0;}public:std::string getState() const{return state;}void setState(const std::string& state){this-state = state;}//保存一个状态对象Memento   即用当前状态的值去创建一个Memento然后将其返回Memento SaveStateMemento(){return Memento(state);}//通过备忘录对象，恢复状态void getStateFromMemento(Memento memento){state = memento.getState();}private:std::string state;};#endif//Memento.h#ifndef _MEMENTO_H_#define _MEMENTO_H_#include public:explicit Memento(const std::string& state): state(state){}std::string getState() const{return state;}private:std::string state;};#endif//Caretaker.h#ifndef _CARETAKER_H_#define _CARETAKER_H_#include public:void add(Memento memento){mementoList.push_back(memento);}//获取到第index个Originator的备忘录对象（即备忘录状态）Memento get(int index){return mementoList[index];}private://在mementoList中会有很多备忘录对象std::vectorOriginator originator;Caretaker caretaker;originator.setState("状态1，攻击力为100");//保存当前状态caretaker.add(originator.SaveStateMemento());//受到debuff，攻击力下降originator.setState("状态2，攻击力为80");//保存状态caretaker.add(originator.SaveStateMemento());cout public:Mediator* getMediator();void setMediator(Mediator* const mediator);Colleague(Mediator* mediator);virtual void Notify(std::string message)=0;private:Mediator* mediator;};//Colleague.cpp#include "Colleague.h"#include "Mediator.h"Mediator* Colleague::getMediator(){return mediator;}void Colleague::setMediator(Mediator* const mediator){this-mediator = mediator;}Colleague::Colleague(Mediator* mediator){this-mediator = mediator;this-mediator-add(this);}//ConcreteColleague1.h#ifndef _CONCRETECOLLEAGUE1_H_#define _CONCRETECOLLEAGUE1_H_#include public:ConcreteColleague1(Mediator* mediator):Colleague(mediator){}void send(std::string message){getMediator()-send(message, this);}void Notify(std::string message){std::cout public:ConcreteColleague2(Mediator* mediator) :Colleague(mediator){}void send(std::string message){getMediator()-send(message, this);}void Notify(std::string message){std::cout public:void add(Colleague* colleague){colleaguesList.push_back(colleague);}void send(std::string message, Colleague* colleague){for (auto value : colleaguesList){if(value!=colleague){value-Notify(message);}}}private:std::vectorpublic:virtual void send(std::string message, Colleague* colleague)=0;virtual void add(Colleague* colleague)=0;};#endif//main.cpp#include Mediator* mediator = new ConcreteMediator();ConcreteColleague1* colleague1 = new ConcreteColleague1(mediator);ConcreteColleague2* colleague2 = new ConcreteColleague2(mediator);colleague1-send("早上好啊！");colleague2-send("早安！");return 0;}public://处理增加金币void AddMoney(){cout cout cout cout public://相当于execute（）virtual void handle() = 0;};//下面是把每个功能都封装为一个请求对象//处理增加金币请求class AddMoneyCommand:public AbstractCommand{public:AddMoneyCommand(HandleClinetProtocal* protocal){this-pProtocol = protocal;}virtual void handle(){this-pProtocol-AddMoney();}public:HandleClinetProtocal* pProtocol;};//处理增加钻石请求class AddDiamondCommand :public AbstractCommand{public:AddDiamondCommand(HandleClinetProtocal* protocal){this-pProtocol = protocal;}virtual void handle(){this-pProtocol-AddDiamond();}public:HandleClinetProtocal* pProtocol;};//处理玩家装备请求class AddEquipmentCommand :public AbstractCommand{public:AddEquipmentCommand(HandleClinetProtocal* protocal){this-pProtocol = protocal;}virtual void handle(){this-pProtocol-AddEquipment();}public:HandleClinetProtocal* pProtocol;};//处理玩家升级请求class AddLevelCommand :public AbstractCommand{public:AddLevelCommand(HandleClinetProtocal* protocal){this-pProtocol = protocal;}virtual void handle(){this-pProtocol-AddLevel();}public:HandleClinetProtocal* pProtocol;};//服务器程序   （命令调用类）class Server{public://将请求对象放入处理队列void addRequest(AbstractCommand* command){mCommands.push(command);}//启动处理程序void startHandle(){while (!mCommands.empty()){Sleep(2000);AbstractCommand* command = mCommands.front();command-handle();mCommands.pop();}}queueHandleClinetProtocal* protocal = new HandleClinetProtocal;//客户端增加金币的请求AbstractCommand* addmoney = new AddMoneyCommand(protocal);//客户端增加钻石的请求AbstractCommand* adddiamond = new AddDiamondCommand(protocal);//客户端穿装备的请求AbstractCommand* addequipment = new AddEquipmentCommand(protocal);//客户端升级请求AbstractCommand* addlevel = new AddLevelCommand(protocal);//将客户端的请求加入到请求队列中Server* server = new Server;server-addRequest(addmoney);server-addRequest(adddiamond);server-addRequest(addequipment);server-addRequest(addlevel);//服务器开始处理请求server-startHandle();}int main(){test01();return 0;}public:virtual void getManResult(Man* man) =0;virtual void getWomanResult(Woman* woman) =0;private:};class Success:public Action{public:void getManResult(Man* man) override{cout cout public:void getManResult(Man* man) override{cout cout public://提供一个方法让访问者可以访问virtual void accept(Action* action) = 0;};//这里用用到了双分派，即首先在客户端程序中，将具体的状态作为参数传递进Man中（第一次分派）//然后在Man中调用作为参数的“具体方法” getManResult同时将自己作为参数传入完成第二次分派class Man:public Person{public:void accept(Action* action) override{action-getManResult(this);}};class Woman: public Person{public:void accept(Action* action) override{action-getWomanResult(this);}};//数据结构，管理很多人（Man、Woman）用来装符合某一个评价的所有人class ObjectStructure{public://添加到listvoid attach(Person* p){persons.push_back(p);}//移除void detach(Person* p){persons.remove(p);delete p;}//显示测评情况void display(Action* action){for (auto value : persons){value-accept(action);}}private:list//创建ObjectStructure（可以创建很多个不同的ObjectStructure来代表不同评价，然后把同样评价的人放到一个ObjectStructure中）ObjectStructure* objectStructure = new ObjectStructure;objectStructure-attach(new Man);objectStructure-attach(new Woman);//假如歌手获得成功Success* success = new Success;objectStructure-display(success);cout public:int getType() const{return type;}float getPrice() const{return price;}int getId() const{return id;}PurchaseRequest(const int type, const float price, const int id): type(type),  price(price),  id(id){}private://请求类型int type;//价格float price = 0.f;int id = 0;};class Approver{public:void setApprover(Approver* const approver){this-approver = approver;}explicit Approver(const string& name): name(name){}//处理审批请求的方法，得到一个请求，处理是子类完成的，因此该方法写成纯虚方法virtual void processRequest(PurchaseRequest* purchaseRequest)=0;protected://下一个处理者Approver* approver;//名字string name;};//教学主任class DepartmentApprover:public Approver{public:explicit DepartmentApprover(const string& name): Approver(name){}void processRequest(PurchaseRequest* purchaseRequest) override{if(purchaseRequest-getPrice()cout approver-processRequest(purchaseRequest);}}};//院长class CollegeApprover :public Approver{public:explicit CollegeApprover(const string& name): Approver(name){}void processRequest(PurchaseRequest* purchaseRequest) override{if (purchaseRequest-getPrice()  5000 && purchaseRequest-getPrice() cout approver-processRequest(purchaseRequest);}}};//副校长class ViceSchoolMasterApprover :public Approver{public:explicit ViceSchoolMasterApprover(const string& name): Approver(name){}void processRequest(PurchaseRequest* purchaseRequest) override{if (purchaseRequest-getPrice()  10000 && purchaseRequest-getPrice() cout approver-processRequest(purchaseRequest);}}};//校长class SchoolMasterApprover :public Approver{public:explicit SchoolMasterApprover(const string& name): Approver(name){}void processRequest(PurchaseRequest* purchaseRequest) override{if (purchaseRequest-getPrice()  30000){cout approver-processRequest(purchaseRequest);}}};int main(int argc, char* argv[]){//创建一个请求PurchaseRequest* purchaseRequest = new PurchaseRequest(1, 1000, 1);//创建相关的审批人DepartmentApprover* department = new DepartmentApprover("张主任");CollegeApprover* college = new CollegeApprover("李院长");ViceSchoolMasterApprover* viceSchoolMaster = new ViceSchoolMasterApprover("王副校长");SchoolMasterApprover* schoolMaster = new SchoolMasterApprover("佟校长");//需要将各个审批级别的下一个人设置好(处理人构成一个环装就可以从任何一个人开始处理了)//否则必须从第一个处理人开始department-setApprover(college);college-setApprover(viceSchoolMaster);viceSchoolMaster-setApprover(schoolMaster);schoolMaster-setApprover(department);//开始处理请求viceSchoolMaster-processRequest(purchaseRequest);return 0;}public:    Iterator() {};    virtual ~Iterator() {};    virtual string First() = 0;    virtual string Next() = 0;    virtual string CurrentItem() = 0;    virtual bool IsDone() = 0;};//聚集抽象类class Aggregate{public:    virtual int Count() = 0;    virtual void Push(const string& strValue) = 0;    virtual string Pop(const int nIndex) = 0;    virtual Iterator* CreateIterator() = 0;};//具体迭代器类，继承Iterator 实现开始、下一个、是否结尾、当前对象等方法class ConcreteIterator : public Iterator{public:    ConcreteIterator(Aggregate* pAggregate) :m_nCurrent(0), Iterator()    {        m_Aggregate = pAggregate;    }    string First()    {        return m_Aggregate-Pop(0);    }    string Next()    {        string strRet;        m_nCurrent++;        if (m_nCurrent