null - 程序员宅基地

[大话设计模式C++版] 第6章穿什么有这么重要？ —— 装饰模式-程序员宅基地

用控制台写可以给人打扮服装的代码

小菜第一份代码

//Person.h
#pragma execution_character_set("utf-8")
class Person
{
    
public:
    Person(QString name) {
    
        m_name = name;
    }
    void WearTShirts() {
    
        qDebug() << "大T恤 ";
    }
    void WearBigTrouser() {
    
        qDebug() << "垮裤 ";
    }
    void WearSneakers() {
    
        qDebug() << "破球鞋 ";
    }
    void WearSuit() {
    
        qDebug() << "西装 ";
    }
    void WearTie() {
    
        qDebug() << "领带 ";
    }
    void WearLeatherShoes(){
    
        qDebug() << "皮鞋 ";
    }
    void Show() {
    
        qDebug() << "装扮的的" + m_name;
    }

private:
    QString m_name;
};

//main.cpp
#pragma execution_character_set("utf-8")
#include <QCoreApplication>
#include "Person.h"
#include <QDebug>

int main(int argc, char *argv[])
{
    
    QCoreApplication a(argc, argv);
    Person* xc = new Person("小菜");

    qDebug() << "\n第一种装扮：";
    xc->WearTShirts();
    xc->WearBigTrouser();
    xc->WearSneakers();
    xc->Show();

    qDebug() << "\n第二种装扮：";
    xc->WearSuit();
    xc->WearTie();
    xc->WearLeatherShoes();
    xc->Show();
    
    delete xc;
    return a.exec();
}

人和衣服耦合了，如果要写给”超人“打扮的代码，则需要修改 Person类 ，违反了开放-封闭原则

需要把衣服和人分开，单独写个衣服类

小菜第二份代码

//Person.h
class Person
{
    
public:
    Person(QString name) {
    
        m_name = name;
    }
    void Show() {
    
        qDebug() << "装扮的的" + m_name;
    }

private:
    QString m_name;
};

//Finery.h
#include <QDebug>

class Finery
{
    
public:
    //Finery();
    virtual void Show() = 0;
    virtual ~Finery() {
    }
};

class TShirts : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "大T恤 ";
    }
};

class BigTrouser : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "垮裤 ";
    }
};

class Sneakers : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "破球鞋 ";
    }
};

class Suit : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "西装 ";
    }
};

class Tie : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "领带 ";
    }
};

class LeatherShoes : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "皮鞋 ";
    }
};

//main.cpp
#include <QCoreApplication>
#include "Person.h"
#include "Finery.h"
#include <QDebug>

int main(int argc, char *argv[])
{
    
    QCoreApplication a(argc, argv);

    Person* xc = new Person("小菜");
    qDebug() << "\n第一种装扮：";
    Finery* dtx = new TShirts();
    Finery* kk = new BigTrouser();
    Finery*  pqx = new Sneakers();
    dtx->Show();
    kk->Show();
    pqx->Show();
    xc->Show();

    qDebug() << "\n第二种装扮：";
    Finery* xz = new Suit();
    Finery* ld = new Tie();
    Finery* px = new LeatherShoes();
    xz->Show();
    ld->Show();
    px->Show();
    xc->Show();

    delete dtx;
    delete kk;
    delete pqx;
    delete xz;
    delete ld;
    delete px;
    delete xc;

    return a.exec();
}

客户端代码很别扭，好像就是把一件一件衣服当着所有人的面穿了起来，这个穿衣服的过程不应该在客户端中暴露出来。
使用装饰模式来为 Person类 穿上衣服

小菜第三份代码

//Person.h
#include <QString>

class Person
{
    
public:
    Person() {
    }
    Person(QString name) {
    
        m_name = name;
    }
    virtual void Show() {
    
        qDebug() << "装扮的的" + m_name;
    }
    virtual ~Person() {
    }

private:
    QString m_name;
};

#include <QDebug>
#include "Person.h"

class Finery : public Person
{
    
protected:
    Person* m_component = nullptr;
public:
    virtual void Decorate(Person* component) {
    
        m_component = component;
    }
    virtual void Show() override {
    
        if (m_component != nullptr) {
    
            m_component->Show();
        }
    }
    virtual ~Finery() {
    }
};

class TShirts : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "大T恤 ";
        Finery::Show();
    }
    virtual ~TShirts() {
    }
};

class BigTrouser : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "垮裤 ";
        Finery::Show();
    }
};

class Sneakers : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "破球鞋 ";
        Finery::Show();
    }
};

class Suit : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "西装 ";
        Finery::Show();
    }
};

class Tie : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "领带 ";
        Finery::Show();
    }
};

class LeatherShoes : public Finery
{
    
public:
    virtual void Show() override {
    
        qDebug() << "皮鞋 ";
        Finery::Show();
    }
};

//main.cpp
#include <QCoreApplication>
#include "Person.h"
#include "Finery.h"
#include <QDebug>

int main(int argc, char *argv[])
{
    
    QCoreApplication a(argc, argv);

    Person* xc = new Person("小菜");
    qDebug() << "\n第一种装扮：";
    TShirts* dtx = new TShirts();
    BigTrouser* kk = new BigTrouser();
    Sneakers*  pqx = new Sneakers();
    pqx->Decorate(xc);
    kk->Decorate(pqx);
    dtx->Decorate(kk);
    dtx->Show();

    qDebug() << "\n第二种装扮：";
    LeatherShoes* px = new LeatherShoes();
    Tie* ld = new Tie();
    Suit* xz = new Suit();
    px->Decorate(xc);
    ld->Decorate(px);
    xz->Decorate(ld);
    xz->Show();

    delete dtx;
    delete kk;
    delete pqx;
    delete xz;
    delete ld;
    delete px;
    delete xc;

    return a.exec();
}

上面就是大话设计模式关于 装饰模式 的代码推演过程，本人感觉这个案例对 装饰模式 的优点描述的不是特别好，因此下面再记录了李建忠老师视频中装饰模式的笔记内容。

Decorator装饰模式 [李建忠C++笔记]

"单一职责"模式

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

动机（Motivation）

在某些情况下我们可能会”过度地使用继承来扩展对象的功能“，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且锁着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。
如何使”对象功能的扩展“能够根据需要来动态地实现？通过是避免”扩展功能的增多“带来的子类膨胀问题？从而使得任何”功能扩展变化“所导致的影响降为最低？

代码重构流程

//decorator1.cpp
//业务操作
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(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);
        //额外的加密操作...
    }
};

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(char data) {
    
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Write(data);
        //额外的加密操作...
        //额外的缓冲操作...
    }
};

void Process()
{
    
    //编译时装配
    CryptoFileStream *fs1 = new CryptoFileStream();
    BufferedFileStream *fs2 = new BufferedFileStream();
    CryptoBufferedFileStream *fs3 = new CryptoBufferedFileStream();
}

上述代码有什么问题？

在这里插入图片描述

问题1：大量的子类产生。

问题2：大量的重复代码，注释相同的地方，代码重复。

如何消除重复？

组合优于继承，下面的组合代码等价于上面的继承代码。

//扩展操作
class CryptoFileStream
{
    
    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);
        //额外的加密操作...
    }
};

class CryptoNetworkStream
{
    
    NetworkStream* 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);
        //额外的加密操作...
    }
};

class CryptoMemoryStream
{
    
    MemoryStream* 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);
        //额外的加密操作...
    }
};

当某个地方声明的类都是某一个类的子类时，则把这个类就声明为那个父类，未来可以使用多态来动态绑定到具体子类上。

//扩展操作
class CryptoFileStream
{
    
    Stream* stream;  //= new FileStream();
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);
        //额外的加密操作...
    }
};

class CryptoNetworkStream
{
    
    Stream* stream;  //= new NetworkStream();
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);
        //额外的加密操作...
    }
};

class CryptoMemoryStream
{
    
    Stream* stream;  //= new MemoryStream();
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);
        //额外的加密操作...
    }
};

经过了上述操作，上面三个类除了名字不一样，其他都一样，因此可以减少成一个类

class CryptoStream : public Stream  //为了满足Stream的接口规范，要继承Stream
{
    
    Stream* stream;  //= new FileStream() or = new NetworkStream() or = new MemoryStream();
public:
    CryptoStream(Stream* stm):stream(stm) {
    }  //构造函数，初始化stream
    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 Stream  //为了满足Stream的接口规范，要继承Stream
{
    
    Stream* stream;  //= new FileStream() or = new NetworkStream() or = new MemoryStream();
public:
    CryptoStream(Stream* stm):stream(stm) {
    }  //构造函数，初始化stream
    virtual char Read(int number) {
    
        //额外的缓存操作...
        stream->Read(number);
    }
    virtual void Seek(int position) {
    
        //额外的缓存操作...
        stream->Seek(position);
        //额外的缓存操作...
    }
    virtual void Write(char data) {
    
        //额外的缓存操作...
        stream->Write(data);
        //额外的缓存操作...
    }
};

客户端代码

void Process()
{
    
    //运行时装配
    FileStream* s1 = new FileStream();  //文件流
    CryptoStream* s2 = new CryptoStream(s1);  //加密文件流
    BufferedStream* s3 = new BufferedStream(s1);  //缓存文件流
    BufferedStream* s4 = new BufferedStream(s2);  //加密缓存文件流
}

如果一个类的多个子类拥有同一个字段，那么应该把这个字段往上提。

class 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(char data) {
    
        //额外的加密操作...
        stream->Write(data);
        //额外的加密操作...
    }
};

class BufferedStream : public DecoratorStream {
    
public:
    BufferedStream(Stream* stm) : DecoratorStream(stm) {
    }
    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模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）。——《设计模式》GoF

在这里插入图片描述

红色的部分是稳定的，蓝色的部分是变化的。ConcreteComponent 是 FileStream NetworkStream MemoryStream 。 ConcreteDecoratorA 和 ConcreteDecoratorB 是 CryptoStream 和 BufferedStream

要点总结

通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的”灵活性差“和”多子类衍生问题“。
Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上有表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
Decorator模式的目的并非解决”多子类衍生的多继承“问题，Decorator模式应用的要点在于解决”主题类在多个方向上的扩展功能“——是为”装饰“的含义。

本文链接：https://blog.csdn.net/weixin_40743639/article/details/127172461

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

王斌老师的博客_王斌 github-程序员宅基地

文章浏览阅读480次。http://blog.sina.com.cn/s/blog_736d0b9101018cgc.html_王斌 github

ACM OJ Collection_htt//acm.wydtang.top/-程序员宅基地

文章浏览阅读737次。原文来自：http://blog.csdn.net/hncqp/article/details/4455263 ACM OJ Collection（排名不分先后）：中国：浙江大学（ZJU）：http://acm.zju.edu.cn/北京大学（PKU）：htt_htt//acm.wydtang.top/

ios 自己服务器苹果支付_修复苹果IOS支付-程序员宅基地

文章浏览阅读467次。更新记录1.0.0(2019-07-01)插件简介专门用来修复苹果IOS支付时出现"您已购买此App内购买项目。此项目将免费恢复"。问题描述首先在IOS平台里面创建“APP内购买项目”，选择的是“消耗型项目”，然后用uni-app官方的支付api进行支付，多支付几次，有时候就会出现提示“您已购买此App内购买项目。此项目将免费恢复”,特别是在沙盒测试里面支付很大几率出现,我明明选的是消耗型项目，应..._ios开发苹果支付恢复权益

spring MVC mock类单元测试（controller）_mvcmock-程序员宅基地

文章浏览阅读5.6k次。Spring从J2EE的Web端为每个关键接口提供了一个mock实现：MockHttpServletRequest几乎每个单元测试中都要使用这个类，它是J2EE Web应用程序最常用的接口HttpServletRequest的mock实现。MockHttpServletResponse此对象用于HttpServletRespons_mvcmock

【我的世界Minecraft-MC】常见及各种指令大杂烩【2022.8版】_summon生成掉落物-程序员宅基地

文章浏览阅读8.5k次，点赞7次，收藏22次。execute as @a at @s run clear @s minecraft:dark_oak_planks{display:{Name:“{“text”:“第三关[阴森古堡]”,“color”:“red”,“italic”:false}”,color:“16711680”},Enchantments:[{id:“protection”,lvl:1}],Unbreakable:1b} 1。Lore:[“{“text”:“免费”,“color”:“blue”,“italic”:false}”]..._summon生成掉落物

CentOS 7安装教程（图文详解）_centos 安装-程序员宅基地

文章浏览阅读10w+次，点赞487次，收藏2.1k次。CentOS 7安装教程：准备：软件：VMware Workstation 镜像文件：CentOS-7-x86_64-bin-DVD1.iso （附：教程较为详细，注释较多，故将操作的选项进行了加粗字体显示。） 1、文件--新建虚拟机--自定义 2、..._centos 安装

[大话设计模式C++版] 第6章穿什么有这么重要？ —— 装饰模式-程序员宅基地

小菜第一份代码

小菜第二份代码

小菜第三份代码

Decorator装饰模式 [李建忠C++笔记]

"单一职责"模式

动机（Motivation）

代码重构流程

模式定义

要点总结

智能推荐

王斌老师的博客_王斌 github-程序员宅基地

ACM OJ Collection_htt//acm.wydtang.top/-程序员宅基地

ios 自己服务器苹果支付_修复苹果IOS支付-程序员宅基地

spring MVC mock类单元测试（controller）_mvcmock-程序员宅基地

【我的世界Minecraft-MC】常见及各种指令大杂烩【2022.8版】_summon生成掉落物-程序员宅基地

CentOS 7安装教程（图文详解）_centos 安装-程序员宅基地

随便推点

Github项目分享——免费的画图工具drow，前端插件化面试_draw github画图-程序员宅基地

如何开始学习人工智能？入门的学习路径和资源是什么？_人工智能学习路径-程序员宅基地

Unity3D 导入资源_unity怎么导入压缩包-程序员宅基地

jqgrid 服务器端验证,javascript – jqgrid服务器端错误消息/验证处理-程序员宅基地

白山头讲PV: 用calibre进行layout之间的比对-程序员宅基地

java exit方法_Java：如何测试调用System.exit（）的方法？-程序员宅基地

推荐文章

热门文章

相关标签

[大话设计模式C++版] 第6章 穿什么有这么重要？ —— 装饰模式-程序员宅基地

小菜第一份代码

小菜第二份代码

小菜第三份代码

Decorator装饰模式 [李建忠C++笔记]

"单一职责"模式

动机（Motivation）

代码重构流程

模式定义

要点总结

智能推荐

随便推点

推荐文章

热门文章

相关标签

[大话设计模式C++版] 第6章穿什么有这么重要？ —— 装饰模式-程序员宅基地