【设计模式】结构型模式基础

结构型模式

系列综述：
来源：该系列是主要参考《大话设计模式》和《设计模式(可复用面向对象软件的基础)》，其他详细知识点拷验来自于各大平台大佬的博客。
总结：设计模式汇总篇
如果对你有用，希望关注·点赞·收藏一波。

---

---

😊点此到文末惊喜↩︎

---

结构型模式

适配器模式

1. 核心：将适配者类接口（源接口）通过（适配器）成目标类接口（目标接口），从而满足用户需求
   • 目标接口（Target）：客户期待的接口，定义客户端使用的接口。
   • 源接口（Adaptee）：需要被适配的接口或类。
   • 适配器（Adapter）：以组合的方式获取类的源接口对象，然会对该接口对象功能现接口的转换，将其转换为客户期待的接口。
2. 抽象原理
   • 适配器类（Adapter）继承目标接口，以组合的形式获取源接口类对象指针（Adaptee），
3. 模式分类
   • 类适配器模式：适配器继承自已有的对象，同时实现目标接口，通过重写目标接口的方法，将源接口的方法进行转换。
   • 对象适配器模式：适配器持有已有的对象，同时实现目标接口，通过调用已有对象方法将源接口的方法进行转换。
     
4. 优点
   • 符合开放封闭原则：可以通过对已有接口的拓展，从而避免对源接口内部的更改
5. 缺点
   • 增加系统中类的数量，增加了系统复杂度
   • 适配器在进行转换过程中会产生额外的开销
6. 示例代码

   // 对象适配器模式
   #include <iostream>
   #include <string>
   // 源接口类
   class Adaptee {
   public:
       void specificRequest() {
           std::cout << "Adaptee::specificRequest" << std::endl;
       }
   };
   
   // 目标接口类
   class Target {
   public:
       virtual ~Target() {}
       virtual void request() = 0;
   };
   // 适配器类：继承目标接口类，以组合的形式获取源接口类
   class Adapter : public Target {
   public:
       Adapter(Adaptee* adaptee) : adaptee_(adaptee) {}
       virtual void request() {
       	cout << "request ";
           adaptee_->specificRequest();
       }
   private:
       Adaptee* adaptee_;// 源接口类对象
   };
   
   int main() {
       Adaptee* adaptee = new Adaptee();		// 源接口对象
       Target* target = new Adapter(adaptee);	// 多态调用
       target->request();
   	// 释放对象
       delete target;
       delete adaptee;
       
       return 0;
   }
   
   

---

代理模式

1. 定义
   • 为其他对象提供一种代理以控制对这个对象的访问。
   • 代理模式的本质是⼀个中间件，主要⽬的是解耦合服务提供者和使⽤者。使⽤者通过代理间接的访问服务提供者，便于后者的封装和控制。是⼀种结构性模式。
   • 当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，所访问的真实对象与代理对象需要实现相同的接口。
2. 使用场景
   • 远程代理：一个对象在不同的地址空间提供的局部代表，可以隐藏一个对象存在于不同地址空间的事实
   • 虚拟代理：根据需要创建开销很大的对象，通过它来存放实例化需要很长时间的真实对象
   • 安全代理：用来控制真实对象访问时的权限
   • 智能代理：当调用真实对象的时候，代理可以处理另外一些事情。
3. 抽象原理
   • 抽象主体类（Subject）：定义了产品的基本接口，描述了产品的主要特性和功能。
   • 真实主体类（Real Subjec）：用来真正完成业务服务功能；
   • 代理类（Proxy）：以组合的方式将真实主体类对象作为类成员，通过重写功能函数并调用真实主体类对象的对应功能，实现代理功能。
4. 优点
   • 符合单一职责原则：隐藏真实的功能对象实例，而其他非核心功能由代理类负责处理，并将接口暴露给客户端调用。
   • 符合开闭原则：对代理的拓展开放，对真实主体的改动封闭。可以保护真实主体的数据和功能调用
5. 作用
   • 远程代理：位于两个不同地址空间对象的访问提供了一种实现机制，可以将一些消耗资源较多的对象和操作移至性能更好的计算机上，提高系统的整体运行效率。
   • 虚拟代理：通过一个消耗资源较少的对象来代表一个消耗资源较多的对象，可以在一定程度上节省系统的运行开销。
   • 缓冲代理：为某一个操作的结果提供临时的缓存存储空间，以便在后续使用中能够共享这些结果，优化系统性能，缩短执行时间。
   • 保护代理：可以控制对一个对象的访问权限，为不同用户提供不同级别的使用权限。
6. 缺点
   • 增大开销：代理类会增加系统开销，降低请求的处理速度

7. #include <iostream>
   #include <string>
   // 抽象主题
   class Subject {
   public:
       virtual void request() = 0;
   };
   // 具体主题
   class RealSubject : public Subject {
   public:
       void request() override {
           std::cout << "RealSubject: Handling request." << std::endl;
       }
   };
   // 代理
   class Proxy : public Subject {
   public:
       Proxy(Subject* real_subject) : real_subject_(real_subject) {}
       void request() override {
           if (checkAccess()) {	// 资质核验
               real_subject_->request();
               logAccess();		// 日志记录 
           }
       }
   private:
       bool checkAccess() {
           std::cout << "Proxy: Checking access prior to firing a real request." << std::endl;
           // 检查访问权限
           return true;
       }
       void logAccess() {
           std::cout << "Proxy: Logging the time of request." << std::endl;
           // 记录访问日志
       }
       Subject* real_subject_;		// 真正主体类对象
   };
   int main() {
       // 创建具体主题和代理
       Subject* real_subject = new RealSubject;
       Proxy* proxy = new Proxy(real_subject);
       // 通过代理访问具体主题
       proxy->request();
       // 释放内存
       delete real_subject;
       delete proxy;
       return 0;
   }
   
   

组合模式

1. 定义
   • 树形层次结构：将对象组合成树形结构来表示具有层次关系的整体-部分关系
   • 使用一致性：用户对单个对象和组合对象的处理具有一致性
2. 抽象原理
   • 抽象组件（Component）：定义叶子节点和枝节点的通用接口的抽象类/接口，包含子节点的管理方法，如增删改查等。
   • 叶子节点（Leaf）：叶子节点没有子节点，实现了组件接口的方法。
   • 树枝节点（Composite）：由一个或多个叶子节点组成，实现了组件接口的方法
3. 两种实现方式
   • 透明方式（通常更好）：叶节点类和枝节点类具备完全一致的行为接口，可能出现无意义接口函数，但是可以统一调用方式
   • 安全方式：叶节点类和枝节点类各自实现自己的形为接口，用户调用需要进行相应的判断
4. 代码

#include <iostream>
#include <vector>

class Component {
public:
    virtual void operation() = 0;
    virtual void add(Component* component) {}
    virtual void remove(Component* component) {}
};

class Leaf : public Component {
public:
    void operation() override {
        std::cout << "Leaf operation" << std::endl;
    }
};

class Composite : public Component {
public:
    void operation() override {
        std::cout << "Composite operation" << std::endl;
        for (Component* component : components) {
            component->operation();
        }
    }

    void add(Component* component) override {
        components.push_back(component);
    }

    void remove(Component* component) override {
        // Find and remove the component
        for (auto it = components.begin(); it != components.end(); ++it) {
            if (*it == component) {
                components.erase(it);
                break;
            }
        }
    }

private:
    std::vector<Component*> components;
};

int main() {
    Component* root = new Composite();
    Component* leaf1 = new Leaf();
    Component* leaf2 = new Leaf();

    root->add(leaf1);
    root->add(leaf2);

    Component* subComposite = new Composite();
    Component* leaf3 = new Leaf();
    Component* leaf4 = new Leaf();

    subComposite->add(leaf3);
    subComposite->add(leaf4);

    root->add(subComposite);

    root->operation();

    delete root;
    delete leaf1;
    delete leaf2;
    delete subComposite;
    delete leaf3;
    delete leaf4;

    return 0;
}

---

少年，我观你骨骼清奇，颖悟绝伦，必成人中龙凤。 秘籍（点击图中书籍）·有缘·赠予你

---

🚩点此跳转到首行↩︎

参考博客

1. 适配器模式
2. 设计模式（四）——搞懂什么是代理模式
3. 适配器模式
4. c++设计模式：代理模式
5. 代理模式
6. 待定引用
7. 待定引用
8. 待定引用