（Boolan）C++设计模式 <五> ——装饰模式（Decorator）

最新推荐文章于 2021-01-18 16:00:52 发布
原创 最新推荐文章于 2021-01-18 16:00:52 发布 · 382 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

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

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

在下面有一组伪代码，这组伪代码主要我i饿了描述一些流的操作，比如文件流、网络流、内存流等，如果我们对于流提出更多的要求，比如需要对文件流加密、对网络流加密以及内存流的加密，同时如果考虑缓冲的情况下，那么这些流都可能会要缓冲，也可能继续的组合，产生加密缓冲网络流等等的操作。

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

}

这样的设计对于代码的复用来说很不好，对于每种方式都有大量的重复代码，但这还不是最主要的，而更可怕的是，这样的设计会导致class的数量激增。将精力浪费在了激增的重复代码上，实在是得不偿失的一件事。所以必须要考虑如何来解决。


几种Stream的组合

那么应该要如何下手呢？如果我们把那些因为组合而产生的class（比如CryptoFileStream）的继承关系先打断，而是改为使用内部持有原先父类的指针。（比如CryptoFileStream原先继承了FileStream，改为持有FileStream）。这时候，原class中的调用父类的函数，全都可以改为使用自己持有的指针对象来调用。此时代码的重复性大幅度提高，只是每一个组合型的class中持有的那个指针不属于同一个（比如，持有的为FileStream，NetworkStream以及BufferStream的指针），如果观察一下，也不难发现，其实FileStream，NetworkStream以及BufferStream又都有同一个父类Stream，所以利用多态性，就可以将每个组合类型中的持有的指针变量，声明为他们共同的父类，利用多态性只需要让父类的指向子类即可(`Stream stream = new FileStream();`)，这就实现了，编译时都为一样的，在运行时提供不同的对象。此时会发现具有大量重复的类，合并了同类项，减少很多不必要的组合类。

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



}

观察上面的代码来说，其实有很多class里面都持有同样的变量stream，那么这些类可以向上再抽象一个父类，将strem 在父类中声明。

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

更改后的类图

FileStream、NetworkStream还有BufferStream来说，他们可以独立执行任务，而加密和缓存其实就是对他们的增强。只需要对Stream（这三个类的共同父类）增加加密功能、增加缓冲的功能，而在使用的时候自由组合即可，而不需要把代码全都写出来。


装饰模式的UML

要点总结

  1. 通过采用组合而非继承的手法，Decorator模式实现了在运动时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用集成带来的“灵活性差”和“多子类衍生的问题”
  2. Decorator类在接口上变现为is-a Component的继承关系，即Decorator类集成了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
  3. Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的重要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。
Toonle
关注
C++实现设计模式——组合（Composite）模式
yxh_1_的博客
04-25 1291
C++实现设计模式——组合（Composite）模式 组合模式定义 把一组相似的对象当作一个单一的对象，它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。 组合模式应用场景 希望客户端可以忽略组合对象与单个对象的差异时； 对象层次具备整体和部分，呈树形结构（比如树形菜单，公司组织架构等） 有一个或多个共同特点。它们有一个主线。 组合模式举例 组合模式在日常中其实经常遇到，只是有时候我们不知道这种就是组合模
C++课程--设计设计思想、方法与模式（李建忠老师）
gomissionone的博客
07-06 3253
【干货回顾】李建忠老师在 Boolan 直播间和大家畅聊《C++ 软件设计与模式的道法术》，精辟囊括了《软件设计思想、方法与模式》C++课程的主要内容，以下为本期直播干货重点：李建忠
（Boolan）C++设计模式 <三> ——策略模式（Strategy）
Toonle的专栏
08-23 554
定义一系列算法，把他们一个个封装起来，并且是他们可以互相替换（变化）。该模式似的算法可以独立于使用它的客户程序（稳定的）而变化（扩展，子类化）。——《设计模式》GoF 动机（Motivation）在软件构建的过程中，某些对象使用的算法可能是多种多样的，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂；而且有时候支持不使用的算法也是一种性能负担 比如现在需要有一个税种的计算系统，其
（Boolan）C++设计模式 <一> ——设计模式简介以及面向对象设计原则
Toonle的专栏
08-23 410
什么是设计模式每一个描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案。这样，你就能一次又一次地使用该方案而不必做重复劳动。——Christopher Alexander 对于我们处理工作中的实际问题的时候，其实绝大多数的问题都是呈一定的模式重复出现的，如果不使用设计模式，那么我们在处理问题的时候，不得不一遍又一遍重复做着类似的工作，不但浪费了大量的精力，同时也更是一种极度让人烦躁
（Boolan）C++设计模式 <六> ——桥模式（Bridge）
Toonle的专栏
08-23 415
将抽象部分（业务功能）与实现部分（平台实现）分离，是他们都可以独立地变化。——《设计模式》GoF 动机由于某些类型的固有的实现逻辑，使得它们具有两个变化的维度，乃至多个维度的变化 假设有如下的通信的伪码描述包括登陆、发信息、播放音乐等等的功能，同时也支持不同的平台的支持，比如PC、移动端等，其中版本也具有不同的功能，比如精简版和完整版。 class Messager{ public: vi
（Boolan）C++设计模式 <四> ——观察者模式（Observer）
Toonle的专栏
08-23 372
动机在软件构建的过程中，我们需要为某些对象建立一种“通知依赖关系”——一个对象（目标对象）的状态发生改变，所有的以来对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使得软件不能很好的抵御变化。使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。 下面是一个文件切割的程序的伪码，可以把较大的文件分隔为若干个较小的文件。并且对于文件分割过程
（Boolan）C++设计模式 <二> ——模版方法（Template Method）
Toonle的专栏
08-23 380
定一个操作中的算法的骨架（稳定的），而将一些步骤延迟（容易变化的）到子类中。Template Method使得子类可以不改变（复用）一个算法的结构即可重新定义（Override覆写）该算法的某写特定步骤——《设计模式（GoF）》 关于模版方法的设计模式，我们先来看这样一个伪码描述。下面的伪码主要是有两个开发人员来构成的代码，分别是库开发人员和应用程序的开发人员。对于库的开发人员来说，已经开发完成了
（Boolan）C++设计模式 <十二> ——命令模式（Command）和访问器（Visitor）
Toonle的专栏
08-23 582
“行为变化”模式 在组建的构建过程中，组建行为的变化经常导致组建本身剧烈的变化。“行为变化”模式将组建的行为和组建本身进行解耦，从而主持组件的变化，实现两者之间的松耦合。 典型模式 Command Visitor 命令模式Command 将一个请求（行为）封装为对象，从而使你可用不同的请求，对客户进行参数化；对请求排队或记录请求日志以及支持可撤销的操作。——《设计模式》GoF 动机在软件
（Boolan）C++设计模式 <十> ——状态模式（State）和备忘录（Memento）
Toonle的专栏
08-23 506
“状态变化”模式 在组建构建过程中，某些对象的状态经常面临变化，如何对这些变化进行有效的管理？同时又维持高层模块的稳定？“状态变化”模式为这一个问题提供了一种解决方案。 典型模式 State Memento 状态模式（State） 允许一个对象在其内部状态改变是改变它的行为。从而使对像看起来似乎修改其行为。——《设计模式》GoF 动机在软件构建过程中，某些对象的状态如果改变，其行为也会随
（Boolan）C++设计模式 <九> ——单例模式（Singleton）和享元模式（FlyWeight）
Toonle的专栏
08-23 647
“对象性能”模式 面向对象很好的解决了“抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来讲，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理。 典型模式 Sington Flyweight 单例模式Singleton 保证一个类仅有一个实例，并提供一个该实例的全局访问点。——《设计模式》GoF 动机在软件系统中，经常有这样一个特殊的类，必须保证
C++中的三大函数和操作符重载(Boolan)
12-26
C++中三大函数： 析构函数 复制构造函数 =操作符(copy assignment operator) 这三个特殊的成员函数如果程序员没有实现，编译器将提供默认的实现方式。 析构函数： 形如～foo_t()，函数名和构造函数相同，前面加～...
深入C++设计模式与新标准：从内存管理到C++11-14特性
在“面向对象”和“设计模式”方面，课件可能探讨了STL本身所体现的设计哲学——泛型编程（Generic Programming）与面向对象编程的异同与互补关系。通过对比GOF 23种经典设计模式（如迭代器模式、工厂模式、观察者...
Boolan 软件架构与C++专家团队走进华为，助力软件变革共创技术新生态
gomissionone的博客
01-18 412
2020年是全球科技版图的转折年，提升基础软件创新能力，掌握技术主导权至关重要。华为作为中国自主技术创新的代表性力量，一直在不断寻求突破，引领业界。Boolan专家团队助力华为软件变革，为其定制软件架构和C++系列技术赋能方案，包括性能工程、架构重构、安全可信、领域驱动等多项专题，在华为反响热烈。
（62页PPT）微专题14　测电阻的几种特殊方法.pptx
最新发布
01-06
（62页PPT）微专题14　测电阻的几种特殊方法.pptx
GeneratedClass1146.java
01-06
GeneratedClass1146.java
数字乡村解决方案（第一部分）.pdf
01-06
源码地址： https://pan.quark.cn/s/27933535a1f6 数字乡村解决方案（第一部分共130页）的电子文档格式
完美复现面向配电网韧性提升的移动储能预布局与动态调度策略【IEEE33节点】（Matlab代码实现）
01-06
【完美复现】面向配电网韧性提升的移动储能预布局与动态调度策略【IEEE33节点】（Matlab代码实现）内容概要：本文介绍了基于IEEE33节点的配电网韧性提升方法，重点研究了移动储能系统的预布局与动态调度策略。通过Matlab代码实现，提出了一种结合预配置和动态调度的两阶段优化模型，旨在应对电网故障或极端事件时快速恢复供电能力。文中采用了多种智能优化算法（如PSO、MPSO、TACPSO、SOA、GA等）进行对比分析，验证所提策略的有效性和优越性。研究不仅关注移动储能单元的初始部署位置，还深入探讨其在故障发生后的动态路径规划与电力支援过程，从而全面提升配电网的韧性水平。; 适合人群：具备电力系统基础知识和Matlab编程能力的研究生、科研人员及从事智能电网、能源系统优化等相关领域的工程技术人员。; 使用场景及目标：①用于科研复现，特别是IEEE顶刊或SCI一区论文中关于配电网韧性、应急电源调度的研究；②支撑电力系统在灾害或故障条件下的恢复力优化设计，提升实际电网应对突发事件的能力；③为移动储能系统在智能配电网中的应用提供理论依据和技术支持。; 阅读建议：建议读者结合提供的Matlab代码逐模块分析，重点关注目标函数建模、约束条件设置以及智能算法的实现细节。同时推荐参考文中提及的MPS预配置与动态调度上下两部分，系统掌握完整的技术路线，并可通过替换不同算法或测试系统进一步拓展研究。
SQL基础培训资料：-临时表和表变量选择.docx
01-06
SQL基础培训资料：-临时表和表变量选择.docx
C# DateTimePicker开发
01-06
先看效果： https://pan.quark.cn/s/3756295eddc9 在C#软件开发过程中，DateTimePicker组件被视为一种常见且关键的构成部分，它为用户提供了图形化的途径来选取日期与时间。 此类控件多应用于需要用户输入日期或时间数据的场景，例如日程管理、订单管理或时间记录等情境。 针对这一主题，我们将细致研究DateTimePicker的操作方法、具备的功能以及相关的C#编程理念。 DateTimePicker控件是由.NET Framework所支持的一种界面组件，适用于在Windows Forms应用程序中部署。 在构建阶段，程序员能够通过调整属性来设定其视觉形态及运作模式，诸如设定日期的显示格式、是否展现时间选项、预设的初始值等。 在执行阶段，用户能够通过点击日历图标的下拉列表来选定日期，或是在文本区域直接键入日期信息，随后按下Tab键或回车键以确认所选定的内容。 在C#语言中，DateTime结构是处理日期与时间数据的核心，而DateTimePicker控件的值则表现为DateTime类型的实例。 用户能够借助`Value`属性来读取或设定用户所选择的日期与时间。 例如，以下代码片段展示了如何为DateTimePicker设定初始的日期值：```csharpDateTimePicker dateTimePicker = new DateTimePicker();dateTimePicker.Value = DateTime.Now;```再者，DateTimePicker控件还内置了事件响应机制，比如`ValueChanged`事件，当用户修改日期或时间时会自动激活。 开发者可以注册该事件以执行特定的功能，例如进行输入验证或更新关联的数据：``...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值