C++设计模式基础和模式设计基本原则

爱被打了一巴掌 2022-11-18 01:25 182阅读 0赞

### 文章目录 ###

*  1. 模式
 *  2. 设计模式（Design pattern）
 *  3. 设计模式的分类
 *  4. 具体分类
 *   *  a. 创建型模式
     *   *  1. 工厂方法模式（Factory Method Pattern）用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中
         *  2. 抽象工厂模式（Abstract Factory Pattern）的意图是提供一个创建一系列相关或者相互依赖的接口，而无需指定它们具体的类。
         *  3. 建造者模式（Builder Pattern）的意图是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
         *  4. 原型模式（Prototype Pattern）是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
         *  5. 单例模式（Singleton Pattern）是保证一个类仅有一个实例，并提供一个访问它的全局访问点。
     *  d. 结构型模式
     *   *  6，代理模式（Proxy Pattern）就是为其他对象提供一种代理以控制对这个对象的访问。
         *  7，装饰者模式（Decorator Pattern）动态的给一个对象添加一些额外的职责。就增加功能来说，此模式比生成子类更为灵活。
         *  8，适配器模式（Adapter Pattern）是将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
         *  9，桥接模式（Bridge Pattern）是将抽象部分与实际部分分离，使它们都可以独立的变化。
         *  10，组合模式（Composite Pattern）是将对象组合成树形结构以表示“部分--整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。
         *  11，外观模式（Facade Pattern）是为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
         *  12，享元模式（Flyweight Pattern）是以共享的方式高效的支持大量的细粒度的对象。
     *  c. 行为型模式
     *   *  13，模板方法模式（Template Method Pattern）使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
         *  14，命令模式（Command Pattern）是将一个请求封装为一个对象，从而使你可用不同的请求对客户端进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
         *  15，责任链模式（Chain of Responsibility Pattern），在该模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。
         *  16，策略模式（Strategy Pattern）就是准备一组算法，并将每一个算法封装起来，使得它们可以互换。
         *  17，中介者模式（Mediator Pattern）就是定义一个中介对象来封装系列对象之间的交互。终结者使各个对象不需要显示的相互调用 ，从而使其耦合性松散，而且可以独立的改变他们之间的交互。
         *  18，观察者模式（Observer Pattern）定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
         *  19，备忘录模式（Memento Pattern）是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
         *  20，访问者模式（Visitor Pattern）就是表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
         *  21，状态模式（State Pattern）就是对象的行为，依赖于它所处的状态。
         *  22，解释器模式（Interpreter Pattern）就是描述了如何为简单的语言定义一个语法，如何在该语言中表示一个句子，以及如何解释这些句子。
         *  23，迭代器模式（Iterator Pattern）是提供了一种方法顺序来访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
 *  5. 设计模式基本原则
 *   *  a. 开放封闭原则 (OCP,Open For Extension, Closed For Modification Principle)
     *  b. 单一职责原则 (SRP,Single Responsibility Principle)
     *  c. 依赖倒置原则 (DIP,Dependence Inversion Principle)
     *  d. 接口隔离原则 (ISP,Interface Segegation Principle)
     *  e. 里氏替换原则 (LSP, Liskov Substitution Principle)
     *  f. 优先使用组合而不是继承原则(CARP,Composite/Aggregate Reuse Principle)
     *  g. 迪米特法则(LOD,Law of Demeter) 最少原则

# 1. 模式 #

在一定环境中解决某一问题的方案，包括三个基本元素–(问题,解决方案,环境)。  
即: 在一定环境下，用固定套路解决问题。

# 2. 设计模式（Design pattern） #

是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代 码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；  
设计模式是软件工程的基石脉络，如同大厦的结构一样。  
学习设计模式的意义  
提高职业素养，关注学员在行业内的长期发展。

# 3. 设计模式的分类 #

Gang of Four的“Design Patterns: Elements of Resualbel Software”书将设计模式归纳为三大类型，共23种。  
创建型模式 : 通常和对象的创建有关，涉及到对象实例化的方式。（共5种模式)  
结构型模式： 描述的是如何组合类和对象以获得更大的结构。(共7种模式)  
行为型模式： 用来对类或对象怎样交互和怎样分配职责进行描述。(共11种模式)

# 4. 具体分类 #

## a. 创建型模式 ##

用来处理对象的创建过程，主要包含以下5种设计模式：

### 1. 工厂方法模式（Factory Method Pattern）用意是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类中 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_16_color_FFFFFF_t_70_g_se_x_16]

### 2. 抽象工厂模式（Abstract Factory Pattern）的意图是提供一个创建一系列相关或者相互依赖的接口，而无需指定它们具体的类。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16]

### 3. 建造者模式（Builder Pattern）的意图是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]

### 4. 原型模式（Prototype Pattern）是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]

### 5. 单例模式（Singleton Pattern）是保证一个类仅有一个实例，并提供一个访问它的全局访问点。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_9_color_FFFFFF_t_70_g_se_x_16]

## d. 结构型模式 ##

用来处理类或者对象的组合，主要包含以下7种设计模式：

### 6，代理模式（Proxy Pattern）就是为其他对象提供一种代理以控制对这个对象的访问。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_15_color_FFFFFF_t_70_g_se_x_16]

### 7，装饰者模式（Decorator Pattern）动态的给一个对象添加一些额外的职责。就增加功能来说，此模式比生成子类更为灵活。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 3]

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

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 4]

### 9，桥接模式（Bridge Pattern）是将抽象部分与实际部分分离，使它们都可以独立的变化。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 5]

### 10，组合模式（Composite Pattern）是将对象组合成树形结构以表示“部分–整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 6]

### 11，外观模式（Facade Pattern）是为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 7]

### 12，享元模式（Flyweight Pattern）是以共享的方式高效的支持大量的细粒度的对象。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 8]

## c. 行为型模式 ##

用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：

### 13，模板方法模式（Template Method Pattern）使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 ###

![在这里插入图片描述][70f9550a56114f28a67e53cbed489a7d.png]

### 14，命令模式（Command Pattern）是将一个请求封装为一个对象，从而使你可用不同的请求对客户端进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 9]

### 15，责任链模式（Chain of Responsibility Pattern），在该模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_18_color_FFFFFF_t_70_g_se_x_16]

### 16，策略模式（Strategy Pattern）就是准备一组算法，并将每一个算法封装起来，使得它们可以互换。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 10]

### 17，中介者模式（Mediator Pattern）就是定义一个中介对象来封装系列对象之间的交互。终结者使各个对象不需要显示的相互调用 ，从而使其耦合性松散，而且可以独立的改变他们之间的交互。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 11]

### 18，观察者模式（Observer Pattern）定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_18_color_FFFFFF_t_70_g_se_x_16 1]

### 19，备忘录模式（Memento Pattern）是在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。 ###

![在这里插入图片描述][56cc81b86d634ea1b6076f86123eadaf.png]

### 20，访问者模式（Visitor Pattern）就是表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 12]

### 21，状态模式（State Pattern）就是对象的行为，依赖于它所处的状态。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 13]

### 22，解释器模式（Interpreter Pattern）就是描述了如何为简单的语言定义一个语法，如何在该语言中表示一个句子，以及如何解释这些句子。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 14]

### 23，迭代器模式（Iterator Pattern）是提供了一种方法顺序来访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 15]

# 5. 设计模式基本原则 #

最终目的：高内聚，低耦合

## a. 开放封闭原则 (OCP,Open For Extension, Closed For Modification Principle) ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70]

类的改动是通过增加代码进行的，而不是修改源代码。

#include <iostream>
    using namespace std;
    /* 1. 开闭原则， 对扩展开放， 对修改关闭 增加功能是通过代码实现， 而不是修改源代码 例如下文的计算器， 每个功能都是单独的类， 这样在扩展功能时， 就可以做到不动源代码增加 */
    
    // 反面案例
    // 计算器的计算方法， 当扩展取余等扩展运算， 不能重写函数
    
    // 写一个抽象类
    class AbstractCaculate{ 
    public:
        virtual void setOperatorNumber(int a, int b) = 0;
        virtual int getResult() = 0;
    };
    
    class PlusCaculate : public AbstractCaculate{ 
    private:
        int mA, mB;
    public:
        virtual void setOperatorNumber(int a, int b){ 
            this->mA = a;
            this->mB = b;
        }
        virtual int getResult(){ 
            return this->mA + this->mB;
        }
    };
    
    class MultiCaculate : public AbstractCaculate{ 
    private:
        int mA, mB;
    public:
        virtual void setOperatorNumber(int a, int b){ 
            this->mA = a;
            this->mB = b;
        } 
        virtual int getResult(){ 
            return this->mA * this->mB;
        }
    };
    
    // 如果需要给calculation增加功能, 只需要在下面在定义一个类, 实现新的功能即可
    
    int main(int argc, char const *argv[])
    { 
        AbstractCaculate* caculator = new PlusCaculate();
        caculator->setOperatorNumber(3,5);
        cout<< "res = "<<caculator->getResult()<<endl;
        delete caculator; // 注意每次新创建的new出来的对象, 一定要使用delete进行销毁
        
        return 0;
    }

## b. 单一职责原则 (SRP,Single Responsibility Principle) ##

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

## c. 依赖倒置原则 (DIP,Dependence Inversion Principle) ##

依赖于抽象(接口),不要依赖具体的实现(类)，也就是针对接口编程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 2]

// 04_依赖倒转原则.cpp
    #include <iostream>
    using namespace std;
    
    // 银行业务
    class AbstractWorker{ 
        public:
        virtual void doBussiness() = 0;
    };
    // 底层业务
    class doSaveWorker: public AbstractWorker{ 
        public:
        virtual void doBussiness(){ 
            cout<<"存款业务.."<<endl;
        }
    };
    class doPayWorker: public AbstractWorker{ 
        public:
        virtual void doBussiness(){ 
            cout<<"付款业务.."<<endl;
        }
    };
    
    class doTransferWorker: public AbstractWorker{ 
        public:
        virtual void doBussiness(){ 
            cout<<"转账业务"<<endl;
        }
    };
    
    // 中层业务, 具体实现就简单了
    void doNewBusiness(AbstractWorker* worker){ 
        worker->doBussiness();
    }
    
    int main(int argc, char const *argv[])
    { 
        // 类似于多态, 父类指向子类
        AbstractWorker* worker = new doTransferWorker();
        doNewBusiness(worker);
        delete worker; // 注意一定要把自己new的对象给delete了
        return 0;
    }

## d. 接口隔离原则 (ISP,Interface Segegation Principle) ##

不应该强迫客户的程序依赖他们不需要的接口方法。一个接口应该只提供一种对外功能，不应该把所有操作都封装到一个接口中去。  
下面的代码都是遵循这种接口隔离原则进行编写的

## e. 里氏替换原则 (LSP, Liskov Substitution Principle) ##

任何抽象类出现的地方都可以用他的实现类进行替换。实际就是虚拟机制，语言级别实现面向对象功能。

class Abstract{  // 抽象类, 只是定义功能, 但是不实现
    public:
        virtual void hello() = 0;
    };
    
    class B : public Abstract{ 
    public:
        virtual void hello(){ 
            // 具体实现
        }
    };

## f. 优先使用组合而不是继承原则(CARP,Composite/Aggregate Reuse Principle) ##

*  尽量使用合成/聚合, 尽量不要使用类继承
 *  如果使用继承，会导致父类的任何变换都可能影响到子类的行为。
 *  如果使用对象组合，就降低了这种依赖关系。
 *  聚合表示一种弱的拥有关系, 体现的是A对象可以包含B对象, 但是B对象不是A对象的一部分;
 *  合成则是一种强拥有, 体现严格的部分和整体的关系, 部分和整体的生命周期是一样的  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_12_color_FFFFFF_t_70_g_se_x_16]

我们来思考这样一样问题:   
当前是80年代, 各个手机厂商和手机软件系统还没有统一, 不同的手机品牌有不同的手机软件框架, 框架下有很多的软件, 这时候想要写一个类来**统一**这些问题, 应该怎么写?  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 16]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 17]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 18]

#include <iostream>
    #include <vector>
    using namespace std;
    class AbstractCar{ 
        public:
        virtual void run() = 0;
    };
    
    class Dazhong: public AbstractCar{ 
    private:
        
    public:
        virtual void run(){ 
            cout<<"大众出发, 迷茫的"<<endl;
        }
    };
    
    class Benchi: public AbstractCar{ 
    private:
        
    public:
        virtual void run(){ 
            cout<<"奔驰, 迷茫的"<<endl;
        }
    };
    
    class Person{ 
    private:
        AbstractCar* car;
    public:
        ~Person(){ 
            if(this->car != NULL){ 
                delete this->car;
            }
        }
        void setCar(AbstractCar* car){ 
            if(this->car != NULL){ 
                delete this->car;
                cout<<"这辆车已经归还.."<<endl;
            } // 防止上一辆车还没有归还, 就开另一辆了
            this->car = car;
        }
        void Doufeng(){ 
            this->car->run();
        }
    };
    
    // 继承和组合, 优先使用组合
    int main(int argc, char const *argv[])
    { 
        Person * p1 = new Person(); // 创建一个人
        p1->setCar(new Benchi()); // 这个人借了一辆车
        p1->Doufeng();  // 开着这辆车去兜风
        p1->setCar(new Dazhong()); // 在接一辆车, 同时上个车已经归还
        p1->Doufeng(); // 在去兜风
        delete p1; // 归还这个车删除这个人
    
        return 0;
    }

## g. 迪米特法则(LOD,Law of Demeter) 最少原则 ##

一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性。例如在一个程序中，各个模块之间相互调用时，通常会提供一个统一的接口来实现。这样其他模块不需要了解另外一个模块的内部实现细节，这样当一个模块内部的实现发生改变时，不会影响其他模块的使用。(黑盒原理)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 5]

#include <iostream>
    #include <vector>
    using namespace std;
    // 最少知识原则
    class AbstractBuilding{ 
    public:
        virtual string getQuality() = 0;
        virtual void sale() = 0;
    };
    
    class BuildingA: public AbstractBuilding{ 
    public:
        string mQulity;
        BuildingA(){ 
            mQulity = "高品质";
        }
        virtual void sale(){ 
            cout<<"楼盘A 售卖 "<<mQulity<<endl;
        }
        virtual string getQuality(){ 
            return mQulity;
        }
    };
    
    class BuildingB: public AbstractBuilding{ 
    public:
        string mQulity;
        BuildingB(){ 
            mQulity = "低品质";
        }
        virtual void sale(){ 
            cout<<"楼盘B 售卖 "<<mQulity<<endl;
        }
        virtual string getQuality(){ 
            return mQulity;
        }
    };
    
    // 中介类
    class Mediator{ 
    public:
        Mediator(){ 
            AbstractBuilding* bu = new BuildingA;
            buildings.push_back(bu);
            bu = new BuildingB;
            buildings.push_back(bu);
            bu = new BuildingB;
            buildings.push_back(bu);
        }
        ~Mediator(){ 
            for(vector<AbstractBuilding*>::iterator it = buildings.begin(); 
                it!=buildings.end(); it++){ 
                    if(*it!=NULL){ 
                        delete *it;
                    }
                }
        }
        vector<AbstractBuilding*> buildings;
        // 对外提供接口
        AbstractBuilding* findMyBu(string quality){ 
            for(vector<AbstractBuilding*>::iterator it = buildings.begin(); 
                it!=buildings.end(); it++){ 
                    if((*it)->getQuality() == quality){ 
                        return *it;
                    }else{ 
                        return NULL;
                    }
                }
        }
    };
    
    int main(int argc, char const *argv[])
    { 
        // BuildingA* build = new BuildingA();
        // if(build->mQulity == "高品质")
        // build->sale();
        // delete build;
        
        Mediator * Medi = new Mediator();
        AbstractBuilding* building = Medi->findMyBu("高品质");
        if(building == NULL){ 
            cout<<"没有高品质的房子了"<<endl;
        }else{ 
            building->sale();
        }
        return 0;
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_16_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/846a333c7c51448b82fbf0ea44ae1561.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/bf645f473b6f4309850e5a7cbc48c51e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20221022/b9c8d04c511e46a2b043ca307e5726b7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20221022/2ba3b5f71fd14c559e517f6c61fd57d6.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_9_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/d29b2fc94c2148b78baf06e78042a0db.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_15_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/184cb8fa3261436eab2025cc57a61ff3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20221022/7874a23524ee4af4be5cff51b5bf990b.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20221022/4c497e700b45484d81d4be9a90299aeb.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20221022/dab3c33b964041d5a27689ef432649ac.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20221022/2eacb4c322604e59abf9b573e1a71397.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20221022/7477125bf2d145fc8d231d9a1024efc5.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20221022/54c369f5ccbf4fffbf4088e9bfab92e4.png
[70f9550a56114f28a67e53cbed489a7d.png]: /images/20221022/9bd9dd9df4e04248b286865cc0197eed.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 9]: /images/20221022/9a40a0c08c0a42128889e57a6ad8b30a.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/1808dc8826b14f93b4647d40a4c0cc1f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 10]: /images/20221022/e9e750dc164e4771959e4ff24cae34d0.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 11]: /images/20221022/b7f0f66955814e928a57ed0a21c33ca5.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_18_color_FFFFFF_t_70_g_se_x_16 1]: /images/20221022/881a4f8642694a6d98d7d7eead409896.png
[56cc81b86d634ea1b6076f86123eadaf.png]: /images/20221022/b51b4f2717854d67b6946abe6d1d9299.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 12]: /images/20221022/b07ef00dc77a4623962e038e7bf6ac61.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 13]: /images/20221022/224f13f8a5ac433995f082670e388b34.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 14]: /images/20221022/6a7c9fd5df0640bd86ad36ba83710d90.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 15]: /images/20221022/909b014a0cc0489b89e70cddf04e9eb2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70]: /images/20221022/e69bb0e2759146e98ffdb4a7d96b43de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 1]: /images/20221022/d27ce736e30c45e6b98979fe261b13cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 2]: /images/20221022/b872318c8ae94f8f8f94a5050a6852ed.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_12_color_FFFFFF_t_70_g_se_x_16]: /images/20221022/abc2513fb2de41faabbff9145544f7f2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 16]: /images/20221022/50c302ce68bc4a609dde688eca8291b3.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 17]: /images/20221022/43f08cae90104cbea0c2b1fd3b97aaba.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 18]: /images/20221022/932efa6d39d6438cafb6de9d2b5b3426.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 3]: /images/20221022/2753a57b5e844214b6631db7c05e5687.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 4]: /images/20221022/16553fce240542038c75cea7057ffd83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDYwODE5_size_16_color_FFFFFF_t_70 5]: /images/20221022/4fc75cb37a3a44d0bdc0eba3fd3ee84a.png