简单工厂、工厂方法和抽象工厂模式（创建型设计模式）的 C++ 代码示例模板

已于 2023-12-17 20:27:50 修改
阅读量507 收藏
点赞数
分类专栏： 设计模式 文章标签： 简单工厂模式 工厂方法模式 抽象工厂模式 设计模式 C++
于 2023-11-19 23:14:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62083249/article/details/134489072
版权

文章目录

前言

简单工厂、工厂方法和抽象工厂模式（创建型设计模式）的 C++ 代码示例模板。

代码仓库

简单工厂模式（Simple Factory）

结构

  • 抽象产品类
  • 具体产品类 A
  • 具体产品类 B
  • 简单工厂类
  • 简单工厂类的静态方法创建具体产品对象 A 和具体产品对象 B

核心

  • 继承
  • 多态
  • 一个工厂创建多类产品

代码（普通版）

#include <iostream>
#include <string>

using std::cerr;
using std::cout;
using std::endl;
using std::string;

// 抽象产品类
class AbstractProduct
{
public:
    virtual void func() = 0;
};

// 具体产品类 A
class ConcreteProductA : public AbstractProduct
{
public:
    void func() override
    {
        cout << "ConcreteProductA" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public AbstractProduct
{
public:
    void func() override
    {
        cout << "ConcreteProductB" << endl;
    }
};

// 简单工厂类
class SimpleFactory
{
public:
    // 静态方法依据类型创建不同的具体产品
    static AbstractProduct *create_concrete_product(const string &concrete_product_type)
    {
        if (concrete_product_type == "A")
        {
            return new ConcreteProductA();
        }
        else if (concrete_product_type == "B")
        {
            return new ConcreteProductB();
        }
        else
        {
            cerr << "Unknown type of concrete product" << endl;

            return nullptr;
        }
    }
};

// 客户端
int main()
{
    // 使用简单工厂创建不同类型的具体产品
    AbstractProduct *concrete_product_a = SimpleFactory::create_concrete_product("A"); // 创建具体产品对象 A
    if (concrete_product_a != nullptr)
    {
        concrete_product_a->func();

        delete concrete_product_a;
    }

    AbstractProduct *concrete_product_b = SimpleFactory::create_concrete_product("B"); // 创建具体产品对象 B
    if (concrete_product_b != nullptr)
    {
        concrete_product_b->func();

        delete concrete_product_b;
    }

    AbstractProduct *concrete_product_c = SimpleFactory::create_concrete_product("C"); // 创建具体产品对象 C
    if (concrete_product_c != nullptr)
    {
        concrete_product_c->func();

        delete concrete_product_c;
    }

    return 0;
}
/*
输出：
ConcreteProductA
ConcreteProductB
Unknown type of concrete product
*/

代码

#include <iostream>
#include <string>
#include <memory>

using std::cerr;
using std::cout;
using std::endl;
using std::make_unique;
using std::string;
using std::unique_ptr;

// 抽象产品类
class AbstractProduct
{
public:
    AbstractProduct() = default;
    virtual ~AbstractProduct() = default;

    virtual void func() = 0;
};

// 具体产品类 A
class ConcreteProductA : public AbstractProduct
{
public:
    ConcreteProductA() = default;
    ~ConcreteProductA() override = default;

    void func() override
    {
        cout << "ConcreteProductA" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public AbstractProduct
{
public:
    ConcreteProductB() = default;
    ~ConcreteProductB() override = default;

    void func() override
    {
        cout << "ConcreteProductB" << endl;
    }
};

// 简单工厂类
class SimpleFactory
{
public:
    // 静态方法依据类型创建不同的具体产品
    static unique_ptr<AbstractProduct> create_concrete_product(const string &concrete_product_type)
    {
        if (concrete_product_type == "A")
        {
            return make_unique<ConcreteProductA>();
        }
        else if (concrete_product_type == "B")
        {
            return make_unique<ConcreteProductB>();
        }
        else
        {
            cerr << "Unknown type of concrete product" << endl;

            return nullptr;
        }
    }
};

// 客户端
int main()
{
    // 使用简单工厂创建不同类型的具体产品
    unique_ptr<AbstractProduct> concrete_product_a = SimpleFactory::create_concrete_product("A"); // 创建具体产品对象 A
    if (concrete_product_a != nullptr)
    {
        concrete_product_a->func();
    }

    unique_ptr<AbstractProduct> concrete_product_b = SimpleFactory::create_concrete_product("B"); // 创建具体产品对象 B
    if (concrete_product_b != nullptr)
    {
        concrete_product_b->func();
    }

    unique_ptr<AbstractProduct> concrete_product_c = SimpleFactory::create_concrete_product("C"); // 创建具体产品对象 C
    if (concrete_product_c != nullptr)
    {
        concrete_product_c->func();
    }

    return 0;
}
/*
输出：
ConcreteProductA
ConcreteProductB
Unknown type of concrete product
*/

工厂方法模式（Factory Method）

结构

  • 抽象产品类
  • 具体产品类 A
  • 具体产品类 B
  • 抽象工厂类
  • 具体工厂类 A
  • 具体工厂类 B
  • 具体工厂对象 A 的方法创建具体产品对象 A
  • 具体工厂对象 B 的方法创建具体产品对象 B

核心

  • 继承
  • 多态
  • 一类工厂创建一类产品

代码（普通版）

#include <iostream>

using std::cout;
using std::endl;

// 抽象产品类
class AbstractProduct
{
public:
    virtual void func() = 0;
};

// 具体产品类 A
class ConcreteProductA : public AbstractProduct
{
public:
    void func() override
    {
        cout << "ConcreteProductA" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public AbstractProduct
{
public:
    void func() override
    {
        cout << "ConcreteProductB" << endl;
    }
};

// 抽象工厂类
class AbstractFactory
{
public:
    virtual AbstractProduct *create_concrete_product() const = 0;
};

// 具体工厂类 A
class ConcreteFactoryA : public AbstractFactory
{
public:
    AbstractProduct *create_concrete_product() const override
    {
        return new ConcreteProductA();
    }
};

// 具体工厂类 B
class ConcreteFactoryB : public AbstractFactory
{
public:
    AbstractProduct *create_concrete_product() const override
    {
        return new ConcreteProductB();
    }
};

// 客户端
int main()
{
    // 使用工厂方法创建不同类型的具体产品
    AbstractFactory *concrete_factory_a = new ConcreteFactoryA();                        // 创建具体工厂对象 A
    AbstractProduct *concrete_product_a = concrete_factory_a->create_concrete_product(); // 创建具体产品对象 A
    concrete_product_a->func();
    delete concrete_product_a;
    delete concrete_factory_a;

    AbstractFactory *concrete_factory_b = new ConcreteFactoryB();                        // 创建具体工厂对象 B
    AbstractProduct *concrete_product_b = concrete_factory_b->create_concrete_product(); // 创建具体产品对象 B
    concrete_product_b->func();
    delete concrete_product_b;
    delete concrete_factory_b;

    return 0;
}
/*
输出：
ConcreteProductA
ConcreteProductB
*/

代码

#include <iostream>
#include <memory>

using std::cout;
using std::endl;
using std::make_unique;
using std::unique_ptr;

// 抽象产品类
class AbstractProduct
{
public:
    AbstractProduct() = default;
    virtual ~AbstractProduct() = default;

    virtual void func() = 0;
};

// 具体产品类 A
class ConcreteProductA : public AbstractProduct
{
public:
    ConcreteProductA() = default;
    ~ConcreteProductA() override = default;

    void func() override
    {
        cout << "ConcreteProductA" << endl;
    }
};

// 具体产品类 B
class ConcreteProductB : public AbstractProduct
{
public:
    ConcreteProductB() = default;
    ~ConcreteProductB() override = default;

    void func() override
    {
        cout << "ConcreteProductB" << endl;
    }
};

// 抽象工厂类
class AbstractFactory
{
public:
    AbstractFactory() = default;
    virtual ~AbstractFactory() = default;

    virtual unique_ptr<AbstractProduct> create_concrete_product() const = 0;
};

// 具体工厂类 A
class ConcreteFactoryA : public AbstractFactory
{
public:
    ConcreteFactoryA() = default;
    ~ConcreteFactoryA() override = default;

    inline unique_ptr<AbstractProduct> create_concrete_product() const override
    {
        return make_unique<ConcreteProductA>();
    }
};

// 具体工厂类 B
class ConcreteFactoryB : public AbstractFactory
{
public:
    ConcreteFactoryB() = default;
    ~ConcreteFactoryB() override = default;

    inline unique_ptr<AbstractProduct> create_concrete_product() const override
    {
        return make_unique<ConcreteProductB>();
    }
};

// 客户端
int main()
{
    // 使用工厂方法创建不同类型的具体产品
    unique_ptr<AbstractFactory> concrete_factory_a = make_unique<ConcreteFactoryA>();               // 创建具体工厂对象 A
    unique_ptr<AbstractProduct> concrete_product_a = concrete_factory_a->create_concrete_product(); // 创建具体产品对象 A
    concrete_product_a->func();

    unique_ptr<AbstractFactory> concrete_factory_b = make_unique<ConcreteFactoryB>();               // 创建具体工厂对象 B
    unique_ptr<AbstractProduct> concrete_product_b = concrete_factory_b->create_concrete_product(); // 创建具体产品对象 B
    concrete_product_b->func();

    return 0;
}
/*
输出：
ConcreteProductA
ConcreteProductB
*/

抽象工厂模式（Abstract Factory）

结构

  • 抽象产品类 A
  • 具体产品类 A1
  • 具体产品类 B1
  • 抽象产品类 B
  • 具体产品类 B1
  • 具体产品类 B2
  • 抽象工厂类1
  • 具体工厂类1
  • 抽象工厂类2
  • 具体工厂类2
  • 具体工厂对象1 的方法创建具体产品对象 A1 和 具体产品对象 B1
  • 具体工厂对象2 的方法创建具体产品对象 A2 和 具体产品对象 B2

核心

  • 继承
  • 多态
  • 产品和工厂形成二维结构：工厂1创建产品 A1 和 B1，工厂2创建产品 A2 和 B2

代码（普通版）

#include <iostream>

using std::cout;
using std::endl;

// 抽象产品类 A
class AbstractProductA
{
public:
    virtual void func() = 0;
};

// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA
{
public:
    void func() override
    {
        cout << "ConcreteProductA1" << endl;
    }
};

// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA
{
public:
    void func() override
    {
        cout << "ConcreteProductA2" << endl;
    }
};

// 抽象产品类 B
class AbstractProductB
{
public:
    virtual void func() = 0;
};

// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB
{
public:
    void func() override
    {
        cout << "ConcreteProductB1" << endl;
    }
};

// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB
{
public:
    void func() override
    {
        cout << "ConcreteProductB2" << endl;
    }
};

// 抽象工厂类
class AbstractFactory
{
public:
    virtual AbstractProductA *create_product_a() const = 0;
    virtual AbstractProductB *create_product_b() const = 0;
};

// 具体工厂类 1
class ConcreteFactory1 : public AbstractFactory
{
public:
    AbstractProductA *create_product_a() const override
    {
        return new ConcreteProductA1();
    }

    AbstractProductB *create_product_b() const override
    {
        return new ConcreteProductB1();
    }
};

// 具体工厂类 2
class ConcreteFactory2 : public AbstractFactory
{
public:
    AbstractProductA *create_product_a() const override
    {
        return new ConcreteProductA2();
    }

    AbstractProductB *create_product_b() const override
    {
        return new ConcreteProductB2();
    }
};

// 客户端
int main()
{
    // 使用抽象工厂创建不同类型的具体产品
    AbstractFactory *concrete_factory_1 = new ConcreteFactory1();                   // 创建具体工厂对象1
    AbstractProductA *concrete_product_a1 = concrete_factory_1->create_product_a(); // 创建具体产品对象 A1
    AbstractProductB *concrete_product_b1 = concrete_factory_1->create_product_b(); // 创建具体产品对象 B1
    concrete_product_a1->func();
    concrete_product_b1->func();
    delete concrete_product_b1;
    delete concrete_product_a1;
    delete concrete_factory_1;

    AbstractFactory *concrete_factory_2 = new ConcreteFactory2();                   // 创建具体工厂2
    AbstractProductA *concrete_product_a2 = concrete_factory_2->create_product_a(); // 创建具体产品对象 B1
    AbstractProductB *concrete_product_b2 = concrete_factory_2->create_product_b(); // 创建具体产品对象 B1
    concrete_product_a2->func();
    concrete_product_b2->func();
    delete concrete_product_b2;
    delete concrete_product_a2;
    delete concrete_factory_2;

    return 0;
}
/*
输出：
ConcreteProductA1
ConcreteProductB1
ConcreteProductA2
ConcreteProductB2
*/

代码

#include <iostream>
#include <memory>

using std::cout;
using std::endl;
using std::make_unique;
using std::unique_ptr;

// 抽象产品类 A
class AbstractProductA
{
public:
    AbstractProductA() = default;
    virtual ~AbstractProductA() = default;

    virtual void func() = 0;
};

// 具体产品类 A1
class ConcreteProductA1 : public AbstractProductA
{
public:
    ConcreteProductA1() = default;
    ~ConcreteProductA1() override = default;

    void func() override
    {
        cout << "ConcreteProductA1" << endl;
    }
};

// 具体产品类 A2
class ConcreteProductA2 : public AbstractProductA
{
public:
    ConcreteProductA2() = default;
    ~ConcreteProductA2() override = default;

    void func() override
    {
        cout << "ConcreteProductA2" << endl;
    }
};

// 抽象产品类 B
class AbstractProductB
{
public:
    AbstractProductB() = default;
    virtual ~AbstractProductB() = default;

    virtual void func() = 0;
};

// 具体产品类 B1
class ConcreteProductB1 : public AbstractProductB
{
public:
    ConcreteProductB1() = default;
    ~ConcreteProductB1() override = default;

    void func() override
    {
        cout << "ConcreteProductB1" << endl;
    }
};

// 具体产品类 B2
class ConcreteProductB2 : public AbstractProductB
{
public:
    ConcreteProductB2() = default;
    ~ConcreteProductB2() override = default;

    void func() override
    {
        cout << "ConcreteProductB2" << endl;
    }
};

// 抽象工厂类
class AbstractFactory
{
public:
    AbstractFactory() = default;
    virtual ~AbstractFactory() = default;

    virtual unique_ptr<AbstractProductA> create_product_a() const = 0;
    virtual unique_ptr<AbstractProductB> create_product_b() const = 0;
};

// 具体工厂类 1
class ConcreteFactory1 : public AbstractFactory
{
public:
    ConcreteFactory1() = default;
    virtual ~ConcreteFactory1() = default;

    inline unique_ptr<AbstractProductA> create_product_a() const override
    {
        return make_unique<ConcreteProductA1>();
    }

    inline unique_ptr<AbstractProductB> create_product_b() const override
    {
        return make_unique<ConcreteProductB1>();
    }
};

// 具体工厂类 2
class ConcreteFactory2 : public AbstractFactory
{
public:
    ConcreteFactory2() = default;
    virtual ~ConcreteFactory2() = default;

    inline unique_ptr<AbstractProductA> create_product_a() const override
    {
        return make_unique<ConcreteProductA2>();
    }

    inline unique_ptr<AbstractProductB> create_product_b() const override
    {
        return make_unique<ConcreteProductB2>();
    }
};

// 客户端
int main()
{
    // 使用抽象工厂创建不同类型的具体产品
    unique_ptr<AbstractFactory> concrete_factory_1 = make_unique<ConcreteFactory1>();          // 创建具体工厂对象1
    unique_ptr<AbstractProductA> concrete_product_a1 = concrete_factory_1->create_product_a(); // 创建具体产品对象 A1
    unique_ptr<AbstractProductB> concrete_product_b1 = concrete_factory_1->create_product_b(); // 创建具体产品对象 B1
    concrete_product_a1->func();
    concrete_product_b1->func();

    unique_ptr<AbstractFactory> concrete_factory_2 = make_unique<ConcreteFactory2>();          // 创建具体工厂2
    unique_ptr<AbstractProductA> concrete_product_a2 = concrete_factory_2->create_product_a(); // 创建具体产品对象 B1
    unique_ptr<AbstractProductB> concrete_product_b2 = concrete_factory_2->create_product_b(); // 创建具体产品对象 B1
    concrete_product_a2->func();
    concrete_product_b2->func();

    return 0;
}
/*
输出：
ConcreteProductA1
ConcreteProductB1
ConcreteProductA2
ConcreteProductB2
*/

总结

简单工厂、工厂方法和抽象工厂模式（创建型设计模式）的 C++ 代码示例模板。

参考资料

作者的话

  • 感谢参考资料的作者/博主
  • 作者：夜悊
  • 版权所有，转载请注明出处，谢谢~
  • 如果文章对你有帮助，请点个赞或加个粉丝吧，你的支持就是作者的动力~
  • 文章在描述时有疑惑的地方，请留言，定会一一耐心讨论、解答
  • 文章在认识上有错误的地方, 敬请批评指正
  • 望读者们都能有所收获
夜悊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式 | 用实际案例详解工厂模式
小白菜的博客
06-06 1176
我们来看一个具体需求 看一个披萨的项目，要便于披萨种类的扩展，要便于维护，有以下要求： 披萨的种类很多（比如GreekPizz、CheesePizz等） 披萨的制作有prepare，bake，cut，box 完成披萨店订购功能 首先我们先编写一个Pizza抽象类： package com.cxc.factory.simplefactory.pizzastore.pizza; /** * 抽...
C++ 设计模式：简单工厂、工厂方法、抽象工厂练习代码
05-24
设计模式中工厂相关模式有简单工厂、工厂方法、抽象工厂学习后的练习代码，C++编程语言。
工厂模式中简单工厂模式、工厂方法模式、抽象工厂模式的分析与总结
yvge669的博客
05-15 581
简单工厂模式： ​ 由一个工厂类根据传入的参数决定创建哪种产品类的实例。简单工厂模式将对象的创建和使用分离开来，客户端只需要传入参数，就可以得到所需的对象，无需关心对象的创建细节。 工厂方法模式： ​ 定义一个创建产品对象的接口，由子类决定实例化哪一个产品类。工厂方法模式将对象的创建延迟到子类中去实现，客户端只需要知道所需产品的工厂类即可，无需关心具体的产品类。 抽象工厂模式： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式可以看作是工厂方法模式的升级版
设计模式之抽象工厂模式的C++代码实现
hanxiaoyong_的博客
08-15 166
抽象工厂方法模式C++实现。在软件功能设计中，经常面临着“一系列相互依赖的对象”的创建工作，同时，由于需求的变化，这些相互依赖的对象会有更多子类的创建功能。抽象工厂模式主要是解决“一系列对象对象的创建工作，且这些对象有相互依赖或者作用的关系”。抽象工厂模式可以将一系列的变化对象分别创建对应的抽象基类，然后将这些有相互作用的抽象基类的对象创建集成到一个工厂类中。抽象工厂方法模式是将有相互依赖的创建工厂集中到一个工厂类中创建，即工厂方法集的类接口。抽象工厂方法模式实现。
简单工厂模式代码示例
舞鹤白沙编码日志
12-31 1499
一. 抽象接口INoodles： package designpattern.factory.simplefactory.noodles; public interface INoodles { /** * 描述每种面条啥样的 */ public abstract void desc(); } 二. 接口实现类： LzNoodles： package designpattern.factory.simplefactory.noodles; public
【设计模式-3】简单工厂模式的代码实现及使用场景
qq_35850405的博客
12-18 1279
简单工厂模式代码实现、UML类图、优缺点、使用场景
23种设计模式之抽象工厂模式Java示例代码
最新发布
04-16
本文介绍了抽象工厂模式的定义、使用场景、主要角色以及相应的类图，并提供了Java示例代码以帮助读者更好地理解该模式的实现方法。抽象工厂模式为创建一组相关或相互依赖的对象提供了一个接口，而不需要指定它们的...
c++设计模式-抽象工厂方法
06-04
c++设计模式-创建型-抽象工厂方法-最简单源码-qt工程
创建型设计模式----抽象工厂模式
08-13
创建型设计模式----抽象工厂模式
简单工厂模式、工厂模式、抽象工厂模式案例（C++实现）
04-10
通过C++实现了简单工厂模式、工厂模式、抽象工厂模式三大设计模式的经典案例。
简单工厂模式的例子
03-27
NULL 博文链接：https://306963591.iteye.com/blog/1133631
简单工厂模式学习代码
03-17
文章：http://blog.csdn.net/hailushijie/article/details/8683919
【C++设计模式】抽象工厂模式
发现问题，并解决问题，批判性思维
02-18 1540
学习总结 （1）抽象工厂模式结构与工厂方法模式结构类似，不同之处在于，一个具体工厂可以生产多种同类相关的产品。 抽象工厂模式的优点： 工厂方法用于创建客户所需产品，同时向客户隐藏某个具体产品类将被实例化的细节，用户只需关心所需产品对应的工厂； 新加入产品系列时，无需修改原有系统，增强了系统的可扩展性，符合开闭原则。 抽象工厂模式的缺点： 在已有产品系列中添加新产品时需要修改抽象层代码，对原有系统改动较大，违背开闭原则 适用环境： 一系列/一族产品需要被同时使用时，适合使用抽象工厂模式； 产品
C++设计模式-抽象工厂模式
IT1995的博客
07-04 5511
目录 基本概念 代码与实例 基本概念 抽象工厂模式（Abstract Factory），提供一个创建一系列相关或相互依赖对象的接口，从而无需指定他们具体的类。 抽象工厂的好处： 1. 易于交换产品系列，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置； ...
C++25设计模式之抽象工厂模式
学习精进的路上
04-16 735
图片引用于菜鸟教程 简介：抽象工厂模式是为了创建一系列产品而提供的解决方案，和简单工厂模式不一样的是，抽象工厂模式不只是创建一种产品，而是创建产品的一系列对象 优点：扩展性高，可以通过一系列对象实现某个功能 缺点：一旦添加新产品，就需要再新增一个工厂类 适用场景：需要一系列或者多个对象实现不同功能又不关心功能怎么实现时 例子背景：现在客户需要i3、i5、i7、i9、DIY电脑主机，而这些主机各方面组件并不相同，那么使用抽象工厂模式，在为各种主机组装时就无需制定配件的型号，它会自动根据产品自动生成需要的配件.
c++抽象工厂模式
燃犀的博客
07-07 1104
抽象工厂模式
C++抽象工厂模式+代码实现
程序员の墨梅
05-02 552
抽象工厂模式(Abstract Factory ) 抽象工厂模式实现: 精髓在这里: 抽象工厂模式(Abstract Factory ) 抽象工厂模式为创建一组对象提供了一种解决方案。与工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。 如下图中的ConcreteFactory1是一系列产品,ConcreteFactory...
C++实现工厂模式（简单与抽象工厂模式）
qq_19525389的博客
08-06 495
What is it? 工厂模式：是一种很常见创建型模式，是用工厂代替new操作的模式。在java程序中很常见，但C++同样可以实现和使用。因为工厂模式就相当于创建对象时的new，如A a = new A();所以用我们在用new时要考虑能不能用工厂模式。虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。。 工厂模式可分为“简单工厂模式”和“抽象工厂模式”。 Wh...
抽象工厂模式C++示例代码
02-23
下面是一个简单的C++示例代码来说明抽象工厂模式的使用： ```cpp #include // 抽象产品A class AbstractProductA { public: virtual void operationA() = 0; }; // 具体产品A1 class ConcreteProductA1 : ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值