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

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

news 2025/4/26 2:21:35

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.mrgr.cn/news/44198.html

相关文章：

  • 【前端】-音乐播放器（源代码和结构讲解，大家可以将自己喜欢的歌曲添加到数据当中，js实现页面动态显示音乐）
  • expressjs，MySQL，实现分页查询接口
  • Vue - 打包部署
  • 如何避免任务延误：从原因到策略的全面解析
  • 18448 最小生成树
  • 使用树莓派搭建音乐服务器
  • AI配音（声音克隆）
  • Windows搭建RTMP服务器
  • 排队打水(贪心)
  • 使用frp将树莓派穿透到外网
  • MySQL 实验 7：索引的操作
  • TypeScript：装饰器
  • springboot文件上传（阿里云oss）
  • 重学SpringBoot3-集成Redis（三）之注解缓存策略设置
  • PPPoE协议个人理解+报文示例+典型配置-RFC2516
  • 制作离线版Koczkatamas工具包
  • C++模版SFIANE应用踩的一个小坑
  • Redis Stack十部曲之五：管理Redis
  • Android 组件化利器：WMRouter 与 DRouter 的选择与实践
  • 系统架构设计师论文《论SOA在企业集成架构设计中的应用》精选试读