[大话设计模式C++版] 第6章 穿什么有这么重要？ —— 装饰模式

已于 2022-10-06 22:57:43 修改
阅读量387 收藏 2
点赞数
分类专栏： 设计模式 文章标签： 设计模式 c++ java
于 2022-10-05 21:27:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40743639/article/details/127172461
版权

源码可以在这里找到 大话设计模式C++版

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

小菜第一份代码

//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：大量的重复代码，注释相同的地方，代码重复。

如何消除重复？

  1. 组合优于继承，下面的组合代码等价于上面的继承代码。
//扩展操作
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);
        //额外的加密操作...
    }
};
  1. 当某个地方声明的类都是某一个类的子类时，则把这个类就声明为那个父类，未来可以使用多态来动态绑定到具体子类上。
//扩展操作
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);  //加密缓存文件流
}
  1. 如果一个类的多个子类拥有同一个字段，那么应该把这个字段往上提。
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模式应用的要点在于解决”主题类在多个方向上的扩展功能“——是为”装饰“的含义。
一个小黑酱
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【资源免费下载】Java代码积累丨大话设计模式（Java实现版本）、线程协作
10-31
设计模式参考《大话设计模式》 工厂简单模式 创造型模式 工厂方法模式 抽象工厂模式 原型模式 建造者模式 单例模式 结构型模式 队列模式 桥接模式 组合模式 装饰模式 外观模式 享元模式 代理模式 行为模式（类行为...
[大话设计模式C++版] 第1章 UML类图
weixin_40743639的博客
10-24 1076
[大话设计模式C++版] 第1章 UML类图
[大话设计模式C++版] 第1章 代码无错就是优？—— 简单工厂模式
weixin_40743639的博客
10-02 744
大话设计模式第1章 简单工厂模式 Qt C++版
大话设计模式 —— 第九章《原型模式》C++ 代码实现
TAOTAO
04-03 353
目录 概述 定义 优点 缺点 使用场景 注意事项 浅复制和深复制 概述 在某些情况下，可能不希望反复使用类的构造函数创建许多不同的对象，而是希望使用该类创建一个对象后，以该对象为原型得到该对象的若干个副本 （ 分深拷贝 和 浅拷贝）。也就是说，当一个对象定义为原型对象时，该对象中提供了一个 Clone 方法，然后该原型对象调用此方法可以“克隆”原型对象得到一个新对象。原型对象 ...
大话设计模式C++版——简单工厂模式
weixin_45014831的博客
11-02 416
文章目录前言一、包含的角色二、优势1.实现了松耦合二、C++实现1.代码总结 前言 用C++把大话设计模式中的案例复现 一、包含的角色 简单工厂包含三个角色： （1）工厂类Factory：工厂工厂类是用来制造产品的。因此，在Factory中有一个用于制造产品的Create函数或者Generate函数之类的函数。这个函数能够根据“标识符”的不同生成不同的ConcreateProduct，当然这些ConcreateProduct都是继承自AbstractProduct的。 （2）抽象产品类Abstrac.
大话设计模式学习笔记C++
fazstyle的博客
10-26 652
一、简单工厂模式 1、面向对象的好处 通过封装、继承、多态把程序的耦合度降低。 用设计模式使得程序更加的灵活，容易修改，并且易于复用。 如实现计算机的功能时，将业务逻辑与界面逻辑分开，让它们的耦合度下降。只有分开，才可以达到容易维护或扩展。 2、紧耦合VS.送耦合 计算器有加、减、乘、除等功能，如果在实现加法功能时，影响到乘法功能，则说明两者的的耦合性高，否则为松耦合。 3、简单工厂模式 封装、继承和多态。 用类的方式实现封装，如加法类、减法类等；用父类、子类的方式实现继承，如运算类
《大话设计模式》Java版的实现案例源码.zip
最新发布
02-20
《大话设计模式》Java版的实现案例源码.zip
设计模式之《大话设计模式》.pptx
10-31
设计模式之《大话设计模式》.pptx
Android之大话设计模式——：抽象工厂模式借鉴.pdf
12-25
Android之大话设计模式——：抽象工厂模式借鉴.pdf
大话设计模式-完整设计模式介绍
10-23
大话设计模式 完整设计模式介绍
设计模式C++版(pdf版)
10-21
设计模式精解－GoF 23种设计模式解析附C++实现源码
【学习笔记】C++下的策略模式（程杰-大话设计模式）
野生C++程序员
05-12 612
《大话设计模式》中策略模式学习笔记
大话设计模式学习 C++
南柯一梦的博客
11-11 535
大话设计模式学习的c++练手记录
《大话设计模式》C++实现：01 简单工厂模式（优化，使用宏注册工厂）
qq_29567701的博客
08-21 526
一、代码 1、结果 1.1 main.cpp #include "Operation.h" #include "OperationFactory.h" #include "OperationAdd.h" #include "OperationSub.h" #include "OperationMul.h" #include "OperationDiv.h" void test() { double numA = 200, numB = 100; cout << "A = " <&lt
《大话设计模式》C++设计模式
m0_37701448的博客
12-17 737
转载地址：https://www.jianshu.com/p/c951adc6aafb 我是看《大话设计模式》学的设计模式，书上的例子是用C#写的，并且为了清晰地表达设计模式的优点写的代码很庞大。我这里用C++改写一下，做一下简化，以方便复习和总结，顺带练习一下画UML图。 这里可以认为所有的类都是定义在服务端的，而main函数在客户端。 简单工厂模式 三种工厂模式都是创建型的设计模式。现在...
设计模式系列（大话设计模式c++版）——观察者模式
月照大江流的博客
07-16 370
设计模式系列（大话设计模式c++版）——观察者模式模式定义模式特点模式实现 模式定义 让我们来看看《大话设计模式》这本书中对于观察者模式的定义：其又叫发布—订阅模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当这个主题对象在状态发生变化时，会通知所有的观察者对象，是他们可以随之自动更新自己的状态。 其组成大概分为至少4个部分：观察者接口、发布者接口、一般是1个发布者、不止一个的观察者 模式特点 将一个系统分割成一系列相互协作的类，同时又需要维护类间的一致性，观察者模式可以避免各类
李建忠设计模式——装饰模式
chunchunlaila的博客
05-12 181
1.“单一职责”模式 在软件组件的设计中，如果责任划分不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。 典型模式 Decorator Bridge 2.装饰模式（Decorator） 1.动机 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增大（扩展功能的增多），各种子类的组合（扩展功能的组合），会导致更多子类的膨胀。 如何使“对象功能的扩展”能够根据需要
装饰模式（大话设计模式例子C++实现）
蹦跶跶
08-21 193
装饰模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。有时我们希望给某个对象而不是整个类添加一些功能。比如有一个手机，允许你为手机添加特性，比如增加挂件、屏幕贴膜等。一种灵活的设计方式是，将手机嵌入到另一对象中，由这个对象完成特性的添加，我们称这个嵌入的对象为装饰。这个装饰与它所装饰的组件接口一致，因此它对使用该组件的客户透明。下面给出装饰模式的UML图。 ———————————————— 在这种设计中，手机的装饰功能被独立出来，可以单独发展，进而简化了具体手机类的设计
[大话设计模式C++版] 附录A 面向对象基础
weixin_40743639的博客
10-02 539
[大话设计模式C++版] 附录A 面向对象基础
大话设计模式 c++
09-13
行为型模式包括策略模式、观察者模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式和解释器模式。 每种设计模式都有其特定的应用场景和解决方案，可以根据实际需求选择合适的设计模式来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值