每天一个设计模式——装饰模式（C++实现）

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

设计模式的代码十分难写的，要充分的体现可复用性，网上有着大量关于设计模式的代码，其中很多的代码违背了很多设计原则，比如依赖倒置原则、开放封闭原则，需要我们明辨是非。

设计模式的原则大于使用哪个设计模式，类的组合关系也大于类的继承，通过不断的写代码加上多思考多总结才能真正的领悟大师们的思想。

我看的是李健忠老师的设计模式
课程链接
课程配套的源码

目录


以下源代码第一份和第二份是我摘录课程的源码，第三份是经过我自己的想法与总结写的，我也建议大家学习一个模式，先动手把最初的代码改一改，这样能增加对这个模式的理解，而不是老师讲了什么才知道什么。

第一份代码

先让我们看看第一份代码，FileStream、 NetworkStream、MemoryStream要重写Read等一系列虚函数，这个是没问题的。可以当他们要实现一个功能的时候（加密呀等等功能，实现的功能不需要重写），而如果继续采用继承的话，功能分别继承FileStream、 NetworkStream、MemoryStream这些类，多一个功能，就要改变N个类，这样的维护性大大的减少了。这也违反了依赖倒置原则，高层模块不应该依赖低层模块，**应该都依赖抽象（基类）**我们进行改正一下，往下翻看第二份代码

//第一版代码
//业务操作
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();

}

第二份代码

对额外的功能新增一个基类，在使用组合的方式替代继承，提高代码复用性，在实际的工程已经可以了。对象Stream* stream并没有得到复用，在细致的话就要引出装饰模式，往下翻看第三份代码

//业务操作
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;//...

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);
    
    BufferedStream* s3=new BufferedStream(s1);
    
    BufferedStream* s4=new BufferedStream(s2);
    
    

}

第三份代码

给所有的功能在套上一个基类（Decorate类），Stream的对象也能得到了复用

//业务操作
class Stream {
public:
    virtual char Read(int number) = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(int data) = 0;

    virtual ~Stream() {}
};

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

};

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

};

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

};
class Decorator :public Stream {
    //继承了这个类并且声明这个类的对象99%的可能性就是装饰模式了
public:
    //为什么需要Decorator？
    //因为这个Steam对象也是共用的，并且会有多个扩展操作，
    //这样也使用了依赖倒置原则，具体的类（File、Network...）与
    //可扩展的类(具体操作)通过Decorator这个抽象实现的通信
    //Decorator通过他的上层Stream来进一步通信
    Stream* stm; // new Stream();
    Decorator(Stream* stm) :stm(stm) {

    }
};

//扩展操作
//增加新的共用的功能，通过组合的形式，而不是每个类通过继承上一个类解决问题
class CryptoStream :public Decorator {//这样三种文件都可以通过这样的一个类
public: 
    CryptoStream(Stream* stm) : Decorator(stm) {}
    virtual char Read(int number) {

        //额外的加密操作...
        stm->Read(number);//读文件流

    }
    virtual void Seek(int position) {
        //额外的加密操作...
        stm->Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(int data) {
        //额外的加密操作...
        stm->Write(data);//写文件流
        //额外的加密操作...
    }
};


class BufferedStream : public Decorator {
    //...
};



class CryptoBufferedStream :public Decorator {
public:
    virtual char Read(int number) {

        //额外的加密操作...
        //额外的缓冲操作...
        stm->Read(number);//读文件流
    }
    virtual void Seek(int position) {
        //额外的加密操作...
        //额外的缓冲操作...
        stm->Seek(position);//定位文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
    virtual void Write(int data) {
        //额外的加密操作...
        //额外的缓冲操作...
        stm->Write(data);//写文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
};



void Process() {


    //运行时装配
    Stream* f = new FileStream();
    Decorator* fs1 = new CryptoStream(f);
    Stream* f2 = new CryptoStream(f);
    //BufferedFileStream* fs2 = new BufferedFileStream();

  //  CryptoBufferedFileStream* fs3 = new CryptoBufferedFileStream();

}
dxgzg
关注
专栏目录
C++实现设计模式——装饰者(decorator)模式
yxh_1_的博客
04-25 1035
C++实现设计模式——装饰者(decorator)模式 装饰者(decorator)模式定义 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。不改变接口的前提下，增强所考虑的类的性能。 何时使用 1）需要扩展一个类的功能，或给一个类增加附加责任。 2）需要动态的给一个对象增加功能，这些功能可以再动态地撤销。 3）需要增加一些基本功能的排列组合而产生的非常大量的功能。 注意：装饰者模式的根本是装饰而不是改变接口，原先调用的什...
C++设计模式——装饰模式（decorator pattern）
净无邪博客
06-07 731
一、原理讲解 图1 装饰者模式UML图 1.1意图 装饰模式目的是：动态地给一个对象添加一些额外的职责，比生成之类更灵活。 1.2常用场景 一般用于给某个对象添加某个功能，但是又不希望更改该对象底层抽象借口，同时该功能可以动态增删，这时可以考虑用装饰者模式。 1.3实行方法 如图1所示，装饰着Decorator通过继承抽象基类Component，又组合一个Component指针*component，通过重写从Component继承而来的虚函数operation()，在里面用指针调用oper.
23种设计模式详讲-装饰模式
撸起袖子加油干
03-05 234
一、定义： 动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活; 1)优点： ①比静态继承（多重继承）更灵活。 ②避免在层次结构高层的类有太多的特征。可以定义一个简单的类，并且用Decorator类给它逐渐地添加功能。可以从简单的部件组合出复杂的功能。 2)缺点： ...
23种设计模式——装饰模式
qq_51165184的博客
04-06 1858
装饰（Decorator）模式本质：动态组合，动态是手段，组合是目的。以对客户端透明的方式扩展对象的功能
C++ 设计模式——装饰模式
最新发布
qq_68194402的博客
08-21 1146
装饰模式（Decorator Pattern）是一种结构型设计模式，允许在不改变对象结构的情况下，动态地为对象添加额外的功能。下面是一个基于控件的例子，展示了如何使用装饰模式来增强控件的功能。
C++设计模式——装饰模式(Decorator Pattern)
leonardohaig的博客
11-09 847
C++设计模式——装饰模式(Decorator Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——装饰模式(Decorator Pattern)目录定义代码示例总结装饰模式和代理模式适用场景优缺点装饰模式的简化参考资料 定义 Attach additional responsibilities to an object dynamically keeping the same interface. Decorators provide a flexible alternati
C++设计模式——装饰模式(高屋建瓴)
weixin_45481202的博客
10-19 155
原网址：https://blog.csdn.net/CoderAldrich/article/details/83115394 重点在于 ConcreteDecoratorA(Component *decorator) : Decorator(decorator) #include <iostream> using namespace std; class Component { public: virtual void Operation() = 0; }; class Concre
C++设计模式——适配器模式
Abieai的博客
10-14 586
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
C++设计模式——装饰器模式
肩上风骋的博客
12-18 1282
装饰器设计模式其本质上还是使用多态的原理，提供了一种可扩展功能的设计模式。
.NET中的设计模式——一步步发现装饰模式
02-27
前言过去我的一个朋友常说，学习任何编程语言最困难的部分是运行“HelloWorld”，之后一切都很容易。多年以后，我才意识到他说的很对。学习设计模式的基本目标是要用它，尤其是帮助那些有扎实的OOP基础，而对设计...
C++写一个http服务器/web服务器
热门推荐
dxgzg的博客
02-02 26万+
目录开篇废话正文 开篇废话 其实这篇文章一直想写，苦于没有时间，想一气呵成写完，在离回家前一天晚上，在上海的小宾馆里面异常兴奋，写一下如何用C++搭建一个简易的http服务器。 我相信大部分人都希望渴望一个自己的网站（哪怕在破在破也是自己做的），我当初是就是这么渴望的，记得那是2020年的8月，我查阅的各种资料终于学会了socket，于是迫不及待的写了一个聊天程序，一直在研究如何端口映射。那时候还很傻很天真，来了一个连接就开一根线程，离开就销毁这根线程，那会也知道线程创建和销毁的开销很大，但是一直没有想到其
C++拷贝/复制一张图片 读写二进制文件
dxgzg的博客
09-30 25万+
最近发现了自己网站一个bug（早发现了，一直没去深入探索原因），我网站的图标没了，按F12看看图标传过来了吗，发现传过来了。但为啥没显示出来百思不得其解，起初是怀疑图片是二进制文件保存的，所以按正常文件读写是不对的，想了之后决定用sendfile函数（Linux的一个系统函数，也叫零拷贝函数，没用过的同学可以翻翻man手册或者搜搜了解一下）发送二进制文件，对jpg、png来一个判断，然后sendfile直接发送，这样做起来改动是最少的，该完之后确实发现ok了，就放在那里没改了，最近要修改一下网站后台的源码，
C++遇到的黑科技代码
dxgzg的博客
05-03 25万+
平常看的一些开源代码，遇到了一些黑科技。在总结一下 目录1、将数字压缩写入字符串中2、当函数只能接受int32的参数的时候，但我想传int64的值怎么办？3、利用栈空间 1、将数字压缩写入字符串中 比如int的最大值是2^31次方，好多位阿，我想写在string中，岂不是要这样写？潜意识都会这么写的，那么我们有什么办法只写在前四个字节中吗？当然有了。 string s; s = to_string(INT_MAX); 用下面的代码，可以清晰看到，把值写到s2的比特位中了，只占用了4个字节.取出他的地址在强
VS C++ 2019中const char* 类型的值不能用于初始化char*的解决与理解
dxgzg的博客
01-05 7833
解决方法： 1、在char *p = “hello”的前面加const 2、或者，右键project -> 属性 -> C/C++ -> 语言 -> 符合模式：否 为什么加个const就OK了，我个人的理解，就像int &r=3；//编译器是会报错的。因为编译器觉得你可能会修改3这个常量，所以在前面加一个const，变成常引用，常引用不会修改值，所以这样就不会有问题...
C++function和bind绑定类成员函数
dxgzg的博客
11-22 6493
定义一个普通的类 class Test1{ public: void fun(int val){ cout<<"hello world "<<val<<endl; } }; 开始第一个测试 int main(){ Test1 t; function<void(int)> pf = std::bind(&Test1::fun,t,2); pf(4); // return 0; } 输出的值是2，说明pf传进去的4并没有什么用，在bin
VS中从文本文档txt文件读取中文乱码的解决办法
dxgzg的博客
01-11 5327
前言：这几天考完试出了成绩，身为班长又要帮学委算平均绩点分，去年暑假写了一个比较憨憨的算分代码，一个成绩一个成绩输入进去，又进阶进阶了C++。每次考完试都会做一个全班成绩分数的表，但是不会用Excel的计算公式，就自己写了个一键出绩点的程序，读取两个文件，一个文件把人名都复制，一个把成绩都复制存放txt记事本中去。 正题：读成绩时，没发生任何乱码，读人名有中文就出现了乱码，别的我也不知道怎么解决，...
C++生成随机字符串
dxgzg的博客
12-13 3346
最近给自己的网站搞一个相册，随机生成图片名字，生成100W个16位的名字，测试没重复，感觉还不错，生成的数字是均匀分布的cppreference #include <random> #include <iostream> #include <unistd.h> #include <unordered_set> using namespace std; char seed[64] = { '0','1','2','3','4','5','6','7','
C++11读写锁的实现
dxgzg的博客
01-08 3042
参考的源码 读写锁，一直都有听，也大概知道点原理，一直没有探究内部是如何实现的，正好今天完成了几项大作业，研究一下读写锁实现的原理。 读写锁的原理就是，可以多次读，但是写只能一次一次的写入，我参考的源码博控制了写优先，并且读的优先级没我写的这么高。我自己在修改了他的源码，实现的是读优先，并且优先级很高，如果存在大量的读操作，可能会出现写操作线程饥饿的现象。如果在具体的场景中写操作也多，可以修改wait条件来判断优先级。我最近的感悟，如果非必要，一个类的对象不必非要跨线程操作。 #include<mu
C++设计模式解析：GoF23模式带C++实现
"C++ 设计模式 PDF 版本提供了对GoF23种设计模式的解析，并附带C++实现源码。这份资源由K. Eckel编写，旨在帮助读者理解和掌握面向对象分析和设计的关键——设计模式。" 设计模式是软件工程中的重要概念，它们代表...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值