类的6个默认成员函数（C++）

已于 2024-04-04 10:32:17 修改
阅读量319 收藏 2
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-07-12 21:00:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kpl_20/article/details/131163259
版权

类的6个默认成员函数

一、认识类的默认成员函数

空类：如果一个类中没有任何成员。
空类中并不是什么都没有，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数。

类的六个默认成员函数

二、初始化和清理

1. 构造函数

构造函数的主要任务：初始化对象

①概念

eg：写一个简单的日期类

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

    void Print()
    {
        std::cout << _year << "-" << _month << "-" << _day << std::endl;
    }

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

int main()
{
    Date d1;
    d1.Init(2024, 4, 3);
    d1.Print();
    return 0;
}

对于Date类，可以通过公有方法给对象设置日期，但是每次都要调用公有方法Init设置信息。而使用构造函数就可以在创建对象时，就把信息设置进去

构造函数：名字和类名相同，创建类的类型对象时由编译器自动调用，给每一个数据成员一个合适的初始值，在对象的整个生命周期只调用一次。

②特性

构造函数是特殊的成员函数:

  1. 函数名和类名相同
  2. 无返回值
  3. 对象实列化时编译器自动调用对应的构造函数
  4. 构造函数可以重载
  5. 通过无参构造函数构造对象时，对象后面不要跟括号，否则就是函数声明了

eg：使用构造替换Init公有方法

class Date
{
public:
	// 1.无参构造函数
	Date()
	{}

	// 2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

void TestDate()
{
	Date d1;                   //调用无参构造函数
	Date d2(2015, 1, 1);       //调用带参的构造函数


	//通过无参构造函数构造对象时，对象后面不要跟括号，否则像下面这样就成为函数声明了
	//声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3();                 //warning
}
  1. 如果类中用户没有显示定义构造函数，编译器会自动生成一个无参的默认构造函数。

eg1:

class Date
{
public:
	//定义一个带参的构造函数。用户显示定义构造函数，编译器不会再生成
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	

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


int main()
{
	//将Date类带参构造函数屏蔽，代码可以通过编译，因为编译器会生成了一个无参的默认构造函数

	//将Date类带参构造函数放开，则编译失败
	//因为用户显示定义任何形式的构造函数，编译器都不会在自动生成
	Date d1;     // error C2512: “Date”: 没有合适的默认构造函数可用

	return 0;
}
  1. C++把类型分成内置类型（基本类型：int/char…）和自定义类型，编译器生成的默认构造函数会对自定义类型成员调用它的默认构造函数。

eg2:

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	//基本类型（内置类型）
	int _year;
	int _month;
	int _day;

	//自定义类型
	Time _t;
};

int main()
{
	Date d;
	return 0;
}


//运行结果：Time()

注：内置类型成员变量在类中声明时可以给默认值（C++11），例如下面这样
eg3:

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}

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;
}
  1. 默认构造函数只能有一个，有以下三种默认构造
    • 无参构造函数
    • 全缺省构造函数
    • 编译器默认生成的构造函数

eg4:

class Date
{
public:
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}

	Date(int year = 1900, int month = 1, int day = 1) //全缺省
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

int main()
{
	//不能通过编译。虽然构造函数重载，但是调用时无参调用，存在歧义
	Date d1;
	return 0;
}

③小结

  1. 一般情况构造函数都需要我们自己写
  2. 不写的情况
    a、内置类型都有缺省值，且初始化符合我们的要求
    b、全是自定义类型的构造，且这些类型都定义默认构造

2. 析构函数

析构函数的主要任务：对象中资源的清理

①概念

析构函数：局部对象的销毁工作是由编译器完成的，而对象在销毁时会自动调用析构函数，完成对象中资源清理的工作

②特性

析构函数是特殊的成员函数：

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

注：析构函数不能重载

eg：

typedef int DataType;   //如果不是int类型，是别的类型，便于维护。以后有模板也不用这样
class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 3) //缺省值
	{
		std::cout << "Stack(size_t capacity = 3)" << std::endl;
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (nullptr == _array)
		{
			perror("malloc::fail");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	//析构函数
	~Stack()
	{
		std::cout << "~Stack()" << std::endl;
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack s;
	return 0;
}

//运行结果：
//Stack(size_t capacity = 3)
//~Stack()
  1. 编译器生成的默认析构函数，对自定义类型成员会调用它的析构函数。

eg1:

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	//基本类型（内置类型）
	int _year = 1900;
	int _month = 1;
	int _day = 1;

	//自定义类型
	Time _t;
};

int main()
{
	Date d;
	return 0;
}
//运行结果：~Time()
//d对象中包含了自定义类型和内置类型。内置类型成员，销毁时不需要资源清理，系统直接将
//其内存回收。而自定义类型成员_t是Time类对象，所以销毁_t时要调用Time类的析构函数。
//but:main方法不能直接调用Time类的析构，所以要先调用Date类的析构函数，而Date类没
//有显示提供，所以编译器默认生成Date类析构函数，在其内部调用Time类析构
//当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁

③小结

  1. 要写析构函数的情况：有动态申请资源就要显示写析构函数释放资源。
  2. 不要写析构函数的情况：
    a. 没有动态申请资源，不需要写析构。
    b. 需要释放的成员都是自定义类型，不需要写析构

eg:

//这样就不需要我们写析构
class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};

三、拷贝构造和赋值运算符重载

1. 拷贝构造函数

①概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用（一般常用const修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。

②特性

拷贝构造也是特殊的成员函数：

  1. 拷贝构造函数是构造函数一种重载形式。
  2. 拷贝构造函数的参数只有一个，且必须是类类型对象的引用。

注意：使用传值方式编译器直接报错，会引发无穷递归

eg1:

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

	//拷贝构造函数
	//Date(const Date d) //error：编译器报错引发无穷递归
	Date(const Date& d)  //ok
	{
		_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. 默认生成的拷贝构造函数，内置类型按照字节直接拷贝，而自定义类型是调用它的拷贝构造完成拷贝

eg2：值拷贝

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}

	Time(const Time& t)
	{
		cout << "Time(const Time& t)" << endl;
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	int _year = 1900;
	int _month = 1;
	int _day = 1;

	Time _t;
};

int main()
{
	Date d1;

	//使用d1拷贝构造d2，此处调用Date类的拷贝构造
	//但是Date类没有显示定义拷贝构造，则编译器会给Date类生成一个默认的拷贝构造
	
	//编译器生成的默认拷贝构造，内置类型是按照字节序方式直接拷贝，
	//而自定义类型是调用其拷贝构造函数完成拷贝的
	Date d2(d1); 
	return 0;
}

//运行结果：
Time(const Time& t)

③小结

默认的拷贝构造函数不够用，因为有深拷贝的存在
1. 拷贝构造是为了深拷贝而生：
浅拷贝图解：
拷贝构造是为了深拷贝而生

为栈实现一个深拷贝构造函数
eg:

	Stack(const Stack& st)
	{
		_array = (int*)malloc(sizeof(int ) * st._capacity);
		if (nullptr == _array)
		{
			perror("malloc::fail");
			return;
		}

		memcpy(_array, st._array, sizeof(int) * st._size);
		_size = st._size;
		_capacity = st._capacity;
	}

注：
类中如果没有涉及资源申请，拷贝构造函数写不写都行。但是涉及到资源的申请，则一定要写拷贝构造，否则就是浅拷贝

2. 拷贝构造函数典型调用场景：

  • 使用已存在对象创建新对象
  • 函数参数类型为类类型对象
  • 函数返回值类型为类类型对象

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

2. 赋值运算符重载

①运算符重载

C++为了增加代码的可读性，引入了运算符重载，运算符重载是具有特殊函数名的函数。和不同函数区别就在于函数名，返回值类型和参数列表和普通函数类似
函数名定义：关键字operator后面直接跟重载的运算符符号
语法：返回值类型 operator操作符(参数列表)

注：

  1. 不能通过其他的符号创建新的操作符。eg：operator@
  2. 重载操作符必须有一个类类型的参数
  3. 用于内置类型的运算符，其含义不能改变。eg：内置类型的+，不能把其当作减法来用
  4. 作为类成员函数重载时，其形参看起来比操作数数目少一。原因：成员函数第一个参数为隐藏的this
  5.   .*  :: sizeof  ?:  .        以上五个运算符不能重载

eg:

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

	//bool opeartor==(Date* this, const Date& d2)
	//左操作数是this，指向调用函数的对象
	bool operator==(const Date& d2)
	{
		return _year == d2._year
			&& _month == d2._month
			&& _day == d2._day;
	}

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

//运算符重载写成全局的，但是这里就需要使用公有的成员变量了。
//需要解决，友元可以解决该问题
//bool opeartor==(Date* this, const Date& d2);

int main()
{
	Date d1(2023, 7, 13);
	Date d2(2023, 7, 13);

	//(d1 == d2) <==> d1.operator==(d2)
	cout << (d1 == d2) << endl;
	cout << d1.operator==(d2) << endl;
	return 0;
}

②赋值运算符重载特性

  1. 赋值运算符重载格式：
  • 参数类型：const T& （传递引用提高传参效率）
  • 返回值类型：T& (返回值引用可以提高返回效率，有返回值为了支持连续赋值)
  • 函数体：
    - 检测是否是自己给自己赋值
    - 返回*this：要符合连续赋值的含义

eg1：

class Date
{
public:
	//构造函数
	Date(int year = 1900, 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;
	}

	//赋值运算符重载
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		//this的生命周期结束，但是Date类创建的对象生命周期还没有结束
		return *this;
	}

private:
	int _year;
	int _month;
	int _day;
};
  1. 赋值运算符只能重载成类的成员函数不能重载成全局函数

eg2：

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

//赋值运算符重载成全局函数
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}

int main()
{
	Date d1(2023, 7, 12);
	Date d2, d3;
	d2 = d3 = d1;
	return 0;
}

运行结果：代码编译失败。原因：在类中没有显示实现，编译器会默认生成，此时用户在类外自己实现一个全局的赋值运算符重载就和默认生成的冲突了

  1. 没有显示实现，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
    注意：内置类型成员变量直接赋值，而自定义类型成员变量需要调用类的赋值运算符重载完成赋值

eg3：

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	Time& operator=(const Time& t)
	{
		cout << "Time& operator=(const Time& t)" << endl;
		if (this != &t)
		{
			_hour = t._hour;
			_minute = t._minute;
			_second = t._second;
		}

		return *this;
	}

private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	int _year;
	int _month;
	int _day;

	Time _t;
};

int main()
{
	Date d1;
	Date d2;
	d1 = d2;

	return 0;
}

//运行结果：Time& operator=(const Time& t)

③小结

一旦涉及资源管理必须要实现运算符重载，如果未涉及到，是否实现都可以。
值拷贝

拷贝构造和赋值运算符重载的区别：
拷贝构造函数：用一个对象初始化创建另一个对象
赋值运算符重载：两个已经创建的对象，一个赋值给另一个。

eg：

    Date d1(2023, 1, 1);
    Date d2 = d1;   //拷贝构造
    Date d3(d1);    //拷贝构造
    d2 = d3;        //赋值运算符重载

四、取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器会默认生成。主要解释：自定义类型使用运算符要重载。
eg:

class Date
{
public:
	Date* operator&()
	{
		return this;
	}

	const Date* operator&() const  //这个const实际修饰*this
	{
		return this;
	}

private:
	int _a;
};

有些情景，比如不想让别人看

return nullptr;

总结

  1. 类的六个默认成员函数不能定义为全局函数。它们必须定义在类的内部作为成员函数。
  2. 类的默认成员函数可以在两个文件中进行声明和定义分离。将类的接口和实现分开，使代码更加模块化和可维护。

构造函数：

  1. 一般情况构造函数都需要我们自己写
  2. 不写的情况
    a、内置类型都有缺省值，且初始化符合我们的要求
    b、全是自定义类型的构造，且这些类型都定义默认构造

析构函数：

  1. 要写析构：有动态申请资源就要显示写析构函数释放资源。
  2. 不要写析构：
    a、没有动态申请资源，不需要写析构。
    b、需要释放的成员都是自定义类型，不需要写析构

拷贝构造函数：
拷贝构造是为了深拷贝而生。
类中如果没有涉及资源申请，拷贝构造是否写都可以，一旦涉及资源申请就一定要写拷贝构造

赋值运算符：
没有显示实现，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
一旦涉及资源管理必须要实现运算符重载，如果未涉及到，是否实现都可以。

拷贝构造函数和赋值运算符的区别：
拷贝构造函数：用一个对象初始化创建另一个对象
赋值运算符重载：两个已经创建的对象，一个赋值给另一个。

kpl_20
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 类的 6个默认成员函数
weixin_62862113的博客
08-24 438
学习笔记：C++ 类的 6个默认成员函数
【C++】类与对象（中篇：类的六个默认成员函数）
zhao_leilei的博客
08-21 1338
文章目录1.类的六个默认成员函数2.构造函数3.析构函数4.拷贝构造函数5.赋值运算符重载6.const修饰类的成员函数7.取地址及const取地址操作符重载 1.类的六个默认成员函数 如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。 class Date{}; 2.构造函数 2.1 概念 构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员都有 一个合适的初始值，并且在对象
【C++】类和对象（中上）：类的六个默认成员函数——构造函数、析构函数、拷贝构造函数！
zz02_24的博客
05-24 1355
上一篇文章我们浅浅的了解类与对象，知道了如何定义一个类，而今天我们更加深入的了解类与对象，也就是了解类的六个默认成员函数。接下来让我们进入学习。初学者对于构造函数，析构函数，拷贝构造函数时一大难点，所以需要下去多练习多思考。
C++默认成员函数
最新发布
woods12351的博客
04-25 825
但空类中会有编译器自动生成的6个默认成员函数。
【C++】类的6个默认成员函数（超详细）
qq_63231615的博客
08-10 2744
1. 类的6个默认成员函数 2. 构造函数 3. 析构函数 4. 拷贝构造函数 5. 赋值运算符重载 6. const成员函数 7. 取地址及const取地址操作符重载
C++的六个默认函数
weixin_42422557的博客
05-08 775
C++中，类有六个默认函数，分别是： 目录 1、构造函数 2.析构函数 3.拷贝构造函数 4、赋值运算符重载函数 5、取地址操作符重载函数 6、const修饰的取地址符重载函数 1、构造函数 定义：在定义一个对象的同时，希望能给它的数据成员赋值——对象的初始化的成员函数，叫做构造函数。 在C++中，由于类的封装性，它不允许在类的非成员函数中直接访问类对象的私有和保护数据成员...
C++_类中的6个默认成员函数
weixin_43853178的博客
10-13 2042
C++类中有6个默认函数，分别是：构造函数、析构函数、拷贝构造函数、赋值运算符重载、取地址及const取地址运算符重载。这六个函数是很特殊的函数，如果我们不自己实现，编译器就会自己实现。这篇博客中将一一介绍这六个默认函数。
【C++】类的6个默认成员函数详解
阿润菜菜的博客
02-06 4404
必须懂的C++类和对象中的默认成员函数
c++ 类的默认八种函数
JMW1407的博客
10-05 9016
类的默认八种函数类的默认八种函数参考 类的默认八种函数 参考 1、https://www.cnblogs.com/lsgxeva/p/7668200.html
C++类中的特殊成员函数示例详解
01-21
C++类中有几个特殊的非静态成员函数，当用户未定义这些函数时，编译器将给出默认实现。C++11前有四个特殊函数，C++11引入移动语义特性，增加了两个参数为右值的特殊函数。这六个函数分别是： 1、默认构造函数 默认...
C++中的四个默认成员函数与运算符重载详解
08-29
C++中的四个默认成员函数与运算符重载详解 C++中的四个默认成员函数与运算符重载详解是面向对象程序设计中非常重要的概念。四个默认成员函数包括构造函数、析构函数、拷贝构造函数和赋值运算符重载函数，这些函数是...
对C++默认构造函数的一点重要说明
12-31
造其实是可有可无的，所以不妨说编译器其实是为每个类生成了默认构造函数的。 在深度探索C++对象模型中讲了四种关于编译器自动生成默认构造函数的情况，在这四种情况下生成的默认构 造函数里面是由实质的隐含代码...
C++空类默认函数详细解析
09-04
当我们声明一个空类时，C++编译器会自动为这个类提供一组默认的成员函数，以确保类实例的正确操作。这些默认函数包括： 1. **默认构造函数**： 默认构造函数是一个无参数的构造函数，它的作用是初始化对象。对于空...
C++类成员构造函数和析构函数顺序示例详细讲解
09-04
1. **基类构造函数**：如果一个类是另一个类的派生类，那么在创建派生类对象时，首先会调用基类的默认构造函数。这是为了确保基类的部分能够正确初始化。 2. **非静态数据成员**：接着，按照在类中声明的顺序，初始...
【C++】类的六大默认成员函数
学了就忘是正常现象
10-14 2915
C++类的六大默认成员函数。
【C++】类与对象（二）—— 类的默认成员函数
丁丁逗的博客
09-14 433
1. 类的6个默认成员函数 如果一个类中什么成员都没有，简称为空类。 空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，都会自动生成下面6个默认成员函数。 2. 构造函数 概念 class Date { public: void SetDate(int year, int month, int day) { _year = year; _month = month; _day = day; } void Display() { cout << _year
C++——类的默认成员函数
zcxmjw的博客
03-02 596
本篇文章主要是深入了解类的默认成员函数的各个特性，方便在日后更加灵活的使用类。
【 C++ 】类和对象（中）—— 类的6个默认成员函数
bit_zyx的博客
06-04 3326
目录 1、类的6个默认成员函数 2、构造函数 构造函数概念 构造函数特性 3、析构函数 析构函数概念 析构函数特性 4、拷贝构造函数 拷贝构造函数概念 拷贝构造函数特性 5、赋值运算符重载 运算符重载 赋值运算符重载 6、const成员 const修饰类的成员函数 7、取地址及const取地址操作符重载 1、类的6个默认成员函数 ......
c++类的默认成员函数是什么
05-13
在C++中，如果你没有定义类的构造函数、拷贝构造函数、拷贝赋值运算符和析构函数，编译器会自动生成这些函数的默认实现。这些默认成员函数的行为是： 1. 默认构造函数：如果你没有定义任何构造函数，编译器会生成一个默认构造函数。这个默认构造函数不接受任何参数，它会初始化对象的所有成员变量为默认值（例如：数值类型为0，指针类型为NULL，布尔类型为false等等）。 2. 拷贝构造函数：如果你没有定义拷贝构造函数，编译器会生成一个默认的拷贝构造函数。这个拷贝构造函数会将一个对象的值复制到另一个对象中。 3. 拷贝赋值运算符：如果你没有定义拷贝赋值运算符，编译器会生成一个默认的拷贝赋值运算符。这个运算符用于将一个对象的值赋给另一个对象。 4. 析构函数：如果你没有定义析构函数，编译器会生成一个默认的析构函数。这个析构函数会在对象被销毁时自动调用，它的作用是释放对象所占用的资源。 需要注意的是，如果你的类中有指针类型的成员变量，那么默认的拷贝构造函数和拷贝赋值运算符可能会出现问题，因为它们只是简单地复制指针，而不是复制指针所指向的对象。这时候你需要自己来定义拷贝构造函数和拷贝赋值运算符，以确保指针所指向的对象也被正确地复制和销毁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kpl_20

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值