【C++设计模式】装饰器模式

最新推荐文章于 2023-03-30 15:32:02 发布
最新推荐文章于 2023-03-30 15:32:02 发布
阅读量134 收藏
点赞数
分类专栏： C++设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33197518/article/details/109776433
版权

模式定义：
动态（组合）的给一个对象增加一些额外的职责，就增加功能而言Decorator模式比生成子类（继承）更为灵活（消除重复代码 & 减少子类个数）。
在这里插入图片描述

假设我们需要设计如下一个功能的程序：
1.对各种流的读取、写入和定位
2.添加对各种流的加密以及缓冲或者又加密又缓冲的功能。
那么我们最初设计的类（版本一）可能如下：

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

因为Read等函数为虚函数，所以可以很好的利用多态性质。

实际上我们可以将操作中内含的那个类转换为继承自一个装饰类，具体可以实现如下：

//业务操作
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;//...
    
    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{
    
    Stream* stream;//...
    
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);
    
    

}

在这里我们可以屡一下结构，这里的Stream类是要被装饰的对象，它自身可以有自己的实例，一般通过抽象类来实现。DecoratorStream类就是装饰器类，而 BufferedStream等类就是自定义的装饰器，为Stream装饰一些功能，自定义的装饰器一般要继承装饰器基类。

在这里插入图片描述在这里插入图片描述

打工的社畜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式之装饰模式
李兰溪的专栏
03-06 884
C++设计模式之装饰模式 动态地给一个对象增加一些额外的职责，就增加对象的功能来说，装饰模式比生成子类更为灵活。装饰模式是一种对象结构模式。 一、缘由我们常常通过继承的方式来对一个既有的类进行功能添加，但继承方式有显著的局限性，因为 继承具有侵入性 继承是一种is a的关系，具有强耦合性，难以复用代码。 例如在窗口控件当中，要增加新的功能如增加滚动条，增加背景图片，通过继承的方式来增加新的功能，
设计模式之装饰器模式，以C++为例。
Bobowen的博客
02-02 745
今天来盘一盘装饰器模式。装饰器模式以一种动态的方式给对象添加额外的职责，好似“装饰”在对象身上一样，通常通过继承和委托来实现。 设计模式始终遵循对“修改封闭，拓展开放”这样的特性，说白了就是尽量不要动源代码，去尽力适应源代码的方式去做拓展开发。装饰器模式同样遵循这样的原则，实现装饰器模式的主要手段同样为 C++最基本的特性：继承、C++11新特性：委托。
装饰模式(decorator-pattern)
geek！
01-19 1055
如何避免继承导致的类数量指数级增长？如何更加优雅地给现有的类动态增添新的功能？装饰模式或许称得上首选。
C++设计模式详解之装饰者模式解析
m0_73443478的博客
02-25 468
C++设计模式详解之装饰者模式解析
设计模式之装饰者模式
sweet_sauce的博客
04-21 377
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。使用场景： 1、扩展一个类的功能。 2...
c++设计模式-结构型模式-装饰器模式
06-12
c++设计模式-结构型模式-装饰器模式；QT工程；c++简单源码； 装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
C++ 23种设计模式.zip
07-29
本资源"**C++ 23种设计模式.zip**"包含了C++版本的设计模式详细讲解，旨在帮助开发者提升编程技能和团队协作效率。 1. **单例模式（Singleton）**：确保一个类只有一个实例，并提供一个全局访问点。在C++中，可以...
C++设计模式之装饰模式(Decorator)
08-27
总的来说，装饰模式是C++中一种非常实用的设计模式，尤其适用于需要动态地给对象添加新功能，或者在不修改原有代码的情况下扩展功能的场景。通过使用装饰模式，我们可以创建更加模块化、可扩展的软件系统。
C++设计模式代码资源
08-17
在这个名为"C++设计模式代码资源"的压缩包中，包含了多种C++实现的设计模式示例代码，下面我们将详细探讨这些设计模式及其应用。 1. **单例模式**：保证一个类只有一个实例，并提供全局访问点。在C++中，可以使用...
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
装饰器(Decorator)模式
12-22
装饰器(Decorator)模式 详细教程，简明易懂，非常清晰的，附带有代码示例。
C++结构型模式-装饰模式
灰太狼的小秘密
09-21 1607
C++实现装饰器模式
C++设计模式(13)——装饰模式
伍粟的博客
02-11 1948
C++ 装饰器模式
C++设计模式：装饰器模式
m0_73443478的博客
03-24 260
C++设计模式：装饰器模式
C++设计模式3——装饰器模式
litingyi000的博客
10-09 199
C++设计模式3——装饰器模式定义背景代码优缺点 定义 背景 公司发放月工资，普通员工有基本工资，销售奖金，累计奖金；销售经理还有团队奖金；以后还会有环比奖金，计算奖金总额。 代码 #include <string> #include <iostream> using namespace std; //duty抽象基类 class Duty { public: virtual int showSalary() = 0; virtual ~Duty() {}; };
设计模式之装饰器模式
胖子
07-25 199
一、介绍 装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。 这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。 意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。 主要解决：一般的，我们为了...
设计模式之装饰器模式(C++实现)
墨1024
12-31 1757
装饰器模式介绍，包括应用场景，优缺点，模式结构，类图 以及 C++代码示例
设计模式之装饰器模式(C++)
热门推荐
翟天保的博客
03-30 2万+
介绍设计模式之装饰器模式
C++ 装饰器模式
索命的博客
08-06 598
C++ 装饰器模式
c++设计模式装饰器模式
最新发布
08-31
装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许向一个现有的对象添加新的功能，同时又不改变其结构。这种模式通过创建一个装饰类来包装原始的类，从而实现动态地扩展一个对象的功能。装饰类和被装饰类可以独立发展，它们之间没有耦合关系。装饰器模式是继承的一个替代模式，它避免了使用继承来扩展对象功能所带来的静态特性。 在C++中，可以通过使用抽象类和具体类来实现装饰器模式。首先创建一个抽象类（比如Shape）作为基类，然后创建具体的类（比如Circle和Rectangle）作为子类。这些子类实现了抽象类中的纯虚函数（比如draw），分别表示不同的图形。 在使用装饰器模式时，我们可以创建一个装饰类，它也是抽象类的子类，并且它的对象包含一个抽象类对象的指针。装饰类可以在原始对象的基础上添加额外的功能，同时保持原始对象的接口不变。通过使用装饰器模式，我们可以动态地扩展一个对象的功能，而无需修改原始对象的结构。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [C++设计模式：装饰器模式](https://blog.csdn.net/m0_73443478/article/details/129751085)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值