类-六个默认成员函数

最新推荐文章于 2022-10-15 01:22:17 发布
最新推荐文章于 2022-10-15 01:22:17 发布
阅读量845 收藏
点赞数 3
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43935646/article/details/105808568
版权

目录

6个成员函数
  　假如定义一个类

class Date 
{
};

  　如果这个类中什么成员（成员变量/成员函数）都没有，就称为空类。空类中并不是什么都没有，任何一个类在不写的情况下，都会自动生成上面6个默认成员函数。

1、构造函数

1.1 概念

  　 构造函数：在对象构造时调用的函数，完成初始化工作。构造函数是一个特殊的成员函数，名字与类名相同，对象实例化时自动调用对应的构造函数，保证每个数据成员都有 一个合适的初始值，并且在对象的生命周期内只调用一次。构造函数是一种特殊的成员函数，其主要任务并不是开空间创建对象，而是初始化对象。

1.2 特性

  　 1. 函数名与类名相同。
  　 2. 无返回值。
  　 3. 对象实例化时编译器自动调用对应的构造函数。
  　 4. 构造函数可以重载。 

#include<iostream>
using namespace std;

class Date
{
public:
	//这个就是自己写的无参的构造函数
	Date()
	{
		_year = 0;
		_month =1;
		_day = 1;
	}
    
	//带参数的构造函数
	Date(int year, int month, int day )
	{
		_year = year;
		_month = month;
		_day = day;
		cout << "Date()" << this << endl;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//成员变量都要封装成私有
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//会调用无参的那个构造函数
	Date d3(2020, 4, 5);//会调用带参数的那个构造函数
	d1.print();
	d2.print();
	system("pause");
	return 0;
}

  　 5.如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户自己显式定义，编译器便不再生成。
  　编译器自动生成的默认构造函数：1、对内置类型(基本类型)，即语法已经定义好的类型如：int /char …不调用 2、对自定义类型（我们使用class/struct/union自己定义的类型）调用其构造函数进行初始化，编译器生成默认的构造函数会对自定类型成员调用的它的默认成员函数。

class Time
{
public:
	Time()
	{
		m_hour = 0;
		m_minute = 0;
		m_second = 0;
		cout << "Time()" << endl;
	}
private:
	int m_hour;
	int m_minute;
	int m_second;

};

class date
{
public:
	void printf()
	{
		cout << m_year << "-" << m_month << "-" << m_day << endl;
	}
private:
     // 基本类型(内置类型)
	int m_year;
	int m_month;
	int m_day;
	//自定义类型
	Time _t;//会调用他的构造函数
};
int main()
{
	date d;//调用默认的无参构造函数
	d.printf();
	system("pause");
	return 0;
}

其结果如下：结果
  　 6.自己写的无参的构造函数和自己写的全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参的构造函数、全缺省的构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数（不用传参）。

2、析构函数

2.1 概念

  　 析构函数：与构造函数功能相反，析构函数对象生命周期到了就会自动调用.完成对象里面的资源清理工作。而对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。析构函数体内不是删除对象，而是仅仅做一些对象删除前的相关清理工作。

2.2 特性

  　 1. 析构函数名是在类名前加上字符 ~。
  　 2. 无参数无返回值。
  　 3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
  　 4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

class Stack
{
public:
	Stack(int n = 10)
	{
		_a = (int*)malloc(sizeof(int)*n);
		_size = 0;
		_capacity = n;
		cout << "Stack()" << endl;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
		cout << "~Stack()" << endl;
	}

private:
	int* _a;
	size_t _size;
	size_t _capacity;
};
int main()
{
    Stack st;;//析构函数完成资源清理的工作
    system("pause");
	return 0;
}

  　 5.编译器自动生成的析构函数，对会自定类型成员调用它的析构函数，对内置类型（基本类型）不会处理。和不显式定义时编译器自动生成的默认构造函数一样。

class Time
{
public:
	Time()
	{
		m_hour = 0;
		m_minute = 0;
		m_second = 0;
		cout << "Time()" << endl;
	}
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int m_hour;
	int m_minute;
	int m_second;

};
class date
{
public:
	date(int year = 0, int month = 1, int day = 1)
	{
		m_year = year;
		m_month = month;
		m_day = day;
		cout << "date()" << this << endl;
	}
private:
    //内置类型
	int m_year;
	int m_month;
	int m_day;
	//自定义类型
	Time _t;
};
int main()
{
    date d;
    system("pause");
	return 0;
}

示意图
  　 6.析构和构造的顺序不同，先构造的对象后析构，后构造的对象先析构。

class Date
{
public:
    Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
		cout << "Date()" << this << endl;
	}
	~Date()
	{
		cout << "~Date()" << this << endl;
	}
	private:
	//成员变量都要封装成私有
	int _year;
	int _month;
	int _day;
};
int main()
{
    Date d1;
    Date d2;
    system("pause");
	return 0;
}

在这里插入图片描述
  　因为当程序运行到system(“pause”); 时，会输出“请按任意键继续。。。”此时，主函数还未执行完，d1、d2为局部变量，只有等到函数体退出时，才会销毁，可是如果按下任意键进，函数体执行完毕，会输出“this指针的内容”，但由于输出窗口随后就关闭了，所以无法看到调用的析构函数。解决办法：解决办法：1.去system(“pause”)；按F10进行调试 2.按图这样写也可以。

3、拷贝构造函数

3.1 概念

  　 拷贝构造函数是构造函数的一个重载形式，也是特殊的成员函数【参数只有一个且必须使用引用传参】，该形参是对本类类型对象的引用(一般常用const修饰)，拷贝构造其实就是使用同类型对象初始化创建新对象，由编译器自动调用

3.2 特性

  　1. 拷贝构造函数是构造函数的一个重载形式。
  　2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
		cout << "Date()" << endl;
	}
	//如果是Date(Date d)会存在一个递归拷贝的问题-会无限递归
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		cout << "Date(const)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2020, 4, 11);
	Date d2(d1);//拷贝构造
	Date d3 = d1;//这种写法也是拷贝构造
	system("pause");
	return 0;
}

特别注意：拷贝构造函数要传一个对象的引用而不是传值！传值会构成无穷递归的问题。
在这里插入图片描述
  　3.若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝或者值拷贝。
  　注意：像日期这种不写拷贝构造函数，编译器会按照浅拷贝的方式来实现，浅拷贝是没有什么问题的。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
		cout << "Date()" << endl;
	}
private:
   int _year;
   int _month;
   int _day;
};
int main()
{
	Date d1;
    // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
    Date d2(d1);
    system("pause");
    return 0; 
}

值拷贝
  　假如是如下代码，不写拷贝构造函数，这时编译器生成的浅拷贝就会出现问题。浅拷贝会导致拷贝者和被拷贝者是同一个地址，指向同一块空间。

class Stack
{
public:
	Stack(int n = 10)
	{
		_a = (int*)malloc(sizeof(int)*n);
		_size = 0;
		_capacity = n;
		cout << "Stack()" << endl;
	}
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_size = _capacity = 0;
		cout << "~Stack()" << endl;
	}

private:
	int* _a;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack d1;
    Stack d2(d1);//会出现错误 -》同一块空间被释放了两次
    system("pause");
    return 0; 
}

在这里插入图片描述
  　当类中无需申请动态资源时，浅拷贝构造函数可以很好的工作。当需要申请动态内存时，即类中有指针变量，使用编译器默认生成的拷贝构造函数会出现问题。

4、赋值操作符重载

4.1 运算符重载概念

  　对于自定义类型来说不能使用运算符，要用就得实现重载函数。C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

4.1.1 特点

  　1.函数名字：关键字operator后面接需要重载的运算符符号。
  　2.函数原型：返回值类型 operator操作符(参数列表)
  　注意：
  　1）不能通过连接其他符号来创建新的操作符：比如operator@
  　2）重载运算符必须有一个是类类型或者是枚举类型的操作数。比如不能重载两个整形的加法运算符。
  　3）用于内置类型【基本类型】的操作符，其含义不能改变。
  　4）作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
操作符有一个默认的形参this，限定为第一个形参。
  　5）.* 、:: 、sizeof 、?: 、. 注意这5个运算符不能重载。

class Date
{
public:
    //构造函数
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    //拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//重载==
	//d1 ==d2 -> d1.operator(&d1,d2);这里是this指针 &d1取地址
	bool operator ==(const Date& d)//bool operator(Date* this, Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	//重载>
	bool operator >(const Date& d)
	{
		if (_year > d._year)
			return true;
		else if (_year == d._year && _month > d._month)
		{
			return true;
		}
		else if (_year == d._year && _month == d._month && _day > d._day)
		{
			return true;
		}

		return false;
	}
	void printf()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2020, 4, 11);
	Date d2(d1);//拷贝构造
	Date d3 = d1;//这种写法也是拷贝构造
	cout << (d1 == d3) << endl;
	Date d4(2020, 4, 1);
	cout << (d1 > d4) << endl;
	cout << (d4 > d2) << endl;
	system("pause");
	return 0;
}

  　输出结果如下：
输出结果

4.2 赋值重载概念

  　对于类类型的对象我们需要对‘=’重载，以完成类类型对象之间的赋值。需要注意的是赋值重载是对一个已存在的对象进行拷贝赋值。 而拷贝构造是创建一个对象时自动调用进行初始化的工作。

4.2.1 特点

  　1. 参数类型
  　2. 返回值：返回*this
  　3. 需要检测是否自己给自己赋值

class Date
{
public:
	//构造函数
	Date(int year = 0,int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//赋值操作符的重载   d2 = d1
	Date operator=(const Date& d)   
	{
		if (this != &d)             //避免自己给自己赋值
		{
			return	_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	void printf()
	{
		cout << _year << "-" << _month << "-" << _day << endl;

	}

private:
	int _year;
	int _month;
	int _day;
}；
int main()
{
	Date d1(2020,1,1);
	d1.printf();

	Date d2;
	d2 = d1;    
	d2.printf();
	return 0;
}

图片示例
  　其输出结构如下：
输出结果
  　注意：赋值运算符的重载,必须要有返回值，并且返回值是*this。因为：对于内置类型int a，int b，int c，是支持连续等a = b = c的，这块拆分成两个，首先将c赋值给b，然后是存在一个返回值的，再将这个返回值赋值给c。同理，对于类类型来说，也是一样的情况。
  　4. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝，也叫做浅拷贝。浅拷贝的问题在上面解释过，因此如果一个类中涉及到资源（比如：动态内存开辟空间），一定要自己给出析构函数、拷贝构造函数、赋值运算符函数。

5、const成员函数

5.1 概念

  　c++中如果一个const修饰一个变量的话，这个变量就成为了一个常量，具有宏的属性，在编译期间会将const所修饰的常量进行替换。如果是const修饰的类成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。const修饰的成员函数里面只能读取数据成员，不能改变数据成员；没有 const 修饰的成员函数，对数据成员则是可读可写的。

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void printf()const //因为this指针是隐含的 ->void printf(const Date* this)
	{
		cout << _year << "-" << _month << "-" << _day << endl;	
	}
private:
	int _year;
	int _month;
	int _day;
};

  　const修饰的是*this，所以this指针指向的内容不能改变。
  　注意：
  　1）const对象可以调用非const成员函数吗？
  　不可以。const修饰的对象是不可以修改对象的内容，如果调用非const成员函数，是可能会修改对象内容的，这是权限放大。
  　2）非const对象可以调用const成员函数吗？
  　可以。非const修饰的对象是可读可写的。const修饰的成员函数只能读，而不能修改，这是权限缩小。
  　3）const成员函数内可以调用其它非const的成员函数吗？
  　不可以。因为this指针的类型不同，这个函数的this指针的类型是
const Date * this ,而非const修饰的成员函数的 this指针为Date* this ,类型不同所以不能调用。
  　4）非const成员函数内可以调用其它的const成员函数吗？
  　可以。当前函数是可读可写的，调用const修饰的成员函数是只能读的，这是权限缩小。

//成员函数调用const成员函数
class date
{
public:
	date(int year = 0, int month = 1, int day = 1)
	{
		m_year = year;
		m_month = month;
		m_day = day;
		cout << "date()" << endl;
	}
	void f1()//void f1(date* this)
	{
		f2();//可以调用 属于权限缩小
	}
	void f2()const
	{

	}
	//void f3()
	//{

	//}
	//void f4()const //void f4(const date* this)
	//{
	//	f3();//不可以 ->属于权限放大
	//}
private:
	int m_year;
	int m_month;
	int m_day;
};

6、取地址及const修饰的取地址操作符重载

  　取址操作符重载函数返回值为该类型的指针，无参数。这两个默认的成员函数一般不用重新定义，编译器会重新生成。需要注意的是对象是const的，取地址就是const Date*this。

//对象是const的，取地址就是const Date*this
//取地址的成员函数
class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date* operator&()//Date* this
	{
		cout << "Date* operator&()" << endl;
		return this;
	}
	const Date* operator&()const//const Date* this
	{
		cout << "const Date* operator&()" << endl;
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;
	Date d2;
	const Date d3;
	cout << &d1 << endl;
	cout << &d2 << endl;
	cout << &d3 << endl;
	system("pause");
	return 0;
}

在这里插入图片描述

做我的猫嘛
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
类的六个默认成员函数
qq_43514458的博客
07-17 168
如果一个类中什么成员都没有，则就是空类。但是空类中什么都没有吗？其实并不是这样的，任何类在我们不写的情况下，都会自动生成下面六个默认成员函数。 class Date{}; 初始化和清理 构造函数 构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，但是需要注意的是构造函数的主要任务并不是开空间创建对象，而是初始化对象。 ...
类中的6个默认成员函数
Ksaila的博客
11-07 1347
1.构造函数 什么是构造函数？           构造函数是一个特殊的函数，名字与类名相同，创建类类型的对象的时候由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只能调用一次。 构造函数的特性          1.函数名与类名相同          2.没有返回值（就是在类名的前面不加任何的类型，void都不可以）          3.构造函数可...
浅谈类的六个默认的成员函数
微风
07-03 1952
越努力~越幸运~~~
c++类的默认六个成员函数
weixin_43198968的博客
04-12 198
c++中默认的六个成员函数分别是：构造函数，拷贝构造函数，赋值操作符重载函数，析构函数，取地址操作符重载函数，const修饰的取地址操作符重载函数。 一、构造函数： 1，构造函数是一个特殊的成员函数，名字与类同名，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。 2，并不是开空间创建对象，而是初始化对象：函数名与类同名，无返回值，对象实例化...
C++中的四个默认成员函数与运算符重载详解
08-29
四个默认成员函数包括构造函数、析构函数、拷贝构造函数和赋值运算符重载函数，这些函数是类的成员函数，用于定义类对象的创建、销毁、复制和赋值等操作。 1. 构造函数：构造函数是特殊的成员函数，用于初始化类...
C++类中的特殊成员函数示例详解
01-21
C++类中有几个特殊的非静态成员函数，当用户未定义这些函数时，编译器将给出默认实现。C++11前有四个特殊函数，C++11引入移动语义特性，增加了两个参数为右值的特殊函数。这六个函数分别是： 1、默认构造函数 默认...
C类的成员变量和成员函数-C教程共3页.pdf.zip
11-21
每个类可以有一个默认构造函数和多个带有参数的构造函数。 3. 析构函数：当对象生命周期结束时自动调用，用于清理资源。C++11引入了析构函数的默认规则，如果类中包含动态分配的资源，应提供一个析构函数来释放这些...
C++类的六个默认成员函数（总结）
Butayarou的博客
01-23 1190
任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。 文章目录一、构造函数（特殊的成员函数）二、析构函数（特殊的成员函数）三、拷贝构造函数（特殊的成员函数）四、赋值运算符重载函数五、取地址操作符重载 ~~最后加句号~~ 一、构造函数（特殊的成员函数） 1.主要任务：在创建对象时完成初始化工作 2.特征： 1）函数名与类名相同 2）无返回值 3）对象实例化时编译器自动调用构造函数 4）构造函数可以重载 默认构造函数有三种：全缺省的构造函数、无参的构造函数、用户不写编译器自动生成的构造函数。（注意
C++_类中的6个默认成员函数
weixin_43853178的博客
10-13 2044
C++类中有6个默认函数，分别是：构造函数、析构函数、拷贝构造函数、赋值运算符重载、取地址及const取地址运算符重载。这六个函数是很特殊的函数，如果我们不自己实现，编译器就会自己实现。这篇博客中将一一介绍这六个默认函数。
C++类和对象（中）——6个默认成员函数
qq_65285898的博客
10-15 2075
C++类和对象（中）
【C++】类与对象 ---类的6个默认成员函数
ajin156的博客
08-04 623
类的6个默认成员函数
继承（隐藏 & 派生类的六个默认成员函数）
HXiaoFan的博客
07-17 610
1 隐藏（重定义） 隐藏是指：在基类和派生类中有同名的成员变量或成员函数，那么派生类的成员变量、成员函数就将基类的隐藏（重定义）了。 如何调用隐藏的成员函数（或使用隐藏的成员变量）？ 指定作用域 2 派生类的六个默认成员函数 在默认情况下，派生类的默认成员函数由基类的成员函数合成（具体实现见下面的代码） （1）构造函数 子类的构造函数，继承了父类的构造函数，需要先调用父类...
类的六个默认成员函数（未完待续）
CY071512的博客
03-23 213
1. 构造函数 　　程序中常需要对变量赋初值进行初始化，这在基于过程的程序中是很容易的，在定义变量时赋以初值，比如： int a = 10; 　　而在基于对象的设计中，在定义一个对象时，也需要做初始化的工作，即对成员变量赋初值进行初始化。对象代表一个实体，每一个对象都有它确定的属性(成员变量)，在系统为对象分配内存时，应该对有关的数据成员初始化。 　　-如果一个类的所有成员变量都是公有的，...
【C++缺省函数】 空类默认产生的6个类成员函数
mazi的博客
06-01 1855
版权声明：转载请注明出处 http://blog.csdn.net/irean_lau。 目录(?)[+] 1、缺省构造函数。 2、缺省拷贝构造函数。 3、 缺省析构函数。 4、缺省赋值运算符。 5、缺省取址运算符。 6、 缺省取址运算符 const。 [cpp] view plain copy
类和对象 2 (6个成员函数)
Monster的博客
09-18 217
空类中真的是空的吗? 当然不是了 ! ! ! 编译器会自动生成成员函数 下面我们就来看看这些成员函数 1. 构造函数 函数名和类名相同, 无返回值, 可以重载, 编译器在创建时自动调用 首先来看看默认构造 默认构造函数 : (一个类中只能存在一个, 且必须存在一个默认构造函数) 1. 编译器默认生成 2. 显示定义的无参构造 3. 全缺省构造函数 注意: 只要显式定义了构造函数, 编译器就不会自动生成默认构造, 不管你定义的是不是默认构造 所以我们一般直接显式给一个全缺省的构造函数 cla
C++类中的6个默认成员函数
qq_44745063的博客
03-16 203
作者：小 琛 欢迎转载，请标明出处 引言： 类的6个默认的成员函数包括： 构造函数 析构函数 拷贝构造函数 赋值运算符重载函数 取地址操作符重载 const修饰的取地址操作符重载。 这里默认的意思是如果你不定义，则编译器会自动生成，而在实际操作中，我们往往自己实现前四个，后两个让编译器自动生成 构造函数 构造函数，顾名思义，为对象分配空间，进行初始化。它是一种特殊的成员函数，具有以下特点: ...
【C++】-- 类和对象（中）-- 类的默认成员函数
weixin_64609308的博客
08-30 597
【C过渡到C++】-- 类和对象（中）-- 类的默认成员函数 -- 1. 类的6个默认成员函数 2. 构造函数 3. 析构函数 4. 拷贝构造函数 5. 赋值运算符重载 6. const成员函数 7. 取地址及const取地址操作符重载...
为什么析构函数要声明为虚函数
kevin_org
03-27 1737
防止内训泄漏。 原因：如果在派生类中申请了内存空间，在析构函数对这块内存进行释放。假设基类中采用非虚析构函数，当删除基类指针指向派生类的对象时，就不会触发动态绑定，也不会调用派生类的析构函数。那么，派生类的内存空间得不到释放就会发生内存泄漏。 为什么不会触发动态绑定？ 所谓的动态绑定的条件是：基类的指针或引用有可能指向不同的派生类的对象。对于非虚函数，执行时实际调用该函数的对象类型为该指针或引用的...
类的六个默认成员函数可以定义成全局的吗，类的六个默认成员函数可以生命和定义分离在两个文件中吗
最新发布
07-13
类的六个默认成员函数（默认构造函数、析构函数、拷贝构造函数、拷贝赋值运算符、移动构造函数和移动赋值运算符）不能定义为全局函数。它们必须定义在类的内部作为成员函数。 类的默认成员函数可以在两个文件中进行...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值