C++中对象的初始化和清理

已于 2024-04-08 20:32:34 修改
阅读量994 收藏 8
点赞数 12
文章标签： java 开发语言 c语言
于 2024-04-08 11:24:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53795212/article/details/137501262
版权

  • 生活中我们买的电子产品基本都会有出厂设置，在某一天我们不用的时候也会删除自己的数据防止信息泄漏

  • C++中面向对象的思想源自于生活，每个对象都有自己的初始设置以及对象销毁之前清理数据的设置

1. 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

  • 一个对象或者变量没有初始状态，其使用后果是未知的

  • 使用完一个对象或者变量后，如果没有及时清理，也会造成一定的安全问题

C++利用了构造函数和析构函数解决上述问题，这两个函数将会自动被编译器调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制我们必须要做的事情，如果我们不提供构造和析构，编译器会提供（编译器提供的构造函数和析构函数是空实现）

  • 构造函数：主要作用是创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用

  • 析构函数：主要作用是在对象被销毁之前系统自动调用，执行一些清理工作

构造函数语法：类名(){}

  1. 构造函数，没有返回值，也不写void

  2. 函数名称与类名相同

  3. 构造函数可以有参数，因此可以发生重载

  4. 程序在调用对象时会自动调用构造，无须手动调用，而且只会调用一次

析构函数语法：~类名(){}

  1. 析构函数，没有返回值，也不写void

  2. 函数名称与类名相同，在名称前加上~

  3. 构造函数不可以有参数，因此不能发生重载

  4. 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

示例：

#include<iostream>
using namespace std;


//对象的初始化和清理

class Person
{
    //1.构造函数：进行初始化操作
    //构造函数，没有返回值，也不写void
    //函数名称与类名相同
    //构造函数可以有参数，因此可以发生重载
    //创建对象的时候，构造函数会自动调用，而且只会调用一次
public:
    Person()
    {
        cout << "Person 构造函数调用" << endl;
    }

    //2.析构函数：进行清理操作
    // 析构函数，没有返回值，也不写void
    // 函数名称与类名相同，在名称前加上~
    // 构造函数不可以有参数，因此不能发生重载
    // 程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次
    ~Person()
    {
        cout << "Person 析构函数调用" << endl;
    }
};

//构造和析构都是必须有的实现，如果我们不提供，编译器会提供一个空实现的构造和析构
void test01()
{
    Person p;  //在栈上的数据，test01执行完毕之后，释放对象p，析构函数也会被调用
}

int main()
{
    test01();  //调用构造函数和析构函数

    Person p;  //调用构造函数，main函数结束后才调用析构函数
    
    system("read -p '按任意键继续...' var");
    
    return 0;
}


输出：
---------------------------------------------------------------------------------
Person 构造函数调用
Person 析构函数调用
Person 构造函数调用
按任意键继续...
Person 析构函数调用

2. 构造函数的分类及调用

两种分类方式：

  • 按参数分类：有参构造和无参构造

  • 按类型分类：普通构造和拷贝构造

三种调用方式：

  • 括号法

  • 显示法

  • 隐式转换法

示例：

#include<iostream>
using namespace std;


//构造函数的分类及调用

//分类
//按参数分类：有参构造函数（默认构造），无参构造函数
//按类型分类：普通构造，拷贝构造
class Person
{
public:
    //无参构造函数（普通构造函数）
    Person()
    {
        cout << "Person 的无参构造函数调用" << endl;
    }
    //有参构造函数（普通构造函数）
    Person(int a)
    {
        age = a;
        cout << "Person 的有参构造函数调用" << endl;
    }
    //拷贝构造函数
    Person( const Person &p )
    {
        //将传入的人身上的所有属性，拷贝到自己身上
        age = p.age;
        cout << "Person 的拷贝构造函数调用" << endl;
    }

    int age;
};

//调用
void test01()
{
    //1.括号法(简单常用)
    Person p1;
    Person p2(10);
    Person p3(p2);

    //注意事项1：
    //调用默认构造函数的时候，不要加()，编译器会认为 Person p1(); 是一个函数声明，而不是在创建对象
    cout << "p2的年龄：" << p2.age << endl;
    cout << "p3的年龄：" << p3.age << endl;

    //2.显示法
    Person p4;
    Person p5 = Person(10);  //Person(10) 创建了一个匿名对象，当前行执行结束后，系统会立刻回收匿名对象
    Person p6 = Person(p2);  

    //注意事项2：
    //不要利用拷贝构造函数，初始化匿名对象，编译器认为 Person(p3) == Person p3; 
    // Person(p3);  //报错：“Person p3”：重定义

    //3.隐式转换法
    Person p7;
    Person p8 = 10;  //有参构造，相当于 Person p4 = Person(10);
    Person p9 = p8;  //拷贝构造，相当于 Person p8 = Person(p7);
}

int main()
{
    test01();  //调用构造函数和析构函数
    
    system("read -p '按任意键继续...' var");
    
    return 0;
}


输出：
---------------------------------------------------------------------------------
Person 的无参构造函数调用
Person 的有参构造函数调用
Person 的拷贝构造函数调用
p2的年龄：10
p3的年龄：10
Person 的无参构造函数调用
Person 的有参构造函数调用
Person 的拷贝构造函数调用
Person 的无参构造函数调用
Person 的有参构造函数调用
Person 的拷贝构造函数调用
按任意键继续...

3. 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况：

  • 使用一个已经创建完毕的对象来初始化一个新对象

  • 值传递的方式给函数参数传值

  • 以值方式返回局部对象

示例：

#include<iostream>
using namespace std;


class Person
{
public:
    Person()
    {
        cout << "Person 的无参构造函数调用" << endl;
    }
    Person(int age)
    {
        m_Age = age;
        cout << "Person 的有参构造函数调用" << endl;
    }
    Person(const Person &p)
    {
        m_Age = p.m_Age;
        cout << "Person 的拷贝构造函数调用" << endl;
    }
    ~Person()
    {
        cout << "Person 的析构函数调用" << endl;
    }
    

    int m_Age = 10;
};


//拷贝构造函数调用时机

//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
    Person p1(20);
    Person p2(p1);

    cout << "P2的年龄为：" << p2.m_Age << endl;
}

//2.值传递的方式给函数参数传值
void doWork(Person p)
{
    p.m_Age = 100;
}

void test02()
{
    Person p;
    doWork(p);
    cout << "p的年龄为：" << p.m_Age << endl;
}

//3.值方式返回局部对象
Person doWork2()
{
    Person p1;
    cout << (int*)&p1 << endl;
    
    return p1;
}
void test03()
{
    Person p = doWork2();
    cout << (int*)&p << endl;
}


int main()
{
    test01();  
    cout << "-----------------------" << endl;
    test02();
    cout << "-----------------------" << endl;
    test03();
    cout << "-----------------------" << endl;
    
    // system("read -p '按任意键继续...' var");
    
    return 0;
}


输出：
---------------------------------------------------------------------------------
Person 的有参构造函数调用
Person 的拷贝构造函数调用
P2的年龄为：20
Person 的析构函数调用
Person 的析构函数调用
-----------------------
Person 的无参构造函数调用
Person 的拷贝构造函数调用
Person 的析构函数调用
p的年龄为：10
Person 的析构函数调用
-----------------------
Person 的无参构造函数调用
0x7ffcc204b4d4
0x7ffcc204b4d4
Person 的析构函数调用
-----------------------

4. 构造函数调用规则

默认情况下，C++编译器至少给一个类添加三个函数：

  1. 默认构造函数（无参，函数体为空）

  2. 默认析构函数（无参，函数体为空）

  3. 默认拷贝函数，对属性进行值拷贝

构造函数调用规则：

  • 如果用户定义有参构造函数，C++不提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，C++不会提供其他构造函数

示例：

#include<iostream>
using namespace std;

//构造函数的调用规则
class Person
{
public:
    //1.默认情况下，C++编译器至少给一个类添加三个函数：
    //默认构造函数（无参，函数体为空）
    //默认析构函数（无参，函数体为空）
    //默认拷贝函数，对属性进行值拷贝
    Person()
    {
        cout << "Person 的默认无参构造函数调用" << endl;
    }

    //2.当用户自定义有参构造函数时，C++编译器将不再提供默认的无参构造函数，但依然提供拷贝构造函数
    Person(int age)
    {
        m_Age = age;
        cout << "Person 的有参构造函数调用" << endl;
    }

    //3.当用户自定义拷贝构造函数时，C++编译器将不再提供任何构造函数
    Person(const Person &p)
    {
        m_Age = p.m_Age;
        cout << "Person 的拷贝构造函数调用" << endl;
    }

    ~Person()
    {
        cout << "Person 的析构函数调用" << endl;
    }

    int m_Age;

};



void test01()
{
    Person p;
    p.m_Age = 18;
    Person p2(p);

    cout << "P2的年龄为：" << p2.m_Age << endl;
}


void test02()
{
    Person p(28);
    Person p2(p);

    cout << "P2的年龄为：" << p2.m_Age << endl;
}


int main()
{
    test01();  
    cout << "--------------------------------------------" << endl;
    test02();
    
    // system("read -p '按任意键继续...' var");
    
    return 0;
}


输出：
---------------------------------------------------------------------------------
Person 的默认无参构造函数调用
Person 的拷贝构造函数调用
P2的年龄为：18
Person 的析构函数调用
Person 的析构函数调用
--------------------------------------------
Person 的有参构造函数调用
Person 的拷贝构造函数调用
P2的年龄为：28
Person 的析构函数调用
Person 的析构函数调用

5. 深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是一个常见的坑

  • 浅拷贝：简单的赋值拷贝操作

  • 深拷贝：在堆区重新申请空间，进行拷贝操作

示例：

#include<iostream>
using namespace std;

//深拷贝与浅拷贝
class Person
{
public:
    Person()
    {
        cout << "Person 的默认无参构造函数调用" << endl;
    }

    Person(int age, int height)
    {
        m_Age = age;
        m_Height = new int(height);
        cout << "Person 的有参构造函数调用" << endl;
    }

    Person(const Person &p)
    {
        cout << "Person 的拷贝构造函数调用" << endl;
        m_Age = p.m_Age;
        // m_Height = p.m_Height;  编译器默认实现这行代码，浅拷贝，导致重复清空同一块内存空间（非法操作）
        m_Height = new int(*p.m_Height);  //深拷贝，解决浅拷贝的问题
    }

    ~Person()
    {
        //析构代码的用途：将堆区开辟的数据进行释放
        if (m_Height != NULL)
        {
            delete m_Height;
            m_Height = NULL;
        }
        cout << "Person 的析构函数调用" << endl;
    }

    int m_Age;
    int *m_Height;
};


void test01()
{
    Person p1(18, 160);
    cout << "p1的年龄：" << p1.m_Age << ", 身高为：" << *p1.m_Height << endl;

    Person p2(p1);
    cout << "p2的年龄：" << p2.m_Age << ", 身高为：" << *p2.m_Height << endl;
}

int main()
{
    test01();  
    // cout << "--------------------------------------------" << endl;
    // test02();
    
    // system("read -p '按任意键继续...' var");
    
    return 0;
}


输出：
---------------------------------------------------------------------------------
Person 的有参构造函数调用
p1的年龄：18, 身高为：160
Person 的拷贝构造函数调用
p2的年龄：18, 身高为：160
Person 的析构函数调用
Person 的析构函数调用

总结：如果类中有属性是在堆区开辟的，为了合法的释放掉堆区的内存，一定要自己提供拷贝构造函数，防止浅拷贝（编译器生成的默认拷贝函数）带来的问题。

6. 初始化列表

作用：C++提供了初始化列表的语法，用来初始化属性

语法：构造函数(): 属性1(值1), 属性2(值2), ...{}

示例：

#include<iostream>
using namespace std;

//初始化列表(test01)
class Person
{
public:
    //传统初始化操作
    // Person(int a, int b, int c)
    // {
    //     m_A = a;
    //     m_B = b;
    //     m_C = c;
    // }

    //初始化列表初始化属性
    Person(int a, int b, int c) : m_A(a), m_B(b), m_C(c)
    {
        cout << "初始化列表初始化属性" << endl;
    }

    int m_A;
    int m_B;
    int m_C;
};


void test01()
{
    // Person p(10, 20, 30);

    Person p(30, 20, 10);
    cout << "m_A = " << p.m_A << endl;
    cout << "m_B = " << p.m_B << endl;
    cout << "m_C = " << p.m_C << endl;
}


int main()
{
    test01();  
    // cout << "--------------------------------------------" << endl;
    // test02();
    
    // system("read -p '按任意键继续...' var");
    
    return 0;
}


输出：
---------------------------------------------------------------------------------
初始化列表初始化属性
m_A = 30
m_B = 20
m_C = 10

7. 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

例如：

class A{}
class B
{
  A a;
}

B类中有对象A作为成员，A为对象成员

当创建B对象时，A与B的构造和析构的顺序是谁先谁后呢？

示例：

#include<iostream>
#include<string>
using namespace std;

//类对象作为类成员

//手机类
class Phone
{
public:

    //Phone() = default;
    Phone(string pName)
    {
        cout << "Phone 的构造函数调用" << endl;
        m_PName = pName;
    }

    ~Phone()
    {
        cout << "Phone 的析构函数调用" << endl;
    }

    //手机品牌名称
    string m_PName;
};

//人类
class Person
{
public:

    Person(string name, string pName): m_Name(name), m_Phone(pName)
    {
        // m_Name = name;
        // m_Phone.m_PName = pName;
        cout << "Person 的构造函数调用" << endl;
    }

    ~Person()
    {
        cout << "Person 的析构函数调用" << endl;
    }

    //姓名
    string m_Name;
    //手机
    Phone m_Phone;
};


//当其他类的对象作为本类成员时，需要选构造其他类对象，再构造本类对象,析构的顺序和构造的顺序相反
void test01()
{
    Person p("张三", "华为");

    cout << p.m_Name << "拿着" << p.m_Phone.m_PName << "手机" << endl;
}


int main()
{
    test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
Phone 的构造函数调用
Person 的构造函数调用
张三拿着华为手机
Person 的析构函数调用
Phone 的析构函数调用

结论：当其他类的对象作为本类成员时，需要选构造其他类对象，再构造本类对象,析构的顺序和构造的顺序相反 

8. 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

  • 静态成员变量

  • 所有对象构想同一份数据

  • 在编译阶段分配内存

  • 类内声明，类外初始化

  • 静态成员函数

  • 所有对象共享同一个函数

  • 静态成员函数只能访问静态成员变量

示例1：

静态成员变量.cpp

#include<iostream>
#include<string>
using namespace std;

//静态成员变量

//人类
class Person
{
public:

    //1.所有对象都共享同一份数据
    //2.编译阶段就分配内存
    //3.类内声明，类外初始化
    static int m_A;

    //静态成员变量也是有访问权限的
private:
    static int m_B;
};


int Person::m_A = 100;
// int Person::m_B = 200;  //类外访问不到私有静态成员变量


//当其他类的对象作为本类成员时，需要选构造其他类对象，再构造本类对象,析构的顺序和构造的顺序相反
void test01()
{
    Person p;
    cout << p.m_A << endl;

    Person p2;
    p2.m_A = 200;
    cout << p.m_A << endl;
}


void test02()
{
    //静态成员变量，不属于某个对象，所有对象共享同一份数据
    //因此，静态成员变量有两种访问方式：

    //1.通过对象进行访问
    Person p;
    cout << p.m_A << endl;

    //2.通过类名进行访问
    cout << Person::m_A << endl;
    // cout << Person::m_B << endl;  //类外访问不到私有静态成员变量
}

int main()
{
    test01();
    test02();

    return 0;
}


输出：
---------------------------------------------------------------------------------
100
200
200
200

静态成员函数.cpp

#include<iostream>
#include<string>
using namespace std;

//静态成员函数.cpp
//1.所有对象共享同一个函数
//2.静态成员函数只能访问静态成员变量

//人类
class Person
{
public:

    static void func()
    {
        m_A = 100;  //静态成员函数可以访问静态成员变量
        //m_B = 100;  //静态成员函数不能访问非静态成员变量,无法区分到底是那个对象的成员变量
        cout << "static void func() 调用" << endl;
        cout << "m_A = " << m_A << endl;
    }

    static int m_A;
    int m_B;

    //静态成员函数也是有访问权限的
private:
    static void func2()
    {
        cout << "static void func2() 调用" << endl;
    }

};

int Person::m_A = 0;

void test01()
{
    //1.通过对象进行访问
    Person p;
    p.func();

    //2.通过类名进行访问
    Person::func();
    // Person::func2();  //类外访问不到私有的静态成员函数

}

int main()
{
    test01();

    return 0;
}


输出：
---------------------------------------------------------------------------------
static void func() 调用
m_A = 100
static void func() 调用
m_A = 100

 

大模型算法和部署
关注
  • 12
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
05 对象的初始化和清理.rar_C++
09-21
纯虚函数和抽象类；构造函数的分类及调用；构造函数和析构函数；继承；静态成员；拷贝构造函数调用；虚析构和纯虚析构；友元；运算符重载；多态及多态的三个案例：计算器类、制作饮品、电脑组装。
C++：类和对象：对象的初始化和清理
C++ JAVA的专栏
12-16 1130
C++：类和对象：对象的初始化和清理
C++类和对象：对象的初始化和清理
weixin_44751255的博客
10-06 664
本文是笔者在C++学习过程中，对类和对象的总结记录，如有不对以及不足的地方，欢迎大家指正！
C++类和对象——对象的初始化和清理
KevinJune的博客
02-11 1271
目录 对象的初始化和清理 1 构造函数和析构函数 2 构造函数的分类及调用 3 拷贝构造函数调用时机 4 构造函数调用规则 5 深拷贝与浅拷贝 6 初始化列表 7 类对象作为类成员 8 静态成员 对象的初始化和清理 ○生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全 ○C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置 1 构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 一个
C++对象的初始化和清理
qq_46359697的博客
10-12 314
对象的初始化和清理1.构造函数和析构函数2.构造函数的分类及调用3. 拷贝构造函数调用时机4.构造函数调用规则5.深拷贝与浅拷贝6.总结 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全 C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。 1.构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 ​ 一个对象或者变量没有初始状态，对其使用后果是未知 ​ 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安
c++对象的初始化和清理
m0_57413285的博客
04-09 4293
对象的初始化和清理：系统会自动进行 构造函数初始化： 创建对象的时候，函数自动调用 类名 （）{} 没有void，可以有参数，可发生重载，程序自动调用一次 析构函数清理：对象销毁前自动调用一次 ~类名 （）{} 没有void，不可以有参数，无法重载，程序自动调用一次 typedef class person { public: person() { cout << "构造函数" << endl; } ~person() { cout <&lt..
java初始化和清理
09-04
Java 的初始化问题和其他高级语言类似。一个明显不一样的地方是体现在它的类加 载过程。传统的编程语言包括C++等，程序是作为启动过程的一部分立刻被加载，而Java 的 类加载只在需要使用程序代码时才会被加载（每个...
面向对象与C++试题.doc
12-16
派生类的对象可以初始化基类的引用 C．派生类的对象可以直接访问基类中的成员 D．派生类的对象的地址可以赋给指向基类的指针 13、设置虚基类的目的是（ ）。 A．简化程序 B．消除二义性 C．提高运行效率 D．减少目标...
C++ 最通俗易懂的构造和析构函数讲解
01-06
注意：对象的初始化和清理工作是编译器强制我们要做的事情，即使你不提供初始化操作和清理操作，编译器也会给你增加默认的操作，只是这个默认初始化操作不会做任何事。 构造函数：实例化对象的时候系统自动调用 析构...
详解C++编程中的析构函数
12-31
创建对象时系统会自动调用构造函数进行初始化工作，同样，销毁对象时系统也会自动调用一个函数来进行清理工作（例如回收创建对象时消耗的各种资源），这个函数被称为析构函数。 析构函数（Destructor）也是一种特殊...
jar包增量更新分析
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
最新发布
博主是个二次元死肥宅~
05-18 677
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 620
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 905
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 247
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 652
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1024
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 253
java导出excel动态加载多sheet多复杂表头
C++中，类的析构函数的作用是对象的初始化吗
05-15
类的析构函数的作用是在对象销毁时执行一些清理工作，例如释放动态分配的内存、关闭文件、释放资源等。它是类的一种特殊成员函数，与类的构造函数相对应。在对象的生命周期结束时，系统会自动调用析构函数，以确保...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值