自学内容网 自学内容网
自学内容网 > 正文

【GeekBand】C++设计模式笔记6_Decorator_装饰模式

🕗 发布于 2024-10-07 01:10 c++  设计模式  

1. “单一职责”模式

  • 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。
  • 典型模式
    • Decorator
    • Bridge

2. Decorator 装饰模式

2.1 动机（Motivation）

  • 在某些情况下我们可能会 “过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。
  • 如何使 “对象功能的扩展” 能够根据需要来动态地实现？同时避免 “扩展功能的增多” 带来的子类膨胀问题？从而使得任何 “功能扩展变化” 所导致的影响降为最低？

2.2 模式定义

动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator 模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）。
——《设计模式》GoF

2.3 实例代码

2.3.1 decorator1
// 流基类
class Stream {
public:
// 纯虚函数
    virtual char Read(int number) = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(char data) = 0;
    
    // 析构函数
    virtual ~Stream() {}
    
};

/******************** 主体类 ********************/
// 文件流类
class FileStream : public Stream {
public:
    virtual char Read(int number) {
        // 读文件流
    }
    
    virtual void Seek(int position) {
        // 定位文件流
    }
    
    virtual void Write(char data) {
        // 写文件流
    }
    
};

// 网络流类
class NetworkStream : public Stream {
public:
    virtual char Read(int number) {
        // 读网络流
    }
    
    virtual void Seek(int position) {
        // 定位网络流
    }
    
    virtual void Write(char data) {
        // 写网络流
    }
    
};

// 内存流类
class MemoryStream : public Stream {
public:
    virtual char Read(int number) {
        // 读内存流
    }
    
    virtual void Seek(int position) {
        // 定位内存流
    }
    
    virtual void Write(char data) {
        // 写内存流
    }
    
};

/******************** 扩展操作 ********************/
// 加密文件流类，继承文件流类
class CryptoFileStream : public FileStream {
public:
    virtual char Read(int number) { 
        // 额外的加密操作...
        FileStream::Read(number);// 读文件流，调用父类函数
    }
    
    virtual void Seek(int position) {
        // 额外的加密操作...
        FileStream::Seek(position);// 定位文件流，调用父类函数
        // 额外的加密操作...
    }
    
    virtual void Write(byte data) {
        // 额外的加密操作...
        FileStream::Write(data);// 写文件流，调用父类函数
        // 额外的加密操作...
    }
};

// 加密网络流类，继承网络流类
class CryptoNetworkStream : public NetworkStream {
public:
    virtual char Read(int number) {  
        // 额外的加密操作...
        NetworkStream::Read(number);// 读网络流，调用父类函数
    }
    
    virtual void Seek(int position) {
        // 额外的加密操作...
        NetworkStream::Seek(position);// 定位网络流，调用父类函数
        // 额外的加密操作...
    }
    
    virtual void Write(byte data) {
        // 额外的加密操作...
        NetworkStream::Write(data);// 写网络流，调用父类函数
        // 额外的加密操作...
    }
};

// 加密内存流类，继承内存流类
class CryptoMemoryStream : public MemoryStream {
public:
    virtual char Read(int number) {
        // 额外的加密操作...
        MemoryStream::Read(number);// 读内存流，调用父类函数
    }
    
    virtual void Seek(int position) {
        // 额外的加密操作...
        MemoryStream::Seek(position);// 定位内存流，调用父类函数
        // 额外的加密操作...
    }
    
    virtual void Write(byte data) {
        // 额外的加密操作...
        MemoryStream::Write(data);// 写内存流，调用父类函数
        // 额外的加密操作...
    }
};

// 缓存文件流类
class BufferedFileStream : public FileStream {
    // ...
};

// 缓存网络流类
class BufferedNetworkStream : public NetworkStream {
    // ...
};

// 缓存内存流类
class BufferedMemoryStream : public MemoryStream {
    // ...
}

// 加密缓存文件流类，继承文件流
class CryptoBufferedFileStream : public FileStream {
public:
    virtual char Read(int number) {
        // 额外的加密操作...
        // 额外的缓冲操作...
        FileStream::Read(number);// 读文件流
    }
    
    virtual void Seek(int position) {
        // 额外的加密操作...
        // 额外的缓冲操作...
        FileStream::Seek(position);// 定位文件流
        // 额外的加密操作...
        // 额外的缓冲操作...
    }
    
    virtual void Write(byte data) {
        // 额外的加密操作...
        // 额外的缓冲操作...
        FileStream::Write(data);// 写文件流
        // 额外的加密操作...
        // 额外的缓冲操作...
    }
};

void Process() {
    // 编译时装配，在编译时就确定具体的类型
    CryptoFileStream *fs1 = new CryptoFileStream();

    BufferedFileStream *fs2 = new BufferedFileStream();

    CryptoBufferedFileStream *fs3 = new CryptoBufferedFileStream();

}
2.3.2 decorator2
// 流基类
class Stream {
public:
// 纯虚函数
    virtual char Read(int number) = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(char data) = 0;
    
    // 析构函数
    virtual ~Stream() {}
    
};

/******************** 主体类 ********************/
// 文件流类
class FileStream : public Stream {
public:
    virtual char Read(int number) {
        // 读文件流
    }
    
    virtual void Seek(int position) {
        // 定位文件流
    }
    
    virtual void Write(char data) {
        // 写文件流
    }
};

// 网络流类
class NetworkStream : public Stream {
public:
    virtual char Read(int number) {
        // 读网络流
    }
    
    virtual void Seek(int position) {
        // 定位网络流
    }
    
    virtual void Write(char data) {
        // 写网络流
    }
};

// 内存流类
class MemoryStream : public Stream {
public:
    virtual char Read(int number) {
        // 读内存流
    }
    
    virtual void Seek(int position) {
        // 定位内存流
    }
    
    virtual void Write(char data) {
        // 写内存流
    }
};

/******************** 扩展操作 ********************/
// 加密流类
class CryptoStream : public Stream {

    Stream* stream;// ...组合形式，Stream是个抽象类，不是一个具体的类

public:
// 构造函数
    CryptoStream(Stream* stm) : stream(stm) {
    
    }
    
    virtual char Read(int number) {
        // 额外的加密操作...
        stream->Read(number);// 读流
    }
    virtual void Seek(int position) {
        // 额外的加密操作...
        stream->Seek(position);// 定位流
        // 额外的加密操作...
    }
    virtual void Write(byte data) {
        // 额外的加密操作...
        stream->Write(data);// 写流
        // 额外的加密操作...
    }
};

// 缓冲流类
class BufferedStream : public Stream {
    
    Stream* stream;// ...组合形式
    
public:
    BufferedStream(Stream* stm) : stream(stm) {
        
    }
    //...
};

void Process() {

    // 运行时装配，在运行时才确认具体类型
    FileStream* s1 = new FileStream();
    CryptoStream* s2 = new CryptoStream(s1);// s2中的stream绑定FileStream类型
    
    BufferedStream* s3 = new BufferedStream(s1);// s3中的stream绑定FileStream类型
    
    BufferedStream* s4 = new BufferedStream(s2);// s4中的stream绑定CryptoStream类型
}
2.3.3 decorator3
// 流基类
class Stream {
public:
// 纯虚函数
    virtual char Read(int number) = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(char data) = 0;
    
    // 析构函数
    virtual ~Stream() {}
};

/******************** 主体类 ********************/
// 文件流类
class FileStream: public Stream {
public:
    virtual char Read(int number) {
        // 读文件流
    }
    
    virtual void Seek(int position) {
        // 定位文件流
    }
    
    virtual void Write(char data) {
        // 写文件流
    }

};

// 网络流类
class NetworkStream : public Stream {
public:
    virtual char Read(int number) {
        // 读网络流
    }
    
    virtual void Seek(int position) {
        // 定位网络流
    }
    
    virtual void Write(char data) {
        // 写网络流
    }
};

// 内存流类
class MemoryStream : public Stream {
public:
    virtual char Read(int number) {
        // 读内存流
    }
    
    virtual void Seek(int position) {
        // 定位内存流
    }
    
    virtual void Write(char data) {
        // 写内存流
    }
};

/******************** 扩展操作 ********************/
// 装饰器流类
DecoratorStream : public Stream {
protected:
    Stream* stream;// ...组合形式，Stream是个抽象类，不是一个具体的类
    
    // 构造函数
    DecoratorStream(Stream * stm) : stream(stm) {
    
    }  
};

// 加密流类，继承装饰器流类
class CryptoStream : public DecoratorStream {
public:
// 构造函数，调用父类的构造函数
    CryptoStream(Stream* stm) : DecoratorStream(stm) {
    
    }
    
    virtual char Read(int number) {   
        // 额外的加密操作...
        stream->Read(number);// 读流
    }
    
    virtual void Seek(int position) {
        // 额外的加密操作...
        stream->Seek(position);// 定位流
        // 额外的加密操作...
    }
    
    virtual void Write(byte data) {
        // 额外的加密操作...
        stream->Write(data);// 写流
        // 额外的加密操作...
    }
};

// 缓冲流类，继承装饰器流类
class BufferedStream : public DecoratorStream {
public:
// 构造函数，调用父类的构造函数
    BufferedStream(Stream* stm): DecoratorStream(stm) {
        
    }
    
    // ...
};

void Process(){

    // 运行时装配
    FileStream* s1 = new FileStream();
    
    CryptoStream* s2 = new CryptoStream(s1);
    
    BufferedStream* s3 = new BufferedStream(s1);
    
    BufferedStream* s4 = new BufferedStream(s2);
}

2.4 结构（Structure）

在这里插入图片描述

2.5 要点总结

  • 通过采用组合而非继承的手法，Decorator 模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的 “灵活性差” 和 “多子类衍生问题”。
  • Decorator 类在接口上表现为is-a Component 的继承关系，即 Decorator 类继承了 Component 类所具有的接口。但在实现上又表现为has-a Component 的组合关系，即 Decorator 类又使用了另外一个 Component 类。
  • Decorator 模式的目的并非解决 “多子类衍生的多继承” 问题，Decorator 模式应用的要点在于解决 “主体类在多个方向上的扩展功能” —— 是为 “装饰” 的含义。

原文地址：https://blog.csdn.net/qq_38154295/article/details/142729860

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

相关文章

  • 职场人生之节日

    为什么要把节日拿出来写篇文章尼，因为上了班之后，过节就不再是普通的过节了，尤其是国庆春节这种大假期，我只能评价是八仙过海，各显神通了，这一点说的不是送礼，我说的是工作，如果你在本地，但是不想加班，那就

    阅读更多2024-10-07
  • 网盘能否作为FTP替代产品？企业该如何进行FTP国产化替代？

    飞驰云联是中国领先的数据安全传输解决方案提供商，长期专注于安全可控、性能卓越的数据传输技术和解决方案，公司产品和方案覆盖了跨网跨区域的数据安全交换、供应链数据安全传输、数据传输过程的防泄漏、FTP的增

    阅读更多2024-10-07
  • 栈和队列--DS

    队列是只允许在一端进行插入操作，在另一端进行数据删除操作的特殊线性表。队列中允许进行插入操作的一端称为队尾(Tail/Rear),进行数据删除操作的一端称为队头(Head/Front)

    阅读更多2024-10-07
  • SpringTask的学习

    域，由空格分隔开，每个域代表一个含义每个域的含义分别为:秒、分钟、小时、日、月、周、年(可选)启动类添加注解 @EnableScheduling 开启任务调度。①导入maven坐标spring-con

    阅读更多2024-10-07
  • 什么是伪多态？在JavaScript当中显式伪多态和隐式伪多态指的是什么？

    显式伪多态 是在编程语言中通过非严格的多态性模拟多态行为的一种技术。在这种情况下，多态行为并不是通过经典的继承或接口机制实现的，而是通过一些显式的方法来模拟类似多态的效果。显式伪多态的核心在于程序员显

    阅读更多2024-10-07
  • Spring Task 调度任务

    从运行结果可以看出，spring启动后，程序每隔5秒钟定时执行了test方法。cron表达式是一种用于设置定时任务的语法规则。它由6个字段组成，分别表示。定时任务类：ScheduleTaskTest，

    阅读更多2024-10-07
  • 必须掌握的渗透测试工具

    most important web-application hacking tools:

    阅读更多2024-10-07
  • 股票历史行情数据源以及策略分享研究

    2. **策略构建**：基于ADX和MACD指标构建交易策略。可以构建或优化自己的股票量化回测策略，并深入理解策略的收益和风险特征。2. **策略构建**：设定不同周期的移动平均线，如5日、10日、2

    阅读更多2024-10-07
  • 弱网(不限于 Wi-Fi)环境的传输优化分析

    弱网传输优化一直是从顶会到会议室争论的焦点，但所出之策全都纯属屎上雕花，就好比在教你如何用五菱宏光在颠簸的乡道开出 120 码的时速一样，本身就是弱网，难以预测，若难以预测，两个办法，一就是不预测，二

    阅读更多2024-10-07
  • ArcGIS实战——一文教会你调整适合中国宝宝体质的标准地图投影参数

    各位要出图的小伙伴有没有遇到一个问题，当我们的研究区域是中国时，使用常见的WGS1984投影，会让我们的中国地图看起来不够挺拔，投影使得左右的拉伸比较长，进而让我们的中国地图变得不够美观。一切都完成之

    阅读更多2024-10-07
自学内容网
Copyright © 2015-2024