C++设计模式外观模式(复杂系统的对外的API)

谁践踏了优雅 2022-09-14 09:52 11阅读 0赞

### 文章目录 ###

*  1. 理论基础
 *  2. 模板代码
 *  3. 应用
 *   *  3.1 基金操作

**什么时候使用外观模式好呢?**

1.  首先在设计初期, 应该要有意识的将不同的两层进行分离, 比如经典三层架构, 就需要考虑数据访问层和业务逻辑层, 表示层的层与层之间建立外观facede, 这样可以为复杂的子系统提供一个简单地接口, 使得耦合大大降低
2.  其次, 开发阶段, 子系统往往因为不断重构演化而变得越来越复杂, 大多数的模式使用都会产生很多很小的类, 这本是好事情, 但是也给外部调用的客户带来了使用的困难, 因此增加外观Facede, 可以提供一个简单地接口, 减少他们的依赖
3.  最后, 维护一个遗留的大型系统时, 可能这个系统已经非常难以维护和扩展了, 但因为他们包含了非常重要的功能, 新的需求开发必须依赖他们, 这时候外观模式facede就非常合适了, 可以为新系统开发一个外观facede类, 来提供设计粗糙或者高度复杂的遗留代码的比较清晰的简单接口, 让新系统与这个facede对象交互, facede与遗留代码交互所有复杂的工作  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16]

# 1. 理论基础 #

**外观模式:**  
为子系统中的一组接口提供一个一致的界面, 此模式定义了一个高层接口, 这个接口使得这一子系统更加容易使用

**主要解决：**  
降低访问复杂系统的内部子系统时的复杂度，简化客户端之间的接口。

**何时使用：**

*  客户端不需要知道系统内部的复杂联系，整个系统只需提供一个"接待员"即可。
 *  定义系统的入口。

**如何解决：**  
客户端不与系统耦合，外观类与系统耦合。

**关键代码：**  
在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。

**应用实例：**  
1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。  
2、标准三层开发模式。  
3、想要炒股缺不太清除里面的门道, 因此选择基金进行炒股, 也就是找个搭理人(基金经理)来操控, 我只需要知道基金的买进卖出就行了(下文有代码实现)

**优点：**  
1、减少系统相互依赖。  
2、提高灵活性。  
3、提高了安全性。

**缺点：**  
不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。

**使用场景：**  
1、为复杂的模块或子系统提供外界访问的模块。  
2、子系统相对独立。  
3、预防低水平人员带来的风险。

**注意事项：**  
在层次化结构中，可以使用外观模式定义系统中每一层的入口。

# 2. 模板代码 #

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

// 子系统类
    class SubSystem1{ 
    public:
        void methodOne(){ 
            cout << "子系统方法 一" <<endl;
        }
    };
    
    class SubSystem2{ 
        public:
        void methodTow(){ 
            cout << "子系统方法 二" <<endl;
        }
    };
    
    
    class SubSystem3{ 
        public:
        void methodThree(){ 
            cout << "子系统方法 三" <<endl;
        }
    };
    
    class SubSystem4{ 
        public:
        void methodFour(){ 
            cout << "子系统方法 四" <<endl;
        }
    };
    
    // 外观类, 
    class Facede{ 
    private:
        SubSystem1 *one = nullptr;
        SubSystem2 *two = nullptr;
        SubSystem3 *three = nullptr;
        SubSystem4 *four = nullptr;
    public:
        Facede(){ 
            one = new SubSystem1();
            two = new SubSystem2();
            three = new SubSystem3();
            four = new SubSystem4();
        }
        ~Facede(){ 
            if(one != nullptr) delete one;
            if(two != nullptr) delete two;
            if(three != nullptr) delete three;
            if(four != nullptr) delete four;
        }
        
        void methodA(){ 
            cout << "方法组A() ..." <<endl;
            one->methodOne();
            two->methodTow();
            four->methodFour();
            three->methodThree();
        }
        void methodB(){ 
            cout << "方法组B() ..." <<endl;
            one->methodOne();
            four->methodFour();
            three->methodThree();
            two->methodTow();
        }
    };
    
    
    
    int main(int argc, char const *argv[]){ 
        Facede *facede = new Facede();
        facede->methodA(); // 由于facede的作用, 客户端根本不知道三个子系统类的存在
    
        delete facede;
        return 0;
    }
    /* 方法组A() ... 子系统方法 一 子系统方法 二 子系统方法 四 子系统方法 三 */

# 3. 应用 #

## 3.1 基金操作 ##

该应用不仅涉及到了外观模式的相关知识,  
同时也涵盖多态的使用事项, 比如**基类的析构函数设置为虚函数**  
还有**对象数组的构建, 初始化, 以及回收内存的方式**

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

class Stocks{ 
    public:
        virtual ~Stocks(){ } 
        // 注意基类的析构函数设置为虚函数, 才能在多态过程中回收派生类的内存空间,
        // 这是因为父类指针指向子类对象时， 回收父类指针， 
        // 会根据多态virtual虚函数指针找到父类虚函数(析构函数), 才能匹配到子类的析构函数
        virtual void Sell(){ }
        virtual void Buy(){ }
        // 纯虚函数是无法实例化, 所以这里定义称为虚函数即可
        // virtual void Sell() = 0;
        // virtual void Buy() = 0;
    };
    
    // 股票1
    class Stock1 : public Stocks{ 
    public:
        ~Stock1(){ 
            cout << "回收了.. ." <<endl;
        }
        void Sell(){ 
            cout << "股票1 卖出" <<endl;
        }
        void Buy(){ 
            cout << "股票1 买进" <<endl;
        }
    };
    
    
    // 股票2
    class Stock2 : public Stocks{ 
    public:
        void Sell(){ 
            cout << "股票2 卖出" <<endl;
        }
        void Buy(){ 
            cout << "股票2 买进" <<endl;
        }
    };
    
    // 股票3
    class Stock3 : public Stocks{ 
    public:
        void Sell(){ 
            cout << "股票3 卖出" <<endl;
        }
        void Buy(){ 
            cout << "股票3 买进" <<endl;
        }
    };
    
    // 国债1
    class NationalDebt1 : public Stocks{ 
    public:
        void Sell(){ 
            cout << "国债1 卖出" <<endl;
        }
        void Buy(){ 
            cout << "国债1 买进" <<endl;
        }
    };
    
    // 房地产1
    class Realty1 : public Stocks{ 
    public:
        void Sell(){ 
            cout << "房地产1 卖出" <<endl;
        }
        void Buy(){ 
            cout << "房地产1 买进" <<endl;
        }
    };
    
    // facede 外观模式类, 这样用户就不用知道基金中包含了哪些股票等信息, 只需要买进卖出就行了
    class Fund{ 
    private:
        // Stocks *stocks = new Stocks[5](); // 带括号, 数组内容是指向对象的指针
        Stocks *stocks[5]; 
    public:
        Fund(){ 
            stocks[0] = new Stock1();
            stocks[1] = new Stock2();
            stocks[2] = new Stock3();
            stocks[3] = new NationalDebt1();
            stocks[4] = new Realty1();
        }
    
        ~Fund(){ 
            cout << "回收fund使用的内存" <<endl;
            // delete []stocks; // 这是回收实例数组的, 即数组中保存的是实例
            for(int i=0; i<5; i++){ 
                delete stocks[i]; // 根据数组中的指针, 进行回收内存
            }
        }
    
        void BuyFund(){ 
            for(int i=0; i<5; i++){ 
                stocks[i]->Buy();
            }
            cout << "买进基金完成 ... \n" << endl;
        }
    
        void SellFund(){ 
            for(int i=0; i<5; i++){ 
                stocks[i]->Sell();
            }
            cout << "卖出基金完成 ... \n" << endl;
        }
    
    };
    
    int main(int argc, char const *argv[]){ 
        Fund *f1 = new Fund();
        f1->BuyFund();
        f1->SellFund();
    
        delete f1;
        return 0;
    }
    /* 股票1 买进 股票2 买进 股票3 买进 国债1 买进 房地产1 买进 买进基金完成 ... 股票1 卖出 股票2 卖出 股票3 卖出 国债1 卖出 房地产1 卖出 卖出基金完成 ... 回收fund使用的内存 回收了.. . */

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/fef667ea52874a8abc1a40192d584104.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/f3160c94d4004e0daf60f2480c7e2245.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6JC95a2Q5peg5oKUIQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/dd1e83ce76544e56b12e2170c301fe4b.png