【C++】5.类和对象（3）

已于 2024-08-10 18:40:19 修改
阅读量460 收藏 20
点赞数 18
分类专栏： C++学习2 文章标签： c++ 开发语言
于 2024-08-10 18:28:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hlyd520/article/details/141094455
版权

文章目录

3.析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值。 (这里跟构造类似，也不需要加void)
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
  4. 对象生命周期结束时，系统会自动调用析构函数。
  5. 跟构造函数类似，我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
  6. 还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
  7. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，如Date；如果默认生成的析构就可以用，也就不需要显示写析构，如MyQueue；但是有资源申请时，一定要自己写析构，否则会造成资源泄漏，如Stack。
  8. 一个局部域的多个对象，C++规定后定义的先析构。
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
    public:
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
    private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
    public:
    //编译器默认生成MyQueue的析构函数调用了Stack的析构，释放的Stack内部的资源
    // 显示写析构，也会自动调用Stack的析构
    /*~MyQueue()
     {}*/
    private:
    Stack pushst;
    Stack popst;
};
int main()
{
    Stack st;
    MyQueue mq;
    return 0;
}

对比一下用C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数确实方便了很多，不会再忘记调用Init和Destory函数了，也方便了不少。

#include<iostream>
using namespace std;
// 用最新加了构造和析构的C++版本Stack实现
bool isValid(const char* s) {
    Stack st;
    while (*s)
    {
        if (*s == '[' || *s == '(' || *s == '{')
        {
            st.Push(*s);
        }
        else
        {
            // 右括号比左括号多，数量匹配问题
            if (st.Empty())
            {
                return false;
            }
            // 栈里面取左括号
            char top = st.Top();
            st.Pop();
            // 顺序不匹配
            if ((*s == ']' && top != '[')
                || (*s == '}' && top != '{')
                || (*s == ')' && top != '('))
            {
                return false;
            }
        }
        ++s;
    }
    // 栈为空，返回真，说明数量都匹配 左括号多，右括号少匹配问题
    return st.Empty();
}
// 用之前C版本Stack实现
bool isValid(const char* s) {
    ST st;
    STInit(&st);
    while (*s)
    {
        // 左括号入栈
        if (*s == '(' || *s == '[' || *s == '{')
        {
            STPush(&st, *s);
        }
        else // 右括号取栈顶左括号尝试匹配
        {
            if (STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }
            char top = STTop(&st);
            STPop(&st);
            // 不匹配
            if ((top == '(' && *s != ')')
                || (top == '{' && *s != '}')
                || (top == '[' && *s != ']'))
            {
                STDestroy(&st);
                return false;
            }
        }
        ++s;
    }
    // 栈不为空，说明左括号比右括号多，数量不匹配
    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;
}
int main()
{
    cout << isValid("[()][]") << endl;
    cout << isValid("[(])[]") << endl;
    return 0;
}

/*
关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器
生成的默认析构函数，对自定类型成员调用它的析构函数。
*/
class Time
{
public:
    ~Time()
    {
        cout << "~Time()" << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

/*
 程序运行结束后输出：~Time()
 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是
 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；
 而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。
 但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函
 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time
 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
 main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数
*/

/*
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；
有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。
*/

注意：

  1. 一般情况下，有动态申请的资源，就需要显示所写的析构函数，来释放资源。

    例如：栈需要写析构

  2. 没有动态申请的资源，不需要写析构函数。因为没有资源需要释放。

    例如：

    class Data{
private:
	int _year;
	int _month;
	int _day;
	int _arr[100];
};

  3. 需要释放资源的成员都是自定义类型，不需要写析构函数。

    例如：

    class MyQue{
private:
	Stack _pushst;
	Stack _popst;
};

因为默认生成的构造会自动调用默认构造函数

默认生成的析构会自动调用默认析构函数

4.拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

拷贝构造的特点：

  1. 拷贝构造函数是构造函数的一个重载。
  2. 拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归调用。 拷贝构造函数也可以多个参数，但是第一个参数必须是类类型对象的引用，后面的参数必须有缺省值。
  3. C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。
  4. 若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
  5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的拷贝构造就可以完成需要的拷贝，所以不需要我们显示实现拷贝构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器自动生成的拷贝构造完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的拷贝构造会调用Stack的拷贝构造，也不需要我们显示实现MyQueue的拷贝构造。这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。
  6. 传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是一个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于一个野引用，类似一个野指针一样。传引用返回可以减少拷贝，但是一定要确保返回对象，在当前函数结束后还在，才能用引用返回。
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// d2(d1)
	//Date(Date& d);// 正确写法
	
    //拷贝构造函数
	Date(const Date& d)
	{
		cout << "Date(Date& d)" << endl;
		//注意：_year = d._year;这个里面的_year不是private:里面的int _year;
		//_year = d._year;这个左边的_year是d2的_year，也就是this->_year，因为this指针是d2，也就是d2传给了this
		//右边的d._year是d，也就是d1的_year
		_year = d._year;
		_month = d._month;
		_day = d._day;
		/*d._year = _year;
		d._month = _month;
		d._day = _day;*/
	}
private:
	int _year;
	int _month;
	int _day;
};

class MyQueue
{
private:
	/*Stack _pushst;
	Stack _popst;*/
};

void func(int i){}

void func(Date d) {}

int main()
{
	// 可以不写，默认生成的拷贝构造就可以用
	Date d1(2023, 4, 25);

	Date d2(d1);//Data(Data& d)里面的d是d1的别名
	//this指针是d2，也就是d2传给了this

	//内置类型直接拷贝，void func(int i);
	//直接把4个字节的10拷贝给i
	func(10);

	//自定义类型的拷贝，规定了要定义拷贝构造去拷贝
	//void func(Date d){}会先调用Date(const Date& d);然后进入void func(Date d) 
	//如果Date(const Date& d);改成了Date(Date d);那么就会出现无限递归，编译器会报错
	func(d1);

	

	// 必须自己实现，实现深拷贝
	/*Stack st1;
	Stack st2(st1);*/


	return 0;
}

警惕无穷递归！

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(const Date& d);// 正确写法

	//Date(const Date& d)   // 错误写法：编译报错，会引发无穷递归
	//{
	//	_year = d._year;
	//	_month = d._month;
	//	_day = d._day;
	//}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

1)：内置类型成员完成值拷贝/浅拷贝

2)：自定义类型成员会调用它的拷贝构造

自定义类型指向浅拷贝会出现两个问题：

  1. 析构两次，报错

  2. 一个函数修改会影响另一个函数

  1. Data和MyQueue都不需要写。因为MyQueue里面会调用Stack，而Stack需要自己实现。Stack的实现和MyQueue无关。

  2. Stack需要自己实现

class Stack
{
public:
	Stack(int capacity = 4)
	{
		cout << "Stack()" << endl;

		_a = (int*)malloc(sizeof(int) * capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}

		_capacity = capacity;		
		_top = 0;
	}

	// st2(st1)
	Stack(const Stack& st)
	{
		_a = (int*)malloc(sizeof(int) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}

		memcpy(_a, st._a, sizeof(int) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	int* _a = nullptr;
	int _top = 0;
	int _capacity;
};

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};

int main()
{
	//1):内置类型成员完成值拷贝/浅拷贝
	// 可以不写，默认生成的拷贝构造就可以用
	Date d1(2023, 4, 25);
	Date d2(d1);//Data(Data& d)里面的d是d1的别名
	//this指针是d2，也就是d2传给了this

	//2);自定义类型成员会调用它的拷贝构造
	//如果只传值，那么就会导致两个函数指向了同一个空间，析构函数调用的话就崩了
	// 而且就算不析构函数也会出问题。比如给其中一个函数赋值会影响另一个函数
	
	// 所以必须调用拷贝构造函数
	// 必须自己实现拷贝构造函数，实现深拷贝
	//栈后进先出，后创建的先析构，st2先析构，st1后析构
	//添加Stack(const Stack& st);前，会报错，因为st1和st2的析构函数指向了同一个空间，而一个空间无法释放两次
	//添加Stack(const Stack& st);后，不报错了
	//Stack(const Stack& st);就是我们自己实现的深拷贝
	Stack st1;
	Stack st2(st1);

	return 0;
}

注意：

在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

//这个采用引用返回是可以的，因为采用引用返回可以减少拷贝，而且函数结束后返回的值是没被销毁的
Stack& func1(){
    static Stack st;
    return st;
}
//这个采用引用返回是不可以的，因为函数结束后返回的值是被销毁了
Stack& func2(){
    Stack st;
    return st;
}

int main(){
    func1();
    func2();
    return 0;
}

传引用返回要谨慎，传值引用没事

Stack& Func()
{
 	static Stack st;//改成Stack st;就不行，因为Stack st;在Func()结束后就销毁了，就会导致拷贝构造传值错误
	st.Push(1);
	st.Push(2);
	st.Push(3);
	//...

	return st;
}

int main()
{
	Stack ret = Func();
	cout << ret.Top() << endl;

	return 0;
}

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// Date d2(d1);
	//是拷贝构造
	/*Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}*/

	// 不是拷贝构造，就是一个普通构造
	//Date(Date* p)
	//{
	//	_year = p->_year;
	//	_month = p->_month;
	//	_day = p->_day;
	//}

	//析构函数
	~Date()
	{
		cout << "~Date()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}

	STDataType Top()
	{
		assert(_top > 0);

		return _a[_top - 1];
	}

	// st2(st1)
	Stack(const Stack& st)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};

void Func(Stack st){}

void Func(int x){}

Date f()
{
	Date ret;
	//...
	return ret;
}

int main()
{
	Date d1(2024, 8, 9);
	//都是拷贝构造
	//自动生成的拷贝构造对内置类型成员变量会完成值拷贝 / 浅拷贝(一个字节一个字节的拷贝)
	Date d2(d1);
	Date d4 = d1;

	Date d5(f());
	Date d6 = f();

	//Satck不可以浅拷贝，因为Stack这里_a是一个指针，直接浅拷贝会导致两个指针指向同一块空间，析构就会崩溃
	Stack st1(10);
	Stack st2(st1);

	Func(st1);
	Func(1);

	MyQueue m1;
	MyQueue m2(m1);

	return 0;
}

这里就不调用拷贝构造了，因为这里是引用返回，不是传值返回

传值返回，返回的是值的拷贝，所以要调用拷贝构造

引用返回，返回的不是值的拷贝，返回的是它的别名，所以不调用拷贝构造

Date& operator=(const Date& d)//返回的是*this这个对象的别名，*this是d4
{
    if (this != &d)//以预防d1 = d1;的情况
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    return *this;
}
流星白龙
关注
  • 18
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++对象内存模型.pdf
04-18
本文讨论了 C++ 对象内存模型的基本概念和结构，并通过实验和分析来探索对象内存结构、简单类型相关数据、包含虚函数类的对象内存结构、继承下的多态性等问题。理解 C++ 对象内存模型对于 C++ 编程语言的学习和应用...
C++实验一-类与简单对象.doc
11-15
7. 面向对象程序设计的基本思想、基本方法和基本步骤：面向对象程序设计是基于对象和类的程序设计思想，强调模块化、抽象化和继承性。 8. MS Visual C++6.0 或 DEV C++调试 C++程序的基本方法、基本步骤：调试 C++...
C++类和对象详细总结
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++的类和对象
Cosmicsea的博客
05-21 5213
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++类和对象（一）
ll1175555的博客
07-13 1万+
目录面向过程和面向对象初步认识类的定义类的作用域类的实例化类的访问限定符及封装类的对象大小计算类成员函数this指针 面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 比如一个外卖系统 面向过程：下单、接单、送餐三个过程 面向对象：客户、商家、骑手，关注的是三个类对象之间的关系 类的定义 class Name { //类体:由成员函数和成员变量组成
C++类和对象
wh22141334的博客
07-18 3957
c++中的类和对象
c++类和对象（类的概念）
m0_58103115的博客
03-24 5209
1.类和对象概念 类：用来对实体（对象）进行描述，对象有什么属性，以及对象具有什么功能是一种自定义类型 对象：现实生活中所存在的 ，对象是对类的具体体现 用类类型创建出来的变量称为对象 2.类的定义 class[类名] { //类体：成员变量属性，成员变量功能 } 方法一：将类的声明和定义全部放在类中定义 方法二：在头文件中放类的声明，在源文件中放类的定义 5.类的访问限定符及封装 6.类的对象大小计算 7.类成员对象的this指针 ...
C++类对象和类指针的区别
热门推荐
Arcobaleno
04-17 2万+
好奇这个，所以参考了一些帖子，写下心得。 一篇转载率较高的帖子：C++ 类对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果： #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; int main...
C++类对象的创建方式
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-11 5935
C++类对象的创建方式
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
C++的.和-＞的区别
qq_45701131的博客
09-07 3397
C++的.和->运算符的区别
C++类对象进行排序
taoxing
08-29 4980
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
C++实验5-类和对象.pdf
09-30
C++实验5-类和对象.pdf
C++初阶+类和对象（上）.pdf
01-17
本节课将介绍C++中的类和对象的概念，包括面向过程和面向对象的初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化、类对象模型、this指针等内容。 1. 面向过程和面向对象初步认识 ...
C++类和对象练习 实现日期类
07-29
为了更好的理解`C++`类和对象的知识,我们可以动手实现一下`C++`的一个简单的日期类,完成相应的函数,更好的帮助我们理解类和对象. 从日期类的构造函数,拷贝构造,获取当月天数,日期与天数的运算,日期类相关的比较...
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 185
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 185
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 264
STL中的迭代器失效（vector为例）
C++ - 函数重载
jiaowenjie的专栏
08-06 306
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值