C++ 设计模式 装饰模式

最新推荐文章于 2024-01-18 11:43:27 发布
最新推荐文章于 2024-01-18 11:43:27 发布
阅读量168 收藏
点赞数
分类专栏： 重构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41605114/article/details/115505491
版权

以下内容均来自GeekBand极客班C++ 设计模式课程（李建忠老师主讲）

参考文献见：https://download.csdn.net/download/qq_41605114/18881763

Decorator

“单一职责”模式：

在软件组件的设计中，如果责任划分不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码（典型的Bad smell），这时候的关键是划分责任。

典型模式：

Decorator

Bridge

动机（Motivation）

在某些情况下，我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增加），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。

如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响降到最低。

《设计模式》GOF的定义：

“动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）”

蓝色为稳定部分，橘黄色为变化部分

下面我们以一个流操作为案例：

结构化编程

流的主体如下：

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 CrytoFileStream : 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 CrytoNetworkStream : public NetworkStream{

};

class CrytoMemoryStream : public MemoryStream{

};

增加缓冲区：

//增加缓冲区
class BufferedFileStream : public FileStream{

};

class BufferedNetworkStream : public NetworkStream{

};

class BufferedMemoryStream : public MemoryStream{

};

现在对上述的继承关系进行梳理，树状图如下： 

从上图可知，如果继续增加需求，那么会导致子类不断膨胀，此时显然是要进行优化，划分清楚责任

为了优化整个结构，我们首先对继承部分进行优化：

利用组合替代继承：

class CrytoFileStream{
     FileStream * stream;
public:
    virtual char Read(int number){
        //额外的加密操作
        stream->Read(number);//直接用父类的，此处必须声明作用域
        //...读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作
        stream->Seek(position);//直接用父类的，此处必须声明作用域
        //...定位文件流
    }
    virtual void Write(char data){
        //额外的加密操作
        stream->Write(data);//直接用父类的，此处必须声明作用域
        //...写文件流
    }
};

对比一下代码段：

继承 ：                                                                                                              组合：

我们可以看到，使用继承的CrytoFileStream class中的FileStream：：Read/Seek/Write部分，全部是静态特质，是无法进行扩展的，只能进行改变。

直接替换成使用组合的CrytoFileStream class

下面我们对所有的扩展内容都进行同样的操作：

class CrytoFileStream{
     FileStream * stream;
public:
    virtual char Read(int number){
        //额外的加密操作
        stream->Read(number);//直接用父类的，此处必须声明作用域
        //...读文件流
    }
};
class CrytoNetworkStream{
    NetworkStream * stream;
public:
   virtual char Read(int number){
       //额外的加密操作
       stream->Read(number);//直接用父类的，此处必须声明作用域
       //...读文件流
   }
};
class CrytoMemoryStream{
    MemoryStream * stream;
public:
   virtual char Read(int number){
       //额外的加密操作
       stream->Read(number);//直接用父类的，此处必须声明作用域
       //...读文件流
   }
};

可以看到，上面的代码更加接近了，加密扩展到的三个类几乎是在完成相同的操作

我们直接把FileStream，NetworkStream，MemoryStream的对象Stream完全可以使用多态进行代替

直接

将上面三个类合为一个类

class CrytoStream : public Stream{
     Stream * stream;
public:
    virtual char Read(int number){
        //额外的加密操作
        stream->Read(number);//直接用父类的，此处必须声明作用域
        //...读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作
        stream->Seek(position);//直接用父类的，此处必须声明作用域
        //...定位文件流
    }
    virtual void Write(char data){
        //额外的加密操作
        stream->Write(data);//直接用父类的，此处必须声明作用域
        //...写文件流
    }
};

 同理，Buffer类也可以合为一个类

//增加缓冲区
class BufferedStream : public Stream{
    Stream * stream;
public:
    BufferedStream(Stream * arg):stream(arg){

    }
   virtual char Read(int number){
       //额外的缓冲操作
       stream->Read(number);//直接用父类的，此处必须声明作用域
       //...读文件流
   }
   virtual void Seek(int position){
       //额外的缓冲操作
       stream->Seek(position);//直接用父类的，此处必须声明作用域
       //...定位文件流
   }
   virtual void Write(char data){
       //额外的缓冲操作
       stream->Write(data);//直接用父类的，此处必须声明作用域
       //...写文件流
   }
};

从CrytoStream类和bufferedStream类中可以看出，其中含有相同的字段，那么按照重构的理论，要么把这些字段提取出来放在父类中，要么就做一个中间类

放在父类中的话，FileStream不需要这个字段，所以没有任何的必要

那么现在做一个中间类 DecoratorStream类，具体操作如下：

class DecoratorStream : public Stream{
protected:
    Stream * stream;
public:
    DecoratorStream(Stream * arg):stream(arg){
        
    }
};

class CrytoStream : public DecoratorStream{   
public:
     CrytoStream(Stream * arg):DecoratorStream(arg){

     }
    virtual char Read(int number){
        //额外的加密操作
        stream->Read(number);//直接用父类的，此处必须声明作用域
        //...读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作
        stream->Seek(position);//直接用父类的，此处必须声明作用域
        //...定位文件流
    }
    virtual void Write(char data){
        //额外的加密操作
        stream->Write(data);//直接用父类的，此处必须声明作用域
        //...写文件流
    }
};

//增加缓冲区
class BufferedStream : public DecoratorStream{
public:
    BufferedStream(Stream * arg):DecoratorStream(arg){

    }
   virtual char Read(int number){
       //额外的缓冲操作
       stream->Read(number);//直接用父类的，此处必须声明作用域
       //...读文件流
   }
   virtual void Seek(int position){
       //额外的缓冲操作
       stream->Seek(position);//直接用父类的，此处必须声明作用域
       //...定位文件流
   }
   virtual void Write(char data){
       //额外的缓冲操作
       stream->Write(data);//直接用父类的，此处必须声明作用域
       //...写文件流
   }
};

加上最开始的抽象类和主体类

//Decorator
class Stream{
public:
    virtual char Read(int number) = 0;
    virtual char Seek(int position) = 0;
    virtual char Write(char data) = 0;

    virtual ~Stream(){}
};
//主体类
class FileStream : public Stream{
public:
    virtual char Read(int number){
        //...读文件流
    }
    virtual char Seek(int position){
        //...定位文件流
    }
    virtual char 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){
        //...写内存流
    }
};

下面我们可以看出，树状结构转化为了下面的形式

要点总结

1，通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。

2，DecoratorStream类在接口上表现为is-a Stream的继承关系，即DecoratorStream类继承了Stream类所具有的接口。但是实际上又表现为has-a Stream的组合继承关系，及DecoratorStream类又使用了另外一个Stream。

3，DecoratorStream模式的目的并非解决“多子类衍生的多继承”问题，DecoratorStream模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。

 

 

 

CodeChecker
关注
专栏目录
Visual C++网络编程经典案例详解 第8章 网络文件传输 CFile类 文件定位 Seek函数
eyetired的博客
06-15 742
通常情况 用户在操作某一文件时 希望从文件的某一特定处开始读取或写入文件 这时 用户就使用定位文件的函数 如CFile类的Seek 原型如下 virtual LONG Seek(LONG loff,UINT nFrom); virtual DWORD GetPosition() const; 函数Seek用于随机访问文件中的数据 参数意义 参数loff表示确定指针移动的字节数 正值表示指针向后移...
C++设计模式之装饰模式
09-04
装饰模式（Decorator Pattern）是一种结构型设计模式，其主要目的是在不改变对象原有结构的情况下，动态地为对象添加新的功能。这种模式的核心在于通过对象的组合而非继承来扩展功能，从而提高了代码的灵活性和可...
C&C++实现文件偏移操作的常用方法
流云阁
07-26 2891
详细说明标准c，c++，MFC文件操作中指针偏移的接口函数；并编写调用实例加以说明！
【C++题解】seek
JG_DF_的博客
01-11 918
里所有的公共前后缀，所以找所有的公共前后缀只需从最长公共前后缀开始，当发现有公共前后缀时，就用。来存该公共前后缀的长度，然后就往里面继续找，直到找完所有的公共前后缀才结束。因为公共前后缀里面可能会有另一个公共前后缀，而最长公共前后缀包含了字符串。区间中最长公共前后缀(max border)的长度为。之后就是找出所有的公共前后缀，用数组。我们用 KMP 得到对应的。一道 KMP 算法裸题。
【知识---c++中seekg、tellg使用】
fyc300的博客
01-18 1446
以上就是关于seekg和tellg的简单使用方法介绍，不足之处，请大家斧正！！！
C++ 学习笔记杂项(1)
永不秃头的程序员的博客
09-25 591
简单记录下关于C++的输入流的相关的seekg函数。
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
c++设计模式-结构型模式-装饰器模式
06-12
c++设计模式-结构型模式-装饰器模式；QT工程；c++简单源码； 装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
c++设计模式全系列+应用场景+实例说明
最新发布
04-01
4. **装饰者模式（Decorator Pattern）**：装饰者模式是一种结构设计模式，允许向一个对象动态添加新功能，而无需修改其源代码。 5. **策略模式（Strategy Pattern）**：策略模式是一种行为设计模式，定义了一系列...
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
C++ 文件操作 tellg,tellp,seekp,seekg函数
wu_zhiyuan的博客
04-21 2140
例如，假如我在进行文件读写，而要定位到当前位置的三个字符之前，则需调用FileHandle.seekg(-3). 但如果我是在写入一个文件，并且比如我要重写后5个字符的内容，我就必须往回跳转5个字符，因而，我应该使用FileHandle.seekp(-5) .所以当你再次调用get()函数的时候，它会返回再下一个字符，而非前面那个。nCount表示要略过的字符数量，而delimiter —— 与它的名称有着同样的含义：假如你想在文件末尾停下，则可使用EOF值传入，这样一来此函数就等同于seekg()；
C++——面向对象编程（文件 多态 继承）完善中
weixin_45683677的博客
03-04 232
1.面向对象编程的特性 程序由类(class)构成，基本特征为封装性、继承性和多态性. 2.c++文件的使用 1.打开文件 一般使用的头文件 fstream类都有一个函数 ????为了写的out与为了读的in 是相对于程序而言的???? void open(const char* filename,int mode,int access); fstream file1; file1.open("c:conf...
文件内光标的移动及数据的修改
Yydsaoligei的博客
06-30 319
python,文件中光标的移动，文件中数据的修改
c++学习seekp和tellp心得
qq_29925133的博客
12-10 794
C++的seek和tellp学习心得 在iostream里面 输出对象拥有函数： ostream& seekp(long ing,int)；//第一个参数是设置偏移，第二个参数是设置读写的位置，有三种状态 long int tellp(void)；//获取当前读写位置到文件头的偏移，单位为字节 下面的程序是在Mat文件里面读取数据，并且用16进制显示 #include<iostrea...
c++ stream
w_419675647的博客
03-20 271
文章目录1总图2 fstream的使用方法用法步骤：注意点：读写文件文本文件的读写二进制文件的读写检测EOF文件定位ios::binary和ios::text打开文件区别3例子代码 原创：整理下 “流” 相关的内容和用法 1总图 2 fstream的使用方法 ofstream是从内存到硬盘，ifstream是从硬盘到内存，其实所谓的流缓冲就是内存空间; fstream 既包含ifstream ...
C++ seekg()函数
热门推荐
漫步云端
05-27 3万+
seekg()是对输入流的操作 seekp()是对输出流的操作 seekg() Moves the read position in a stream.//移动在流中读的位置 ------------------------------------------------------------------------ basic_istream<Elem, Tr>& seek...
seekg()与tellg()用法详解
he-honghua的专栏
09-02 1万+
对输入流操作：seekg（）与tellg（）对输出流操作：seekp（）与tellp（）下面以输入流函数为例介绍用法：seekg（）是对输入文件定位，它有两个参数：第一个参数是偏移量，第二个参数是基地址。对于第一个参数，可以是正负数值，正的表示向后偏移，负的表示向前偏移。而第二个参数可以是：ios：：beg：表示输入流的开始位置ios：：cur：表示输入流的当前位置io
C++中读文件很有用的fseek函数
imucaoyue的专栏
12-02 5346
int fseek( FILE *stream, long offset, int origin ); 　　第一个参数stream为文件指针 　　第二个参数offset为偏移量，正数表示正向偏移，负数表示负向偏移 　　第三个参数origin设定从文件的哪里开始偏移,可能取值为：SEEK_CUR、 SEEK_END 或 SEEK_SET 　　SEEK_SET：
C++设计模式实战：Adapter模式详解
"C++设计模式的全实现" C++设计模式是软件开发中的一种最佳实践，它提供了解决常见编程问题的模板。本资源聚焦于23种主要设计模式的C++实现，旨在帮助开发者更好地理解和应用这些模式，提高代码的可读性、可维护性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值