设计模式 c++版（2）——工厂模式

最新推荐文章于 2024-08-17 15:55:28 发布
最新推荐文章于 2024-08-17 15:55:28 发布
阅读量419 收藏
点赞数
分类专栏： 设计模式 文章标签： c 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jecklin_online/article/details/82776390
版权

定义：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类

示例一：工厂方法模式（通用版）

1.类图8-2



2. 类图说明：

Product                抽象产品类，负责定义产品的共性，实现对事物最抽象的定义
Creator                 抽象创建类，即抽象工厂
ConcreteCreator  具体实现工厂，创建产品类

 

3. 代码清单8-8:

    **********  通用工厂，代码清单8-8: ***************//

#include <QCoreApplication>
#include <QDebug>
enum E_Product
{
    EConcreteProduct1 ,
    EConcreteProduct2
};

class Product       //产品类的公共方法
{
public:
    virtual void    method1() = 0;
    virtual void    method2() = 0;
};

class ConcreteProduct1:public Product   //具体产品类
{
public:
    virtual void    method1(){}
    virtual void    method2(){qDebug() << "ConcreteProduct1 method";}
};

class ConcreteProduct2:public Product   //具体产品类
{
public:
    virtual void    method1(){}
    virtual void    method2(){qDebug() << "ConcreteProduct2 method";}
};

class Creator       //抽象工厂类
{
public:
    virtual Product* createProduct(E_Product eenum) = 0;
    
};

class ConcreteCreator:public Creator    //具体工厂类
{
public:
    virtual Product* createProduct(E_Product eenum)
    {
        Product* product;
        switch(eenum)
        {
        case EConcreteProduct1:
            product = new ConcreteProduct1();
            break;
        case EConcreteProduct2:
            product = new ConcreteProduct2();
            break;
        }
        return product;      
    }

};




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

    Creator *creator = new ConcreteCreator();
    Product *product = creator->createProduct(EConcreteProduct1);
    product->method2();
    
    
    return a.exec();
}

 

示例二：女娲造人

 

1.类图8-1

2. 类图说明：

AbstractHumanFactory ：是一个抽象类，定义了一个八卦炉具有的整体功能
HumanFactory                ：为实现类，完成具体的任务——创建人类
Human                             ：接口是人类的总称，其三个实现类分别为三类人种
NvWa                                ：类是一个场景类，负责模拟这个场景，执行相关的任务

其中，定义每个人种都有两个方法：getColor(获得人的皮肤颜色) 和 talk(交谈)

 

3. 代码清单8-1:

    **********  女娲造人，代码清单8-1: ***************//
 #include <QCoreApplication>
#include <QDebug>
enum E_Human
{
    EBlackHuman     ,
    EYellowHuman    ,
    EWhiteHuman
};

class Human
{
public:
    virtual void    getColor() = 0; //每个人种的皮肤都有相应的颜色
    virtual void    talk()     = 0; //人类会说话
};

class BlackHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "Black";}
    virtual void    talk(){qDebug() << "Black talk";}
};

class YellowHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "Yellow";}
    virtual void    talk(){qDebug() << "Yellow talk";}
};

class WhiteHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "White";}
    virtual void    talk(){qDebug() << "White talk";}
};

class AbstractHumanFactory
{
public:
    virtual Human* createHuman(E_Human nnum) = 0;
};

class HumanFactory:public AbstractHumanFactory
{
public:
    virtual Human* createHuman(E_Human nnum)
    {
        Human* human;
        switch(nnum)
        {
        case EBlackHuman:
            human = new BlackHuman();
            break;
        case EYellowHuman:
            human = new YellowHuman();
            break;
        case EWhiteHuman:
            human = new WhiteHuman();
            break;
        }
        return human; 
    }
};



int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    AbstractHumanFactory *factory = new HumanFactory();
    Human *white = factory->createHuman(EWhiteHuman);
    white->getColor();
    white->talk();
    
    Human *yellow = factory->createHuman(EYellowHuman);
    yellow->getColor();
    yellow->talk();
    
    Human *black = factory->createHuman(EBlackHuman);
    black->getColor();
    black->talk();
    
    
    return a.exec();
}

 

三、工厂方法模式的应用

优点：

  1.  良好的封装性，代码结构清晰。一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以，不用知道创建对象的过程，降低模块间的耦合
  2. 扩展性好。在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以“拥抱变化”。例如，在例子中的，需要增加一个棕色人种，只需要增加一个BrownHuman类，工厂类不用任何修改就可以完成系统扩展
  3. 屏蔽产品类。产品类的实现如何变化，调用者不需要关心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不用发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。例如：数据库开发中，如果使用JDBC链接数据库，数据库从MySQL切换到Oracle，需要改动的地方就是切换一下驱动名称（前提条件是SQL语句是标准语句），其他都不需要修改，这是工厂方法灵活性的一个直接案例
  4. 典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不关心，符合迪米特法则，不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；还符合里氏替换原则，使用产品子类替换产品父类

 

四、工厂方法的使用场景

  1. 工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，但需要慎重地考虑是否要增加一个工厂类进行管理，增加代码的复杂度
  2. 需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。万物皆对象，那万物也就皆产品类。例如，需要设计一个连接邮件服务器的框架，有三种网络协议可供选择：POP3, IMAP, HTTP，我们就可以把这三种连接方法作为产品类，定义一个接口如 IConnectMail，然后定义对邮件的操作方法，用不同的方法实现是哪个具体的产品类（也就是连接方式）再定义一个工厂方法，按照不同的传入条件，选择不同的链接方式。如此设计，可以做到完美的扩展，如叩谢邮件服务器提供了 WebService 接口，那我们只要增加一个产品类就可以了
  3. 可以使用在异构项目中，通过WebService与一个非C++的项目交互
  4. 可以使用在测试驱动开发的框架下。例如，测试一个类A，就需要把与类A有关联关系的类B也同时产生出来，我们可以使用工厂方法把类B虚拟出来，避免类A与类B的耦合

 

五、工厂方法的扩展

工厂模式有很多扩展，下面介绍4种

 

5-1. 缩小为简单工厂模式

场景：一个模块仅需要一个工厂类，没有必要把他产生出来，使用静态的方法就可以了，根据这一要求，把上例中的 AbstarctHumanFactory 修改一下

 

示例三：简单工厂模式

1. 类图8-3

分析：在类图中去掉了 AbstarctHumanFactory 抽象类，同时把 createHuman 方法设置为静态类型，简化了创建过程


2. 代码清单8-13:

    **********  1.扩展：简单工厂模式，代码清单8-13: ***************//


enum E_Human
{
    EBlackHuman     ,
    EYellowHuman    ,
    EWhiteHuman
};

class Human
{
public:
    virtual void    getColor() = 0; //每个人种的皮肤都有相应的颜色
    virtual void    talk()     = 0; //人类会说话
};

class BlackHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "Black";}
    virtual void    talk(){qDebug() << "Black talk";}
};

class YellowHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "Yellow";}
    virtual void    talk(){qDebug() << "Yellow talk";}
};

class WhiteHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "White";}
    virtual void    talk(){qDebug() << "White talk";}
};

class HumanFactory
{
public:
    static Human* createHuman(E_Human nnum)
    {
        Human* human;
        switch(nnum)
        {
        case EBlackHuman:
            human = new BlackHuman();
            break;
        case EYellowHuman:
            human = new YellowHuman();
            break;
        case EWhiteHuman:
            human = new WhiteHuman();
            break;
        }
        return human; 
    }
};



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

    
    Human *white = HumanFactory::createHuman(EWhiteHuman);
    white->getColor();
    white->talk();
    
    Human *yellow = HumanFactory::createHuman(EYellowHuman);
    yellow->getColor();
    yellow->talk();
    
    Human *black = HumanFactory::createHuman(EBlackHuman);
    black->getColor();
    black->talk();
    
    return a.exec();
}

 

5-2. 升级为多个工厂类

场景：当我们在做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有的产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。例如，一个产品类具有5个具体实现，每个实现类的初始化（不仅仅是new,初始化包括new一个对象，并对对象设置一定的初始值）方法都不相同，如果卸载一个工厂方法中，势必会导致该方法巨大
解决：考虑到需要结构清晰，我们就为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联。我们还以女娲造人为例，每个人种（具体的产品类）都对应了一个创建者，每个创建者都独立负责创建对应的产品对象，符合单一职责原则。

 

示例四：多个工厂类

1. 类图8-4

 

2. 代码清单8-14:

    **********  2.扩展：多个工厂模式，代码清单8-14:***************//



class Human
{
public:
    virtual void    getColor() = 0; //每个人种的皮肤都有相应的颜色
    virtual void    talk()     = 0; //人类会说话
};

class BlackHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "Black";}
    virtual void    talk(){qDebug() << "Black talk";}
};

class YellowHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "Yellow";}
    virtual void    talk(){qDebug() << "Yellow talk";}
};

class WhiteHuman:public Human
{
public:
    virtual void    getColor(){qDebug() << "White";}
    virtual void    talk(){qDebug() << "White talk";}
};

class AbstractHumanFactory
{
public:
    virtual Human* createHuman() = 0;
};

class BlackHumanFactory:public AbstractHumanFactory
{
public:
    virtual Human* createHuman()
    {
        Human* human;
        human = new BlackHuman();
        return human;
    }
};

class YellowHumanFactory:public AbstractHumanFactory
{
public:
    virtual Human* createHuman()
    {
        Human* human;
        human = new YellowHuman();
        return human;
    }
};

class WhiteHumanFactory:public AbstractHumanFactory
{
public:
    virtual Human* createHuman()
    {
        Human* human;
        human = new WhiteHuman();
        return human;
    }
};




int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    AbstractHumanFactory *wFactory = new WhiteHumanFactory();
    Human *white = wFactory->createHuman();
    white->getColor();
    white->talk();
    
    AbstractHumanFactory *yFactory = new YellowHumanFactory();
    Human *yellow = yFactory->createHuman();
    yellow->getColor();
    yellow->talk();
    
    AbstractHumanFactory *bFactory = new BlackHumanFactory();
    Human *black = bFactory->createHuman();
    black->getColor();
    black->talk();
    

    
    return a.exec();
}

 

分析：每一个产品类都对应了一个创建类，好处是创建类的职责清晰，而且结构简单，但是给可扩展性和可维护性带来了影响。比如，如果要扩展一个产品类，就需要建立一个响应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量相同，维护时需要考虑两个对象之间的关系。
注：在复杂的应用中一般采用多工厂的方法，然后再增加一个协调类，避免调用者与各个子工厂交流，协调类的作用是封装工厂类，对高层模块提供统一的访问接口


5-3. 替代单例模式

场景：单例博士的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象

 

示例五：替代单例模式

1. 类图8-5

2. 类图说明：

Singleton 定义了一个private 的无参构造函数，目的是不允许通过new的方式创建一个对象。Singleton保证不能通过正常的渠道建立一个对象，那么使用SingletonFactory通过反射方式创建。通过获得类构造器，然后设置访问权限，生成一个对象，然后提供外部访问，保证内存中的对象唯一。
分析：以下通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。


3. 代码清单8-15:

#include <QCoreApplication>
#include <QDebug>

using namespace std;

//    **********  3.扩展：替代单例模式，代码清单8-15::***************//
class Singleton
{
public:
    void    doSomething(){qDebug() << "Singleton doSomething";}
    friend class SingletonFactory;
private:    
    Singleton(){}
};


class SingletonFactory
{
public:
    static Singleton* getSingleton()
    {
        return m_singleton;
    }
private:
    static Singleton* m_singleton;
};

Singleton* SingletonFactory::m_singleton = new Singleton();



int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    
    Singleton* singleton = SingletonFactory::getSingleton();
    singleton->doSomething();

    
    return a.exec();
}


5-4. 延迟初始化

场景：为何延迟初始化？一个对象被消费完毕后，不立刻释放，工厂类保持其初始状态，等待再次被使用。延迟初始化是工厂方法模式的一个扩展应用。
分析：ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次被重用的对象保留。

 

示例六：延迟初始化

1. 类图8-6

 

2. 代码清单8-16:

#include <QCoreApplication>
#include <QDebug>

using namespace std;

//    **********  4.扩展：延迟初始化，代码清单8-16:***************//

class Product       //产品类的公共方法
{
public:
    virtual void    method1() = 0;
    virtual void    method2() = 0;
};

class ConcreteProduct1:public Product   //具体产品类
{
public:
    virtual void    method1(){}
    virtual void    method2(){qDebug() << "ConcreteProduct1 method";}
};

class ConcreteProduct2:public Product   //具体产品类
{
public:
    virtual void    method1(){}
    virtual void    method2(){qDebug() << "ConcreteProduct2 method";}
};

class ProductFactory
{
public:
    static Product* createProduct(QString type)
    {
        Product* product = nullptr;
        QHash<QString, Product>::const_iterator iter = m_prMap.constBegin();
        while (iter != m_prMap.constEnd()) 
        {
            if (iter.key() == type)
            {
                product = iter.value();
            }
            else
            {
                if (type == "Product1")
                {
                    product = new ConcreteProduct1();
                }
                else
                {
                    product = new ConcreteProduct2();
                }
                m_prMap.insert(type, product);
            }
            ++iter;
        }
    }
private:
    static QHash<QString,*Product> m_prMap;
};

QHash<QString,Product> ProductFactory::m_prMap;

代码说明：
通过定义一个QHash容器，容纳所有生产对象，如果在QHash容器中已经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入到QHash中，方便下次调用。

延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断QHash中已有的对象数量来实现，这样的处理是非常有意义的，例如JDBC链接数据库，都会要求设置一个MaxConnections最大连接数量，该数量就是内存汇总最大实例化的数量。

延迟加载还可以用在对象初始化比较复杂的情况下，例如硬件访问，设计多方面的交互，则可以通过延迟加载降低对象的产生和销毁带来的复杂性。

参考文献《秦小波. 设计模式之禅》（第2版） (华章原创精品) 机械工业出版社

 

Jecklin_online
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
工厂方法模式--女娲造人
qwqc262的博客
10-29 974
工厂方法模式–女娲造人 1.工程文件 Human.java和HumanFactory.java这两个是接口类。 通过输出不同人种的语言识别不同人种。 2.Human.java package factory_approach_model; public interface Human { public void talk(); } 3.HumanFactory.java package factory_approach_model; public interface HumanFactory
C++知识点-线程5-延迟锁和延迟初始化
蓝色的杯子
07-14 594
uniquelock比guardload重量级一些,但是灵活一些. uniquelock的第一个版本 class LogFile { std::mutex _mu; ofstream _f; public: LogFile() { _f.open("log.txt"); } void shared_print(string id, int value) { std::unique_lock<mutex> locker(_mu); cout <&lt..
c++中延迟初始化
青箫的博客
04-06 1632
仅仅在C++0x标准或gnu++ox标准中使用-std=c++0x -std=gnu++0x这两个参数设置上后，才能有延迟初始化，即参数在模板里面初始化
工厂模式C++实现（三种工厂模式附详细注释）
m0_46210273的博客
09-07 3686
简单工厂模式 顾名思义，工厂是用来生产东西的，而在C++里面就是用来生产对象的。 就像一家餐厅一样，你可以按照你的方式来点餐。在工厂模式中也一样，你可以要求工厂为你生产不同的对象。 闲话不多说，直接上代码！ #include<iostream> #include<string> using namespace std; class Produce;//声明产品类 class Factory;//声明工厂类 class Factory { public: Factory(){
C++ 设计模式——工厂模式
最新发布
qq_68194402的博客
08-17 1603
工厂模式是一种创建对象的设计模式，主要用于将对象的创建与使用分离。它提供了一种接口来创建对象，但由子类决定实例化哪个类。工厂模式有几种变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。
C++ 设计模式——抽象工厂模式
qq_68194402的博客
08-17 1341
抽象工厂模式提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。它通常用于需要创建多个产品族的场景。
C++ 设计模式——工厂方法模式
qq_68194402的博客
08-16 846
工厂方法模式是一种创建型设计模式，它通过定义一个接口用于创建对象，但由子类决定实例化哪个类。与简单工厂模式不同，工厂方法模式将对象的创建委托给子类，从而实现更好的扩展性和灵活性。
大话设计模式C++版——简单工厂模式
weixin_45014831的博客
11-02 446
文章目录前言一、包含的角色二、优势1.实现了松耦合二、C++实现1.代码总结 前言 用C++把大话设计模式中的案例复现 一、包含的角色 简单工厂包含三个角色： （1）工厂类Factory：工厂工厂类是用来制造产品的。因此，在Factory中有一个用于制造产品的Create函数或者Generate函数之类的函数。这个函数能够根据“标识符”的不同生成不同的ConcreateProduct，当然这些ConcreateProduct都是继承自AbstractProduct的。 （2）抽象产品类Abstrac.
C++ 设计模式——简单工厂模式
qq_68194402的博客
08-16 755
简单工厂模式是一种创建型设计模式，通过一个工厂类来负责对象的实例。这种模式将对象创建的细节封装在工厂类中，客户端无需知道具体的创建过程，只需通过工厂类获取对象实例即可。
C++设计模式——适配器模式
Abieai的博客
10-14 577
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
（创建模式 上）设计模式——工厂、抽象工厂 C++/Python3实现
01-20
简介 设计模式是为了解决一些出现的问题设计的解决方案。是长时间经验的总结，是根据...工厂模式 在类中实现一个接口创建指定对象，使一个类的实例化延迟到了子类。简单来说把类的创建都封装起来，只需要调用一个子类
C++设计模式之工厂方法模式
12-31
之前讲到了C++设计模式——简单工厂模式，由于简单工厂模式的局限性，比如：工厂现在能生产ProductA、ProductB和ProductC三种产品了，此时，需要增加生产ProductD产品；那么，首先是不是需要在产品枚举类型中添加新...
C++设计模式之抽象工厂模式
01-21
之前讲到了C++设计模式——工厂方法模式，我们可能会想到，后期产品会越来越多了，建立的工厂也会越来越多，工厂进行了增长，工厂变的凌乱而难于管理；由于工厂方法模式创建的对象都是继承于Product的，所以工厂方法...
C++设计模式——工厂方法（factory method）
净无邪博客
08-05 1463
一、原理讲解 工厂方法是简单工厂的改进，改进之处是每款产品对应一个工厂，该工厂只生产这一种产品，也就是只创建这个产品类对象。 1.1意图 定义一个创建对象的接口，让子类决定实例化哪个类。该模式使类对象的创建延迟到子类。 1.2应用场景 客户端不知道他所需要的对象的类； 需要将类的实例延迟到子类中实现，并且一类产品有许多形态。’ 1.3结构图（UML图） （后面补充） 1.4代码实现步骤 a1 定义一个抽象产品接口类IProduct，并且定义一个接口函数show()用于子类继承；（抽象.
设计模式 —— 里氏替换原则
Jecklin_online的博客
09-13 6006
前言 ● 第一种定义，也是最正宗的定义：如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2 时，程序P的行为没有发生变化，那么类型 S 是类型 T 的子类型。 ● 第二种定义：所有引用基类的地方必须能透明地使用其子类的对象。 第二个定义是最清晰明确的，通俗点讲，只要父类能出现的地方子类就可以出现，而且替换为子类也不会 产生任何错误或异...
设计模式 c++版（11）——策略模式
Jecklin_online的博客
09-26 895
定义： 定义一组算法，将每个算法都封装起来，并且使他们之间可以互换 示例一：策略模式（通用版） 1. 类图18-3   2. 类图说明 策略模式使用的就是面向对象的继承和多态机制 Context 封装角色。也叫上下文角色，起承上启下的封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。 Strategy 抽象策略角色。策略、算法家族的抽象，通常为借口，定义每个策略或算...
设计模式 c++版（16）——门面模式
Jecklin_online的博客
10-09 555
定义： 要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用（门面模式也叫做外观模式）。 示例一：门面模式（通用版） 1. 类图23-4   2. 类图说明 Subsystem Classes 是子系统所有类的简称，它可以代表几十个对象的集合。门面对象时外界访问子系统内部的唯一通道。   3. 门面模式结构图 23-5 ...
设计模式 c++版（21）——桥梁模式
Jecklin_online的博客
10-10 406
定义：将抽象和实现解耦，使得两者可以独立地变化。 示例一：桥梁模式（通用版） 1. 类图 29-4   2. 类图说明 Abstraction 抽象化角色。主要职责是定义出该角色的行为，同时保存一个对实现化角色的引用，该角色一般是抽象类。 Implementor 实现化角色。它是接口或抽象类，定义角色必须的行为和属性。 RefinedAbstraction 修正抽象化角色。它引用实例...
C++实现：详解常见设计模式及其工厂方法
"本文档深入解析了C++中的常见设计模式——Factory模式。Factory模式是一种创建型设计模式，它提供了一个接口，使得子类能够决定具体创建哪个对象实例，从而实现了对象的实例化延迟。模式的核心包括两个抽象概念：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值