类与对象（中）

已于 2024-04-01 02:28:32 修改
阅读量610 收藏 29
点赞数 11
文章标签： c++ 开发语言
于 2024-04-01 02:12:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67466860/article/details/137121097
版权

类

六大默认成员函数

天选之子：这六个这些函数，编译器会默认生成一个函数，如果我们实现了，编译器就不会生成。
在这里插入图片描述

默认生成的构造与析构函数：
内置类型不做处理（C++11后可以给缺省值）
自定义类型调用对应的构造与析构函数
++++++++++++++++++++++++++++++++++++
默认生成的拷贝构造与赋值重载：
内置类型按照值拷贝 按字节进行拷贝
自定义类型成员，调用成员的拷贝构造或者赋值重载

构造函数

特征：

  1. 函数名与类名相同。
  2. 无返回值(可以什么都不用写)（不是要写void，而是什么都没有）。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载，一个类可以有多个构造函数多种初始化方式。建议提供全缺省的构造函数。
class Date
{
public:
    // 1.无参构造函数
    Date()//无返回值，不需要写void等
    {}
    // 2.带参构造函数
    Date(int year, int month, int day)//重载的构造函数
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year ;
    int _month ;
    int _day ;
};
int main()
{
    Date d1;//调用无参构造函数
    Date d2(2024,3,29);//调用有参构造函数
    return 0;
}
  1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。
class Date
{
public:
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;//自动生成的是可以使用的
	d1.Print();
	return 0;
}

在这里插入图片描述
一旦我们自己定义之后，编译器不会自动生成，如果此时存在不符合的构造函数程序会崩溃

class Date
{
public:
	Date(int year, int month, int day)//自定义函数构造
    {								  //编译器没有生成默认构造函数
        _year = year;				  //此时我们需要的一种构造函数，自定义函数没有满足需要
        _month = month;				  //程序就会报错
        _day = day;
    }
	void Print()
	{
		cout << _year << "年" << _month << "月" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//没有满足，该构造函数需要给默认生成/全缺省/无参的，而上面是有参数的构造函数
	d1.Print();
	return 0;
}

在这里插入图片描述
其实看到这里我们会有一个疑惑，为甚么默认生成的构造函数出现的是随机值？

因为生成的默认构造函数有缺陷，因为默认的构造函数对于内置类型的成员不做处理，自定义类型成员会去调用他的默认构造(不用传参数的构造)。
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。
注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数

但是之后在C++11中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时可以给缺省值。

private:
    int _year = 1;
    int _month = 1;
    int _day = 1;

析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

特征:

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载（同构造，内置成员不处理，自定义类型成员会调用他的析构函数）
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数
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;
}

在这里插入图片描述
如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如
Date类；有资源申请时，一定要写，否则会造成资源泄漏，

拷贝构造

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

要注意使用引用，因为传值传参会导致无穷递归
因为传值传参，内置类型，编译器可以直接拷贝（浅拷贝）， 自定义类型的拷贝，需要调用拷贝构造
而传引用的话就相当于对这一块空间起别名

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const Date& d)   // 正确写法。通常拷贝构造的传引用参数都加const 防止有人写反
    //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指针指向的空间，析构时，1指向的空间析构之后，2指针又把同一块空间又析构了一遍。
那么这样传参，指针指向的空间会相互影响。即两个指针指向的空间相同。
在这里插入图片描述

两个指针指向同一块空间问题：插入数据相互影响、析构两次程序崩溃
在这里插入图片描述
深拷贝就是开辟另一块空间，可以让他把数据放到另一块空间中
在这里插入图片描述

Stack(const Stack& st)
	{
		_array = (DataType*)malloc(sizeof(DataType) * st._capacity);//开辟一块新的空间
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			exit(-1);
		}
		memcpy(_array, st._array, sizeof(DataType) * st._size);//把内容拷贝过去
		_size = st._size;
		_capacity = st._capacity;
	}


什么情况下需要写拷贝构造？
自己实现了析构函数释放空间，就需要写拷贝构造。
因为写析构函数释放了资源，所以我们的函数申请资源了，所以需要拷贝构造
如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

运算符重载

函数重载是运算符重载的一部分。
C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

//<返回值类型> operator<重载运算符>(参数列表)//默认传单个参数，因为this指针会占据一个名额
 //举例
 bool operator==(const Date& d)
 {
 	//...函数主体	
 }

注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@，不能自创
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
5. .* (点星。没用过) :: (域作用符) sizeof (字节大小) ?:(三目运算) .（成员访问） 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

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

//赋值重载
class Date
{
public:
    //返回值是为了支持连续赋值，保证运算符的特性
    Date& operator=(const Date& d)//出作用域存在使用传引用
    {
        if (this != &d)//防止自我赋值
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;//连续赋值
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2024, 3, 30);
    Date d2(2024, 4, 20);
    return 0;
}

赋值运算符只能重载成类的成员函数不能重载成全局函数

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;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
 if (&left != &right)
 {
 left._year = right._year;
 left._month = right._month;
 left._day = right._day;
 }
 return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。
在这里插入图片描述
用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。
注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。
如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

赋值重载是两个已经定义好的对象

Date d1(2024,3,31);
d2=d1;//调用赋值重载
Date d3=d1;//调用拷贝运算

前后置++的区别

//++d
Date& operator++();
//d++
Date operator++(int);
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
 Date& operator++()
 {
 _day += 1;
 return *this;
 }
 // 后置++
 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
 //  而temp是临时对象，因此只能以值的方式返回，不能返回引用
 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }
private:
 int _year;
 int _month;
 int _day;
};

整个运算符重载的代码安置：
用日期类作为模板

#include"Date.h"
//声明与定义分离
int Date::GetMonthDay(int year, int month)
{
	assert(month > 0 && month < 13);
	int montharr[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 400) == 0))
	{
		return 29;
	}
	else
	{
		return montharr[month];
	}
}
Date::Date(int year, int month, int day)
{
    if (month > 0 && month < 13
        && (day > 0 && day <= GetMonthDay(year, month)))
    {
        _year = year;
        _month = month;
        _day = day;
    }
    else
    {
        cout << "日期非法" << endl;
    }
}
//d1.operator==(d2)
bool Date::operator==(const Date& d)
{
    return _year == d._year
        && _month == d._month
        && _day == d._day;
}
bool Date::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;
    }
    else
    {
        return false;
    }
}
bool Date::operator<=(const Date& d)//复用
{
    return *this < d || *this == d;
}
bool Date::operator>(const Date& d)
{
    return !(*this <= d);
}
bool Date::operator>=(const Date& d)
{
    return !(*this < d);
}
bool Date::operator!=(const Date& d)
{
    return !(*this == d);
}
//返回值是为了支持连续赋值，保证运算符的特性
Date& Date::operator=(const Date& d)//出作用域存在使用传引用
{
    if (this != &d)//防止自我赋值
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    return *this;
}

void Date::Print()
{
    cout << _year << "年" << _month << "月" << _day << endl;
}

Date& Date::operator+=(int day)
{
    if (day < 0)
    {
        *this -= -day;
        return *this;
    }
    _day += day;
    while (_day > GetMonthDay(_year, _month))
    {
        _day -=GetMonthDay(_year,_month);
        ++_month;
        if (_month == 13)
        {
            ++_year;
            _month = 1;
        }
    }
    return *this;
}
Date Date::operator+(int day)
{
    Date ret = *this;
   /* ret._day += day;
    while (ret._day > GetMonthDay(ret._year, ret._month))
    {
        ret._day -= GetMonthDay(ret._year, ret._month);
        ++ret._month;
        if (ret._month == 13)
        {
            ++ret._year;
            ret._month = 1;
        }
    }*/
    ret += day;//直接复用
    return ret;
}
Date& Date::operator-=(int day)
{
    if (day < 0)
    {
        *this += -day;
        return *this;
    }
    _day -= day;
    while (_day <= 0)//记得day是不能为0的
    {
        _month--;
        if (_month <= 0)
        {
            _year--;
            _month = 12;
        }
        _day += GetMonthDay(_year, _month);
    }
    return *this;
}
Date Date::operator-(int day)
{
    Date ret = *this;
    ret -= day;
    return ret;
}
//前置++
Date& Date::operator++()
{
    *this += 1;
    return *this;
}
//后置++
Date Date::operator++(int)//
{
    Date ret = *this;
    *this += 1;
    return ret;
}
//前置--
Date& Date::operator--()
{
    *this -= 1;
    return *this;
}
//后置--
Date  Date::operator--(int)
{
    Date ret = *this;
    *this -= 1;
    return ret;
}
//-的函数重载，d1-d2
int Date::operator-(const Date& d)
{
    Date max = *this;
    Date min = d;
    int flat = 1;
    if (*this < d)
    {
        max = d;
        min = *this;
        flat = -1;
    }
    int n = 0;
    while (min != max)
    {
        ++min;
        ++n;
    }
    return n * flat;
}

const修饰函数成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改

class L
{
public:
	void Print()
	{
		cout << _a << endl;
	}

private:
	int _a = 10;

};
void Func(const L& a)
{
	a.Print();
}
int main()
{
	L d;
	Func(d);
	return 0;
}

在这里插入图片描述

在这里插入图片描述
所以我们加上 const，避免权限的放大
const 修饰 *this
this的类型为const L*

	void Print() const//把参数改为 const L*
	{
		cout << _a << endl;
	}

内部不改变成员变量的成员函数时，最好加上const，因为const对象和普通对象都可调用

class Arr
{
public:
	int& operator[](int& d)
	{
		assert(d < 10);
		return _a[d];
	}
	const int& operator[](int& d) const//前面的const修饰返回值是传引用的const
	{								   //后面的const修饰参数类型为const int*
		assert(d < 10);				   //因为参数类型不同从而构成函数重载
		return _a[d];
	}
private:
	int _a[10];
	int _size;
};

int main()
{
	return 0;
}

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

这两个默认成员函数一般不用重新定义 ，编译器默认会生成 所以一般不会去重载取地址

class Date
{
public :
 Date* operator&()
 {
 	return this ;
 }
 const Date* operator&()const
 {
 	return this ;
 }
private :
	 int _year ; // 年
	 int _month ; // 月
	 int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需
要重载，比如想让别人获取到指定的内容！

L* operator&()
{	
	//return *this;
	return (L*)100000;//搞怪玩
}
青青丘比特
关注
  • 11
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
python中的类和对象
学Python的小白！
08-16 1万+
面向对象和面向过程二者相辅相成，并不是独立的,解决复杂问题，通过面向对象便于我们从宏观上把握事物之间复杂关系，方便我们分析整个系统；具体到微观操作，仍然使用面向过程来处理
C#类和对象
书启鸿蒙知秋枫
03-22 3035
一、面向对象概念 面向对象是一种符合人类思维习惯的编程思想，是基于结构分析的、以数据为中心的程序设计。把解决的问题按照一定的规则划分为许多独立的对象，通过调用对象的方法来解决问题。与原来面向过程的程序设计不同(通过调用函数)。 类(class)就是指具有相同性质和功能的整体 客观对象（object），从概念层面讲，就是某种客观事物的抽象（或功能） 抽象原则包括数据抽象和过程抽象两个方面：数据抽象就是定义对象的属性；过程抽象就是定义对象的操作。 类的三大特性：封装、继承和多态。 封装就是把客观对象
Java类与对象
xinhang10的博客
10-25 4039
此文章为大家全方位的讲解了什么是Java的类与对象，从类与对象是什么到类与对象如何创建如何实例化以及使用。并且为大家介绍了类的成员有成员变量、成员方法。如何实现private的封装以及如何使用getter和setter方法还有我们的构造方法和代码块，最后最后在文章的结尾教给了大家如何通过电脑自己实现自己生成private的封装，setter和getter的定义以及toSring的定义方法。
java类和对象
qq_52592775的博客
05-29 5518
自己对于类和对象的一点见解，后面会持续更新
伴生类、伴生对象
qianchun22的博客
10-26 3414
参考博客：https://blog.csdn.net/m0_48758256/article/details/109241456 伴生（Companion） 1、单例对象与同名类定义在同一文件中时形成绑定关系 同名类称为单例对象的伴生类（class） 单例对象称为同名类伴生对象（object） 2、伴生类与伴生对象可相互访问各自私有成员 3、伴生对象可为伴生类增加静态成员 伴生类与伴生对象 案例： 前提:同一个文件的class和object 名字相同 伴生类和伴生对象在同一个文件中，名字相同，cl
编程语言-go:类与对象的概念
eyeofeagle的博客
01-20 2356
go中没有类和对象的概念，只有struct和变量与之对应 1，定义“类”: struct type Books struct{ title string author string id int } 2, 创建“对象”: 变量 var book1 Books book1.title=&quot;go-languange&quot; book1...
java类与对象实验报告心得体会_java实验报告类和对象实验报告
weixin_33325305的博客
12-29 2089
实验报告课程名称面向对象程序设计实验名称实验三、类和对象日期2018/4/9学生学号姓名班级实验目的：1．掌握面向对象编程语言中的类和对象的使用方法。2．理解类的封装性。实验条件：电脑一台、能上网查阅资料。实验内容与步骤：要求：设计和实现一个学生类，满足以下要求：1、学生具有学号、姓名、性别、年龄和专业等属性；2、可以修改和获取年龄和专业等信息；3、只能获取但不允许修改学生的姓名、性别和学号信息；...
C++编程语言中类对象的赋值与复制介绍（一）
热门推荐
liitdar的博客
08-20 4万+
本系列文章主要介绍C++编程语言中类对象的赋值和复制操作，以及两者之间的区别，另外还会介绍“深拷贝”与“浅拷贝”的相关知识。本文为系列文章的第一篇，主要介绍C++编程语言中类对象的赋值的相关知识。
如何创建与使用 类与对象
weixin_58942225的博客
06-09 2052
对象的创建和使用 一：在面向对象编程中，将对象具有的特征称为属性，通常情况下不同对象具有不同的属性或属性值。除此以外，对象还能执行某些操作或具备某些行为能力 二：对象能执行的操作或具备的行为能力称为方法，对象就是由一系列属性和一系列方法组成 ...
Java中对象和类的关系
qq_61411852的博客
02-25 4558
Java的对象与类的关系
类与对象练习.pdf
08-12
在OOP中，类和对象是两个基本概念。 类（Class）是一种引用数据类型，是对一类事物的抽象描述，是对象的模板。类定义了对象的属性和行为，对象是类的实例。 封装（Encapsulation）是OOP的三大特征之一，它将对象的...
java类与对象
12-21
java类与对象 类与对象的概念类的定义格式对象的创建和使用对象的创建对象访问类的变量与方法成员变量默认值成员变量的封装步骤# 封装中this关键字的使用成员方法的重载overload重载的意义重载的格式构造方法构造...
二_类与对象_
10-03
在编程世界中，类与对象是面向对象编程（OOP）的核心概念。面向对象编程是一种设计和实现软件的方法，它基于“对象”的概念，而这些对象则是类的实例。类可以看作是创建对象的蓝图，它定义了对象的数据属性和行为。...
第十章 类与对象
01-07
本章详细介绍了 C++ 中面向对象编程的核心概念——类与对象。通过定义类来组织和管理代码，不仅可以提高程序的可读性和可维护性，还能更好地模拟现实世界中的复杂系统。掌握了类与对象的基本原理后，开发者可以更...
C++ 类与对象习题
10-14
- **类定义**: C++中用来描述一类对象的共同特征和行为的概念。它是一个抽象数据类型，包含了数据成员和成员函数。 - **成员函数**: 定义在类中的函数，用于实现类的行为。 - **数据成员**: 定义在类中的变量，用于...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 682
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
QT C++上位机软件开发，相比较C#上位机软件开发，有哪些特点和区别
曾经的我也很优秀，现在的我一无所有。
08-20 421
在开发上位机软件时，选择使用Qt C++还是C#取决于多种因素，包括项目需求、团队技能、开发速度等因素。
c++ error: ‘this’ was not captured for this lambda function
xiaozhi
08-20 371
c++ error: ‘this’ was not captured for this lambda function
C++ 基础
最新发布
weixin_51883798的博客
08-22 264
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
面向对象编程：VC++中的类与对象详解
本文档是关于面向对象程序设计与Visual C++6.0教程中关于类与对象的详细讲解，涵盖了类的定义、使用、成员（数据和函数）、访问控制、构造函数、析构函数、复制构造函数、类作用域、静态成员、友元以及常对象等多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

青青丘比特

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

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

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

打赏作者

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

抵扣说明：

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

余额充值