当前位置： 首页 > article >正文

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

article 2024/10/7 3:39:25

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 模式应用的要点在于解决 “主体类在多个方向上的扩展功能” —— 是为 “装饰” 的含义。

http://www.kler.cn/news/335457.html

相关文章：

  • EFCore postgresql 批量删除、插入、更新
  • Java - Spring框架 (ios+aop)
  • c基础面试题
  • 如何创建一个docker，给它命名，且下次重新打开它
  • 数据结构——List接口
  • SpringBoot中的数据库查询及Mybatis和MybatisPlus的使用
  • Windows环境 源码编译 FFmpeg
  • 828华为云征文｜部署开源超轻量中文OCR项目 TrWebOCR
  • JavaWeb的小结02
  • 【无人水面艇路径跟随控制2】（C++）USV代码阅读： SetOfLos 类的从路径点和里程计信息中计算期望航向
  • 数据结构：将复杂的现实问题简化为计算机可以理解和处理的形式
  • 530、二叉搜索树的最小绝对差
  • 2020大厂web前端面试常见问题总结
  • 计算机毕业设计 基于Python的人事管理系统的设计与实现 Python+Django+Vue 前后端分离 附源码 讲解 文档
  • 疾风大模型气象,基于气象数据打造可视化平台
  • SpringBoot框架下校园资料库的构建与优化
  • 鸿蒙开发（NEXT/API 12）【管理应用与Wear Engine服务的连接状态】手机侧应用开发
  • Go-Micro客户端请求报500错误的解决方法
  • 健康信息管理：SpringBoot的创新应用
  • 怎样用python+sqlalchemy获得mssql视图对应物理表关系(二)