设计模式7-装饰模式

已于 2024-07-12 09:11:13 修改
阅读量853 收藏 13
点赞数 12
分类专栏： 设计模式 c/c++ 文章标签： 设计模式
于 2024-07-09 01:09:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41810539/article/details/140281365
版权

设计模式7-装饰模式

写在前面

单一职责模式：

  • 在软件组件的设计中，如果责任划分的不清晰，使用记者得到的结果往往是跟随需求的变化，以及子类的增加而急剧膨胀。同时充值的重复代码。这个时候就应该责任划分清楚。使每个类负责自己的责任模块。这才是单一职责模式的关键。

  • 典型模式：装饰模式（decorator model），桥模式（Bridge model）

动机

  • 在某些情况下，我们可能会过多的使用技巧来扩展对象的功能。由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性。随着子类的增多，也就是扩展功能增多。各种子类的组合（扩展功能组合）。

  • 那么如何使对象功能的扩展能够根据需要来动态的实现？而且同时避免扩展功能增多带来的子类膨胀问题。从而使得任何功能扩展变化所导致的影响降为最低。这就是装饰模式的目的。

模式定义

动态组合的给一个对象增加一些额外的职责，就增加工人而言，装饰模式比生成子类更加灵活。也就是消除重复代码以及减少子类个数。

结构

在这里插入图片描述

在观察者模式中有如下角色：

Subject（抽象主题/被观察者）： 抽象主题角色把所有观察者对象保存在一个集合里，每个主题可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSubject（具体主题/具体被观察者）： 该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
Observer（抽象观察者）： 观察者的抽象类，定义了一个更新接口，使得在得到主题更改通知时更新自己。
ConcreteObserver（具体观察者）： 实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。在具体观察者中维护一个指向具体目标对象的引用，存储具体观察者的有关状态，这些状态需要与具体目标保持一致。

代码推导

原始代码

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

}

这段代码存在几个缺陷。主要包括类的继承结构复杂，重复代码多，扩展性差等问题。

缺陷分析：

在这里插入图片描述
从上述图像可以看出，按照继承模式去写子类。那么子类的数量将会是1个抽象stream类 ，n(此时n=3)个基础子类，n*m个扩展子类，子类与子类间功能还会交叉。

1.类结构复杂。

  • 类继承关系较为复杂，多个类之间存在多重继承(如CryptoFileStream和BufferedFileStream)，且同一类的不同变种都要各自继承主类(FileStream)。
  • 这种设计导致继承树较为复杂，难以维护和扩展。

2.重复代码多

  • CryptoFileStream、CryptoNetworkStream、CryptoMemoryStream中的加密操作代码几乎相同。
  • BufferedFileStream、BufferedNetworkStream、BufferedMemoryStream中的缓冲操作代码也基本一致。

3.扩展性差

  • 如果需要增加新的功能，如压缩操作，需要再新增大量类似的类（如CryptoBufferedCompressedFileStream等），导致类的数量急剧增加，扩展性极差。

解决

那么按照继承的逻辑将加密功能以虚函数的形式写入到基类中，有需要重写加密函数不就行了？

将加密功能作为虚函数写入基类的确是一种方式，但是这种方法会有一些缺点，特别是在职责分离和代码扩展性方面。

问题分析

1. 职责不单一：

  • 如果将加密功能直接写入基类，那么基类需要承担多种职责：基本流操作（读、写、定位）和加密操作。这违反了单一职责原则（SRP），即一个类应该只有一个引起其变化的原因。

2. 代码复杂度增加：

  • 基类中加入加密相关的虚函数后，所有子类都需要考虑加密操作，即使某些子类并不需要加密功能。这会增加代码的复杂度。

3. 扩展性差：

  • 如果未来需要添加新的功能（例如压缩、日志记录等），那么基类将会变得越来越臃肿，不同子类需要覆盖不同的虚函数，扩展性差。

选择装饰模式的理由

选择装饰器模式的理由主要有以下几点：

1. 职责分离（Single Responsibility Principle）

装饰器模式允许将不同的功能（如加密、缓冲）分离到不同的类中，从而使每个类只负责一种职责。这符合单一职责原则（Single Responsibility Principle），使代码更易于理解、维护和扩展。

2. 动态扩展功能

装饰器模式可以在运行时动态地组合对象，添加或移除功能，而不需要修改对象本身。这提供了比继承更灵活的功能扩展方式。例如，可以动态地对一个流对象添加加密功能、缓冲功能，甚至多个功能的组合。

3. 避免类爆炸

如果通过继承来实现功能扩展，每种功能组合都需要一个新的子类，类的数量会迅速增加，导致类爆炸问题。装饰器模式通过将功能封装在独立的装饰器类中，避免了大量的子类定义。

4. 开闭原则（Open/Closed Principle）

装饰器模式使类对扩展开放，对修改关闭。可以通过添加新的装饰器类来扩展功能，而无需修改已有的类。这符合开闭原则，提高了代码的可扩展性和灵活性。

5. 更好的组合复用

装饰器模式允许通过不同的装饰器类进行自由组合，复用功能模块。例如，可以同时添加加密和缓冲功能，而无需创建一个专门的“加密缓冲流”类。

例子对比

继承方式的缺点：

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 CryptoFileStream : public FileStream {
    // 实现加密功能
};

class BufferedFileStream : public FileStream {
    // 实现缓冲功能
};

class CryptoBufferedFileStream : public 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 StreamDecorator : public Stream {
protected:
    Stream* stream;
public:
    StreamDecorator(Stream* strm) : stream(strm) {}
    virtual char Read(int number) {
        return stream->Read(number);
    }
    virtual void Seek(int position) {
        stream->Seek(position);
    }
    virtual void Write(char data) {
        stream->Write(data);
    }
};

// 加密装饰器
class CryptoStream : public StreamDecorator {
public:
    CryptoStream(Stream* strm) : StreamDecorator(strm) {}
    virtual char Read(int number) {
        // 额外的加密操作...
        return StreamDecorator::Read(number);
    }
    virtual void Seek(int position) {
        // 额外的加密操作...
        StreamDecorator::Seek(position);
        // 额外的加密操作...
    }
    virtual void Write(char data) {
        // 额外的加密操作...
        StreamDecorator::Write(data);
        // 额外的加密操作...
    }
};

// 缓冲装饰器
class BufferedStream : public StreamDecorator {
public:
    BufferedStream(Stream* strm) : StreamDecorator(strm) {}
    virtual char Read(int number) {
        // 额外的缓冲操作...
        return StreamDecorator::Read(number);
    }
    virtual void Seek(int position) {
        // 额外的缓冲操作...
        StreamDecorator::Seek(position);
        // 额外的缓冲操作...
    }
    virtual void Write(char data) {
        // 额外的缓冲操作...
        StreamDecorator::Write(data);
        // 额外的缓冲操作...
    }
};

// 使用示例
void Process() {
    Stream* fileStream = new FileStream();
    Stream* cryptoStream = new CryptoStream(fileStream);
    Stream* bufferedCryptoStream = new BufferedStream(cryptoStream);

    bufferedCryptoStream->Read(100);
    bufferedCryptoStream->Write('A');
    bufferedCryptoStream->Seek(10);

    delete bufferedCryptoStream; // 注意：需要确保正确删除链上的所有装饰器
    delete cryptoStream;
    delete fileStream;
}

详细说明

这段代码演示了如何使用装饰器模式来动态地为基本的文件流添加加密和缓冲功能。以下是代码的详细说明：

1. 基本流接口 Stream

Stream 是一个抽象基类，定义了三个纯虚函数：Read、Seek 和 Write。所有具体的流类都必须实现这些函数。

class Stream {
public:
    virtual char Read(int number) = 0;
    virtual void Seek(int position) = 0;
    virtual void Write(char data) = 0;
    virtual ~Stream() {}
};
2. 文件流实现 FileStream

FileStream 是一个具体的流类，继承自 Stream 并实现了 Read、Seek 和 Write 方法。具体的实现细节在代码中没有给出，但假设它们涉及对文件的读写操作。

class FileStream : public Stream {
public:
    virtual char Read(int number) {
        // 读文件流
    }
    virtual void Seek(int position) {
        // 定位文件流
    }
    virtual void Write(char data) {
        // 写文件流
    }
};
3. 装饰器基类 StreamDecorator

StreamDecorator 继承自 Stream，并持有一个指向 Stream 对象的指针 stream。StreamDecorator 通过调用 stream 指针的相应方法实现 Read、Seek 和 Write，从而将所有操作委托给被装饰的流对象。

class StreamDecorator : public Stream {
protected:
    Stream* stream;
public:
    StreamDecorator(Stream* strm) : stream(strm) {}
    virtual char Read(int number) {
        return stream->Read(number);
    }
    virtual void Seek(int position) {
        stream->Seek(position);
    }
    virtual void Write(char data) {
        stream->Write(data);
    }
};
4. 加密装饰器 CryptoStream

CryptoStream 继承自 StreamDecorator，并在调用 StreamDecorator 的 Read、Seek 和 Write 方法之前或之后添加额外的加密操作。

class CryptoStream : public StreamDecorator {
public:
    CryptoStream(Stream* strm) : StreamDecorator(strm) {}
    virtual char Read(int number) {
        // 额外的加密操作...
        return StreamDecorator::Read(number);
    }
    virtual void Seek(int position) {
        // 额外的加密操作...
        StreamDecorator::Seek(position);
        // 额外的加密操作...
    }
    virtual void Write(char data) {
        // 额外的加密操作...
        StreamDecorator::Write(data);
        // 额外的加密操作...
    }
};
5. 缓冲装饰器 BufferedStream

BufferedStream 继承自 StreamDecorator，并在调用 StreamDecorator 的 Read、Seek 和 Write 方法之前或之后添加额外的缓冲操作。

class BufferedStream : public StreamDecorator {
public:
    BufferedStream(Stream* strm) : StreamDecorator(strm) {}
    virtual char Read(int number) {
        // 额外的缓冲操作...
        return StreamDecorator::Read(number);
    }
    virtual void Seek(int position) {
        // 额外的缓冲操作...
        StreamDecorator::Seek(position);
        // 额外的缓冲操作...
    }
    virtual void Write(char data) {
        // 额外的缓冲操作...
        StreamDecorator::Write(data);
        // 额外的缓冲操作...
    }
};
6. 使用示例 Process

在 Process 函数中，首先创建一个 FileStream 对象，然后将其装饰为 CryptoStream 和 BufferedStream，最终形成一个既具有加密功能又具有缓冲功能的流对象。

void Process() {
    Stream* fileStream = new FileStream(); // 基本的文件流
    Stream* cryptoStream = new CryptoStream(fileStream); // 加密装饰
    Stream* bufferedCryptoStream = new BufferedStream(cryptoStream); // 缓冲装饰

    bufferedCryptoStream->Read(100); // 读取操作，包含加密和缓冲
    bufferedCryptoStream->Write('A'); // 写入操作，包含加密和缓冲
    bufferedCryptoStream->Seek(10); // 定位操作，包含加密和缓冲

    delete bufferedCryptoStream; // 注意：需要确保正确删除链上的所有装饰器
    delete cryptoStream;
    delete fileStream;
}

总结

  • 职责分离：每个装饰器类（如 CryptoStream 和 BufferedStream）只负责增加一个特定的功能，使得代码更符合单一职责原则。
  • 动态组合：通过层层包装，可以在运行时动态地为基本流对象添加多种功能（如加密和缓冲），提高了代码的灵活性和可扩展性。
  • 代码复用：装饰器类可以复用，避免了为每个功能组合创建大量子类的情况。

在这里插入图片描述

从上图可以看出此时类的结构为1+n+1+m。一个抽象类加上n个基础类，加上一个装饰类。再加上m个功能类。对比于修改之前类的层次。冗余的代码量大大减少同时也减少了子类的数量。

要点总结

  • 通过采用组合而非计件的方法，装饰模式实现了在运行时动态扩展对象功能的能力。而且可以根据需要扩展多功能，避免了使用继承带来的灵活性差和子类衍生问题。
  • 装饰器类在接口上表现为一个组合的继承关系。装饰器类继承了组合类所具有的接口但是在实现上又表现为组合关系。
  • 装饰器模式的目的并非解决多子类衍生的多继承问题。装饰器模式应用的要点在于解决主体内在多个方向上的扩展功能。就是装饰的含义。
郑同学zxc
关注
  • 12
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java常用设计模式-装饰器模式
08-26
Java 设计模式 - 装饰器模式 装饰器模式（Decorator Pattern）是一种结构性设计模式，它允许您在不影响同一类的其他对象的行为的情况下，静态或动态地向单个对象添加行为。该模式非常有用，当您想要在运行时添加或...
Java设计模式-装饰者模式
12-21
装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许在运行时给对象增加新的行为或责任，而无需修改其源代码。这种模式通过创建一个与原对象具有相同接口的新对象（装饰者），并把原对象作为其内部成员，...
Java设计模式 ---- 装饰模式
qq_48651377的博客
05-12 3924
一、什么是装饰模式？        装饰模式是一种用于替代继承的技术，它通过一种无须定义子类的方式给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。 定义：动态地给一个对象增加一些额外的职责。就扩展功能而言，装饰模式提供了一种比使用子类更加灵活的替代方案。 二、装饰模式结构与实现 1、结构 （1）Component（抽象构件）： 具体构件和抽象装饰类的共同父类。 （2）ConcreteComponent（具体构件）
C++设计模式----装饰器模式
精致的灰的博客
09-16 1741
装饰器模式
设计模式 - 装饰模式
Circ
04-16 4147
什么是装饰模式？ 装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。 适用范围 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。不改变接口的前提下，增强所考虑的类的性能。 何时使用： 1）需要扩展一个类的功能，或给一个类增加附加责任。 2）需要动态的给一个对象增加功能，这些功能可以再动态地撤销。 3）需要增加一些基本功能的排列组合而产生的非常大量的功能，从而使继承变得 不现实。 角色构成
设计模式---装饰器(Decorator)模式
honor_zhang的博客
09-07 2537
1 定义 装饰器（Decorator）模式，也称为包装（Wrapper）模式，是继承关系的一种替代方案。指在不改变对象结构的情况下，动态的给对象添加一些功能。 2 优缺点 2.1 优点 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果 装饰器模式完全遵守开闭原则 2.2 缺点 装饰器模式会增加许多子类，过度使用会增加程序得复杂性。 3 装饰器模式的结构与实现 装饰器模式的类图如下所示：
Java设计模式--装饰者模式
Boogie
05-21 3569
在学习Mybatis二级缓存时，了解到sqlsessin对象会使用到一个Executor和相应的CachingExecutor的装饰者模式。所以就来具体了解一下。 Mybatis二级缓存详解–》https://blog.csdn.net/luanlouis/article/details/41408341。 强烈推荐！！！ 接下来具体讨论装饰者模式： 装饰者模式定义： 动态地将责任...
设计模式-装饰者模式
chenduwei的博客
03-30 1613
装饰者模式动态地将额外责任附加到对象上。对于扩展功能，装饰者提供子类化之外的弹性替代方案。
C++设计模式-装饰模式
IT1995的博客
06-10 5099
目录 基本概念 代码和实例 基本概念 装饰模式是为已有功能动态地添加更多功能的一种方式。 当系统需要新功能的时候，是向旧系统的类中添加新代码。这些新代码通常装饰了原有类的核心职责或主要行为。 装饰模式的优点： 1. 把类中的装饰功能从类中搬移出去，这样可以简化原有的类； 2. 有效地把类的核心职责和装饰功能区分开了。而且可...
设计模式--装饰器模式
bighacker的博客
05-10 9520
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构，属于结构型设计模式，即对先有类进行包装。在不想增加很多子类的情况下扩展类。优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。缺点：多层装饰比较复杂。使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销具体实现：创建一个 ...
掌握装饰器模式：概念、用法及商品价格策略优化案例
热门推荐
张彦峰的博客
04-19 169万+
本文系统性地介绍了装饰器模式，从基本概念到实际应用，逐步展开。首先，阐述了装饰器模式的定义和功能，配合结构图和具体实例进行说明。接着，深入探讨了装饰器模式的基本用法，包括接口定义、具体对象初始化、装饰类设计以及其他具体装饰类的实现。在实际案例分析部分，我们通过构建一套商品价格策略优化方案，展示了装饰器模式的强大灵活性。案例步骤包括订单和商品属性类的建立、计算支付金额的接口和基本类设计、优惠券和红包计算类的实现，以及工厂类的组合应用。最后，通过实际操作演示，为读者提供了详实的学习参考和实践指导。
设计模式之代理模式分析使用
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
设计模式--装饰者模式java例子
02-06
装饰者模式是软件设计模式中的一种结构型模式，它的主要目的是动态地给对象添加新的功能，而无需修改原有代码。在Java中，装饰者模式通常通过继承和组合来实现，它提供了一种比继承更灵活的方式来扩展对象的功能。...
c++设计模式-结构型模式-装饰器模式
06-12
c++设计模式-结构型模式-装饰器模式；QT工程；c++简单源码； 装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
设计模式2-面向对象设计原则
qq_41810539的博客
06-19 951
变化是复用的天地。面向对象设计最大的优势在于抵御变化。重新认识面向对象。从宏观层面来看，面向对象的构建方式更能适应软件的变化。将变化所带来的影响减为最小。从微观层面来看面，面向对象的方式更强调这个类的责任。由于需求变化导致的增类型不应该影响原来类型的实现设计原则大于设计模式。可以通过设计原则发明设计模式.
gperftools工具
qq_41810539的博客
07-06 932
include // CPU Profiler 头文件#include // Heap Profiler 头文件。// 指定输出文件名。// 启动 Heap Profiler。// 启动 CPU Profiler。//停止 CPU Profiler。// pprof文本分析。
Qt 的Q_PROPERTY关键字
最新发布
qq_41810539的博客
07-08 857
为此，Qt 引入了元对象系统（Meta-Object System），允许在运行时对对象进行动态反射（reflection）。宏在类的声明中使用，Qt 的元对象编译器（moc，Meta-Object Compiler）会解析这些宏并生成额外的 C++ 代码来实现属性系统。是这个系统的一部分，它使得对象的属性可以被动态地获取和设置。宏是 Qt 框架中元对象系统的重要组成部分，它允许开发者在类中声明属性，使这些属性可以在运行时动态访问和操作。的详细说明，包括其由来、实现原理、特点、属性和应用。
C语言使用正则表达式
qq_41810539的博客
06-27 571
在C语言中，可以使用POSIX正则表达式库来匹配正则表达式。POSIX正则表达式库提供了标准的正则表达式处理函数，例如。以下是一个完整的示例程序，演示如何在C语言中使用POSIX正则表达式库进行正则表达式匹配。使用POSIX正则表达式库可以方便地在C语言中进行正则表达式匹配，满足各种文本处理需求。，可以用来编译、执行和释放正则表达式。函数执行正则表达式匹配。不适用于windows。函数编译正则表达式。函数释放正则表达式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值