第6节 装饰者模式(单一职责)

最新推荐文章于 2024-09-25 21:31:09 发布
最新推荐文章于 2024-09-25 21:31:09 发布
阅读量178 收藏
点赞数
分类专栏： C++ 设计模式 文章标签： c++ 编程语言 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongbaofeng1234/article/details/104797456
版权

一、单一职责模式概述

  1. 在软件设计中，如果职责划分不清晰，使用继承得到的结果往往随着需求的变化子类急剧膨胀，同时充斥着冗余的代码;
  2. 单一职责模式典型：装饰者模式、桥模式

二、装饰者模式动机

  1. 在某些情况下，我们可能会过度使用继承来扩展对象的功能，由于继承为类型的静态特性，使得这种扩展缺乏灵活性;
  2. 此外，随着子类的增多，各种子类的组合会导致更多子类的膨胀;
  3. 如何使得对象功能的扩展能够根据需要来动态实现？同时避免"扩展功能的增多"带来的子类膨胀问题，从而使得任何功能扩展变化的影响降到最低？

三、程序示例

我们打算做一些IO操作，设计一些关于流的库.

3.1 使用设计模式前

#include <stdio.h>

class Stream {                                        // 基类：定义流的一些基本操作
public:
    virtual char Read(int number)   = 0;              // 纯虚函数
    virtual void Seek(int position) = 0;
    virtual void Write(char data)   = 0;
    virtual ~Stream() {};                             // 养成良好的习惯，基类析构函数写成虚函数
};

// 主体类：文件流操作，继承自Stream
class FileStream : public Stream {
public:
    virtual char Read(int number)  {/* code... */ }   // 读取文件流
    virtual void Seek(int position){/* code... */ }   // 定位文件流
    virtual void Write(char data)  {/* code... */ }   // 写入文件流
};

// 主体类：网络流操作，继承自Stream
class NetworkStream :public Stream {
public:
    virtual char Read(int number)   {/* code... */ }   // 读取网络流
    virtual void Seek(int position) {/* code... */ }   // 定位网络流
    virtual void Write(char data)   {/* code... */ }   // 写入网络流
};

// 主体类：内存流操作，继承自Stream
class MemoryStream :public Stream {
public:
    virtual char Read(int number)   {/* code... */ }   // 读取内存流
    virtual void Seek(int position) {/* code... */ }   // 定位内存流
    virtual void Write(char data)   {/* code... */ }   // 写入内存流
};

// 现在考虑扩展操作，如果我们要对文件流进行加密
class CryptoFileStream :public FileStream {
public:
    virtual char Read(int number) {                     // 读取文件流
		//  额外的加密操作
		FileStream::Read(number);
    }  
    virtual void Seek(int position) {                   // 定位文件流
		//  额外的加密操作
		FileStream::Seek(position);
    }  
    virtual void Write(char 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(char 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(char data) {                     // 写入内存流
		//  额外的加密操作
		MemoryStream::Write(data);
    }
};

// 继续对FileStream进行扩展
class BufferedFileStream:public FileStream{ /* 额外的缓冲操作*/  };

// 对文件既有缓冲扩展又有加密扩展
class CryptoBufferedFileStream :public FileStream {     // 当然也可继承自BufferedFileStream
	// 额外的缓冲操作
	// 额外的加密操作
};

int main()
{
    // 使用设计模式前，发生的是编译时装配
    CryptoFileStream   *fs1 = new CryptoFileStream();
    BufferedFileStream *fs2 = new BufferedFileStream();
    CryptoBufferedFileStream *fs3 = new CryptoBufferedFileStream();

    /*codes to do something... */
    delete fs3;
    delete fs2;
    delete fs1;
    renturn 0;
}

3.2 问题分析

使用设计模式前，代码结构关系如下：

                                            Stream
	                                          ||
           FileStream                    NetworkStream                    MemoryStream
	          ||                              ||                               ||
        CryptoFileStream               CryptoNetworkStream             CryptoMemoryStream
       BufferedFileStream             BufferedNetworkStream           BufferedMemoryStream
    CryptoBufferedFileStream       CryptoBufferedNetworkStream      CryptoBufferedMemoryStream

假设扩展类型数量为N，操作种类为M，则在谁用设计模式前，类的总量为O(MN),当M/N数量较多时，类数量是很大的；另一方面，我们发现类代码里有很多重复冗余的操作.

我们是否能够把O(MN) 变为O(M+N)？在OOP设计原则里，提到，能够使用组合的方式我们尽量不适用继承，使用组合方式后是否能讲类数量变为O(M+N)？

3.3 使用装饰者模式

#include <stdio.h>

class Stream {                                        // 基类：定义流的一些基本操作
public:
    virtual char Read(int number)   = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(char data)   = 0;
    virtual ~Stream() {};                             // 养成良好的习惯，基类析构函数写成虚函数
};

// 主体类：文件流操作，继承自Stream
class FileStream : public Stream {
public:
    virtual char Read(int number)  {/* code... */ }   // 读取文件流
    virtual void Seek(int position){/* code... */ }   // 定位文件流
    virtual void Write(char data)  {/* code... */ }   // 写入文件流
};

// 主体类：网络流操作，继承自Stream
class NetworkStream :public Stream {
public:
    virtual char Read(int number)   {/* code... */ }   // 读取网络流
    virtual void Seek(int position) {/* code... */ }   // 定位网络流
    virtual void Write(char data)   {/* code... */ }   // 写入网络流
};

// 主体类：内存流操作，继承自Stream
class MemoryStream :public Stream {
public:
    virtual char Read(int number)   {/* code... */ }   // 读取内存流
    virtual void Seek(int position) {/* code... */ }   // 定位内存流
    virtual void Write(char data)   {/* code... */ }   // 写入内存流
};

class CryptoStream{
public:
    CryptoStream(Stream* stream) { this->m_stream = stream; }
public:
    virtual char Read(int number) {                     
		doCrypto();
		m_stream->Read(number);
    }
    virtual void Seek(int position) {                  
		doCrypto();
		m_stream->Seek(position);
    }
    virtual void Write(char data) {                     
		doCrypto();
		m_stream->Write(data);
    }
private:
    void doCrypto() {}
private:
    Stream* m_stream;                    // 编译时无关，运行时根据new的具体对象决定调用什么方法
};

class BufferedStream{
public:
    BufferedStream(Stream* stream){ this->m_stream = stream; }      
public:
    virtual char Read(int number) {                    
		doBuffered();
		m_stream->Read(number);
    }
    virtual void Seek(int position) {                  
		doBuffered();
		m_stream->Seek(position);
    }
    virtual void Write(char data) {                    
		doBuffered();
		m_stream->Write(data);
    }
private:
    void doBuffered() {}
private:
    Stream* m_stream;                                  // 编译时无关，运行时根据new的具体对象决定调用什么方法
};    

int main()
{
    // 使用设计模式后，类的数量变为加法关系，而不再是乘法关系(CryptoStream,BufferedStream)
    Stream         *s1 = new FileStream();
    CryptoStream   *s2 = new CryptoStream(s1);
    BufferedStream *s3 = new BufferedStream(s1);

    /*codes to do something... */
    delete s1; delete s2; delete s3;
    renturn 0;
}

3.4 总结分析

使用设计模式后，类的数量变为加法关系，而非乘法关系(CryptoStream,BufferedStream).

四、再思考

如何实现既加密、又缓存？

  • 上述代码s2和s3是相互分开的，相互直连没有联系，怎么实现交互？ 他们之间的共同点是？自然是基类了
  • 因此我们不仅需要在类中声明Stream对象，还需要继承该类，而且需要实现基类的虚函数，才能new出一个对象，不实现基类虚方法是不能构造对象的.
  • 此时，应用代码可以写成：
#include <stdio.h>

class Stream {                                        // 基类：定义流的一些基本操作
public:
    virtual char Read(int number)   = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(char data)   = 0;
    virtual ~Stream() {};                             // 养成良好的习惯，基类析构函数写成虚函数
};

// 主体类：文件流操作，继承自Stream
class FileStream : public Stream {
public:
    virtual char Read(int number)  {/* code... */ }   // 读取文件流
    virtual void Seek(int position){/* code... */ }   // 定位文件流
    virtual void Write(char data)  {/* code... */ }   // 写入文件流
};

// 主体类：网络流操作，继承自Stream
class NetworkStream :public Stream {
public:
    virtual char Read(int number)   {/* code... */ }   // 读取网络流
    virtual void Seek(int position) {/* code... */ }   // 定位网络流
    virtual void Write(char data)   {/* code... */ }   // 写入网络流
};

// 主体类：内存流操作，继承自Stream
class MemoryStream :public Stream {
public:
    virtual char Read(int number)   {/* code... */ }   // 读取内存流
    virtual void Seek(int position) {/* code... */ }   // 定位内存流
    virtual void Write(char data)   {/* code... */ }   // 写入内存流
};

class CryptoStream:public Stream{
public:
    CryptoStream(Stream* stream) { this->m_stream = stream; }
public:
    virtual char Read(int number) {                     
		doCrypto();
		m_stream->Read(number);
    }
    virtual void Seek(int position) {                  
		doCrypto();
		m_stream->Seek(position);
    }
    virtual void Write(char data) {                     
		doCrypto();
		m_stream->Write(data);
    }
private:
    void doCrypto() {}
private:
    Stream* m_stream;                    // 编译时无关，运行时根据new的具体对象决定调用什么方法
};

class BufferedStream:public Stream {
public:
    BufferedStream(Stream* stream){ this->m_stream = stream; }      
public:
    virtual char Read(int number) {                    
		doBuffered();
		m_stream->Read(number);
    }
    virtual void Seek(int position) {                  
		doBuffered();
		m_stream->Seek(position);
    }
    virtual void Write(char data) {                    
		doBuffered();
		m_stream->Write(data);
    }
private:
    void doBuffered() {}
private:
    Stream* m_stream;                    // 编译时无关，运行时根据new的具体对象决定调用什么方法
};    

int main()
{
    // 运行时装配
    Stream         *m1 = new FileStream();
    CryptoStream   *m2 = new CryptoStream(m1);
    BufferedStream *m3 = new BufferedStream(m2);        // m3既可以加密，又可以缓存
    delete s1; delete s2; delete s3;

    /*codes to do something... */
    delete s1; delete s2; delete s3;
    renturn 0;
}

五、 再再思考

CryptoStream和BufferedStream含有公共的部分m_stream,根据GOF的思想，含有的公共部分可以网上提，即可以将 Stream* m_stream 放在基类里，但是我们发现FileStream、NetworkStream、MemoryStream并不需要这个.由此，我们可以写个中间类，比如MidStream，如文中代码所述；此时，可以CryptoStream和BufferedStream让继承MidStream即可.

// 创建中间类,这里不做虚函数实现，也就无法创建对象
class MidStream:public Stream {
protected:
	Stream *m_stream;
};

六、要点总结

  1. 通过采用组合而非继承的手法，装饰者模式实现了在运行时动态扩展对象功能的呢理工，而且可以根据需要扩展多个功能，避免了使用继承带来的"灵活性差"和"多子类衍生问题".
  2. 装饰者类在接口上表现为IS-A的继承关系，但又在实现上表现为Has-A的组合关系;
  3. 装饰者模式的目的并非为了解决"多子类衍生的多继承"问题，而主要在于解决"主体类在多个方向上的扩展功能"——是为"装饰"的含义.
yangxianpku
关注
专栏目录
刘伟 《设计模式（第2版）》PPT.zip
05-15
SOLID代表单一职责原则（Single Responsibility Principle）、开闭原则（Open-Closed Principle）、里氏替换原则（Liskov Substitution Principle）、接口隔离原则（Interface Segregation Principle）和依赖倒置...
设计模式（三）—— 装饰者模式
热门推荐
平凡之路无尽路的博客
09-05 2万+
由于之前看的容易忘记，因此特记录下来，以便学习总结与更好理解，该系列博文也是第一次记录，所有有好多不完善之处请见谅与留言指出，如果有幸大家看到该博文，希望报以参考目的看浏览，如有错误之处，谢谢大家指出与留言。 一、咖啡馆订单系统项目 咖啡馆订单系统项目： 咖啡馆订单项目： 1）、咖啡种类：Espresso、ShortBlack（浓缩）、LongBlack、Decaf （无糖）（这些就...
第 6 章：程序设计与设计模式.zip
12-14
在"第 6 章：程序设计与设计模式"的学习中，你将有机会深入研究这些概念，通过实例学习如何在实际项目中应用它们。这包括如何通过设计模式改进代码结构，如何通过良好的程序设计原则提高代码质量，以及如何在团队...
深入浅出设计模式第一章中文.zip
05-20
2. 设计原则：包括开闭原则（Open-Closed Principle）、里氏替换原则（Liskov Substitution Principle）、依赖倒置原则（Dependency Inversion Principle）、单一职责原则（Single Responsibility Principle）、接口...
重学java的设计模式
05-09
1. 单一职责原则：一个类或方法应该只有一个引起它变化的原因。 2. 里氏替换原则：子类必须能够替换掉其父类，不影响程序的正确性。 3. 依赖倒置原则：依赖于抽象而不是具体实现，提高代码的可扩展性。 4. 接口隔离...
【ARM 嵌入式 C 入门及渐进26 -- 内敛函数和宏定义的区别】
CodingCos的博客
09-25 775
在 C 语言中，内联函数和宏定义都可以用来减少函数调用的开销和提高代码执行效率，但它们在许多方面存在显著区别。内联函数使用inline关键字定义。宏定义使用#define预处理指令。无类型检查：宏是文本替换，没有类型检查，可能导致类型错误。调试困难：宏替换在预处理阶段完成，难以在调试器中跟踪宏的行为。全局作用域：宏在定义后全局有效，可能引起命名冲突和作用域污染。维护复杂：宏替换简单但容易出错，逻辑复杂时难以维护。性能优化：宏是简单的文本替换，不涉及编译器优化。return 0;
pyqt瀑布流布局
weixin_54217201的博客
09-21 446
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 264
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 619
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 639
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
C++ 字符串中的第一个唯一字符 - 力扣（LeetCode）
SikJ_2020_0_24的博客
09-21 288
比如：假设str[1] = 'b ‘a’的ASCII码值是97，那么count[ str[ 1 ] - 'a' ],也就是count[ 1 ]对应的是b出现的次数。所以遍历一次字符串就可以得到每个ASCII码值出现的次数，在遍历一次字符串，第一个ASCII码值所对应计数数组的值为1，就是第一个只出现一次的字符。由于小写字母一共有26个，所以利用ASCII码值来创建一个整形数组count，来保存对应ASCII码值出现的次数。它的第一个不重复的字符，并返回它的索引。
C++-Primer-Plus：18 个重点笔记
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 750
虽然从理论上讲，前缀递增/递减操作符由于不需要保存操作前的值而可能更高效，但这种差异在现代C++编程实践中往往被编译器的优化所掩盖。因此，在选择使用前缀还是后缀操作符时，更应该关注的是代码的清晰性和可读性，而不是微小的效率差异。在大多数情况下，遵循团队的编码规范或个人的编码习惯即可。最后，对于C++ Primer这样的经典书籍来说，它可能更多地是从语言规范和实现原理的角度来讨论这个问题，而不是从实际应用中的性能差异出发。
c++ day06
yangh1231的博客
09-25 175
【代码】c++ day06。
C++—vector的常见接口与用法（正式进入STL）
GGbond665的博客
09-21 386
vector的常见接口与用法
C++如何进阶？ -- 整理一些学习资料
csdnzzt的博客
09-22 337
在学习完C++最基础的知识后，需要对C++有更近一步的认知。看门见山，首先贴出学习资料：侯捷老师的这几个视频是每个学习C++的人都应该仔细看几遍下来的，只看一遍是绝对记不住的具体来说必看的两本书，或者说，必看的两本书和一章节是STL源码剖析、Effective C++、深度探索C++对象模型第三章（虚函数）。而选看的两本书: More Effective C++、深度探索C++第三章以外的部分。
(c++)线程的创建、互斥锁的使用、线程数组
weixin_53112343的博客
09-20 259
但是线程可能在cpu分配的一个时间片中做不完10万次+1的操作，这时候cpu会被其他线程抢占，由于num1++不是一个原子操作（操作过程中可能会发生中断），导致++其实没有做完，所以num1的最终结果会小于100万。2.创建10个线程，每个线程都做10万次全局变量num2++操作，与前者不同的是，这次对num2++操作加入互斥锁，也就是让num2++成为一个“原子操作”（操作过程不会被中断），所以结果符合预期为100万。
c语言--文件操作
最新发布
2303_80645930的博客
09-25 663
磁盘（硬盘）上的⽂件是⽂件。但是在程序设计中，我们⼀般谈的⽂件有两种：程序⽂件、数据⽂件（从⽂件功能的⻆度来分类的）。函数名功能适用于fgetc字符输入函数所有输入流fputc字符输出函数所有输出流fgets⽂本⾏输⼊函数所有输入流fputs⽂本⾏输出函数所有输出流fscanf格式化输⼊函数所有输入流fprintf格式化输出函数所有输出流fread⼆进制输⼊文本输入流fwrite⼆进制输出文本输出流。
基于C++(FLTK)实现（CS界面）超市收银系统
神仙别闹的自留地
09-25 635
7.比较蛋疼的是，这个fltk.framework中虽然已经包含了头文件，但是并不全（142个），差一个abi-version.h文件，因此，我们回到最初的FLTK解压文件夹，在/FL文件夹中找到abi-version.h文件，然后再回到/Library/Frameworks下，打开刚刚拷贝进来的fltk.framework，在/Version/A/Headers/FL/ 下，将abi-version.h拷贝进来。至于绘图以及输出各个商品所占利润百分比，程序中采用的是 fl_draw 系列的函数。
59.【C语言】内存函数(memmove函数)
2401_85828611的博客
09-21 733
对比第59篇的memcpy函数。​ memmove多了:Copying takes place as if an intermediate buffer were used(复制就像中间的缓存区使用一样), allowing the destination and source to overlap. memcpy多了:, and should not overlap (for overlapping memory blocks, memmove is a safer approach). ​
Java设计模式详解：24种模式+6大原则
章节26集中讨论六大设计原则，分别是单一职责原则（Single Responsibility Principle）、开放封闭原则（Open-Closed Principle）、里氏替换原则（Liskov Substitution Principle）、接口隔离原则（Interface ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值