2021-03-10-C++学习之8-类和对象-友元、运算符重载

最新推荐文章于 2022-04-12 22:02:48 发布
最新推荐文章于 2022-04-12 22:02:48 发布
阅读量103 收藏
点赞数
分类专栏： 学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42656213/article/details/114606344
版权

一、友元
1. 全局函数做友元

  • 友元的目的是让一个函数或者类 访问另一个类中的私有成员
  • 友元的关键字为 friend
  • 友元的三种实现
    • 全局函数做友元
    • 类做友元
    • 成员函数做友元

代码测试：

#include<iostream>
using namespace std;
#include<string>
//建筑物类
class Building
{
	//goodGay全局函数是Building好朋友，可以访问Building中私有成员
	friend void goodGay(Building* building);
public:
	Building()
	{
		m_BedRoom = "卧室";
		m_SittingRoom = "客厅";
	}
public:
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};

//全局函数
void goodGay(Building *building)
{
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友全局函数 正在访问：" << building->m_BedRoom << endl;

}
void test01()
{
	Building building;
	goodGay(&building);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

输出：

好基友全局函数 正在访问：客厅
好基友全局函数 正在访问：卧室
请按任意键继续. . .

2. 友元类
代码测试：

#include<iostream>
using namespace std;
#include<string>
//建筑物类
class Building;
class GoodGay
{
public:
	GoodGay();
	void visit();//参观函数 访问Building中的属性
	Building* building;
};
//建筑物类
class Building
{
	//GoodGay类是Building好朋友，可以访问Building中私有成员
	friend class GoodGay;
public:
	Building();	
public:
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};
//类外写成员函数
Building::Building() //首先调用构造函数
{
	m_BedRoom = "卧室";
	m_SittingRoom = "客厅";
}
GoodGay::GoodGay() //首先调用构造函数
{
	//创建建筑物对象
	building = new Building;
}
void GoodGay::visit()
{
	cout << "好基友类正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友类正在访问：" << building->m_BedRoom << endl;

}

void test01()
{
	GoodGay gg;
	gg.visit();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

输出：

好基友类正在访问：客厅
好基友类正在访问：卧室
请按任意键继续. . .

3. 成员函数做友元
代码测试：

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

class Building;
class GoodGay
{
public:
	GoodGay();
	void visit();//让visit函数可以访问Building中私有成员
	void visit2();//让visit函数不可以访问Building中私有成员
	Building* building;
};
class Building
{
	//告诉编译器 GoodGay类下的visit成员函数作为本类的好朋友，
	//可以访问私有成员
	friend void GoodGay::visit();
public:
	Building();
	string m_SittingRoom;
private:
	string m_BedRoom;
};

//类外实现成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}
GoodGay::GoodGay()
{
	building = new Building;
}
void GoodGay::visit()
{
	cout << "visit 函数正在访问：" << building->m_SittingRoom << endl;
	cout << "visit 函数正在访问：" << building->m_BedRoom << endl;

}
void  GoodGay::visit2()
{
	cout << "visit2 函数正在访问：" << building->m_SittingRoom << endl;
	//cout << "visit 函数正在访问：" << building->m_BedRoom << endl;

}

void test01()
{
	GoodGay gg;
	gg.visit();
	gg.visit2();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

输出;

visit 函数正在访问：客厅
visit 函数正在访问：卧室
visit2 函数正在访问：客厅
请按任意键继续. . .

二、运算符重载

  • 对已有的运算符重载进行定义，赋予其另一种功能，以适应不同的数据类型。

1. 加号运算符重载
两个自定义的数据类型怎么相加？
例如：

Person p3 = p1.operator(p2);
//简化为
Person p3 = p1 + p2;

代码测试1：

#include<iostream>
using namespace std;
#include<string>
//加号运算符重载
class Person
{
public:
	//1、成员函数重载+号
	/*Person operator+ (Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}*/
	int m_A;
	int m_B;
};
//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//成员函数重载本质调用
	//Person p3 = p1.operator+(p2);
	//全局函数重载本质调用
	Person p3 = operator+(p1, p2);
	//只要写了加号重载，可以直接写，不用写明调用了什么重载方法
	//Person p3 = p1 + p2;
	cout << "p3.m_A = " << p3.m_A << "  p3.m_B = " << p3.m_B << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

输出：

p3.m_A = 20  p3.m_B = 20
请按任意键继续. . .

代码测试2：
运算符重载也可以发生函数重载

#include<iostream>
using namespace std;
#include<string>
//加号运算符重载
class Person
{
public:
	//1、成员函数重载+号
	/*Person operator+ (Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}*/
	int m_A;
	int m_B;
};
//2、全局函数重载+号
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
//函数重载版本
Person operator+(Person& p1, int num)
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//成员函数重载本质调用
	//Person p3 = p1.operator+(p2);
	//全局函数重载本质调用
	//Person p3 = operator+(p1, p2);
	//只要写了加号重载，可以直接写，不用写明调用了什么重载方法
	Person p3 = p1 + p2;
	cout << "p3.m_A = " << p3.m_A <<  endl;
	cout << "p3.m_B = " << p3.m_B << endl;
	//运算符重载，也可以发生函数重载
	Person p4 = p1 + 100;
	cout << "p4.m_A = " << p4.m_A << endl;
	cout << "p4.m_B = " << p4.m_B << endl;

}

int main()
{
	test01();

	system("pause");
	return 0;
}

输出：

p3.m_A = 20
p3.m_B = 20
p4.m_A = 110
p4.m_B = 110
请按任意键继续. . .
  • 总结：
    • 对于内置的数据类型的表达式的运算符是不能改变的
    • 不能滥用运算符重载，加号就实现加法重载，减号就实现减号重载…

2. 左移运算符重载
可以输出自定义数据类型
比如：

Person p;
p.m_A = 10;
p.m_B = 10;
cout<< p << endl;//可以自动输出Person数据类型p的m_A和m_B

代码测试1：

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

//左移运算符重载
class Person
{
public:
	//成员函数实现 左移运算符 p.operator<<(cout)  简化版本 p<<cout
	//通常不会用成员函数实现左移运算符重载，因为无法实现 cout在左侧
	/*void operator<<(cout)
	{

	}*/
	int m_A;
	int m_B;
};
//只能通过全局函数实现左移运算符重载
//本质 operator<<(cout,p)，简化版本为 cout << p
//全局只能有一个cout，所以用&
void operator<< (ostream &cout, Person &p)
{
	cout << "m_A = " << p.m_A << "  m_B = " << p.m_B << endl;
}
void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout << p;
}
int main()
{
	test01();

	system("pause");
	return 0;
}

输出：

m_A = 10  m_B = 10
请按任意键继续. . .

代码测试2：

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

//左移运算符重载
//为了一次输出Person这个对象里面的多个属性
class Person
{
	friend ostream& operator<< (ostream& cout, Person& p);
public :
	Person(int a,int b)
	{
		m_A = a;
		m_B = b;
	}

private:
	//成员函数实现 左移运算符 p.operator<<(cout)  简化版本 p<<cout
	//通常不会用成员函数实现左移运算符重载，因为无法实现 cout在左侧
	/*void operator<<(cout)
	{

	}*/
	int m_A;
	int m_B;
};
//只能通过全局函数实现左移运算符重载
//本质 operator<<(cout,p)，简化版本为 cout << p
//全局只能有一个cout，所以用&
//加上ostream & ，用了链式编程思想
//cout换成out也可以，因为引用的本质是起别名
ostream & operator<< (ostream &cout, Person &p)
{
	cout << "m_A = " << p.m_A << "  m_B = " << p.m_B ;
	return cout;
}
void test01()
{
	Person p(10,10);
	/*p.m_A = 10;
	p.m_B = 10;*/
	//cout << p<< endl;//加上endl后报错，用到链式编程思想
	cout << p << "  hello world" << endl;
}
int main()
{
	test01();

	system("pause");
	return 0;
}

输出：

m_A = 10  m_B = 10  hello world
请按任意键继续. . .

3. 递增运算符重载
通过递增运算符重载，实现自己的整型数据。
代码测试：

#include<iostream>
using namespace std;
#include<string>
//递增运算符重载
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);

public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	//返回一个引用，为了一直对一个数据进行递增
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置递增运算符
	//(int)是一个占位参数，可以用于区分前置递增和后置递增
	//后置递增一定要返回值，而不是返回引用，因为temp是一个局部变量
	MyInteger operator++(int)
	{
		//先记录当时结果
		MyInteger temp = *this;
		//后递增
		m_Num++;
		//最后返回记录的当时的结果
		return temp;
	}

private:
	int m_Num;
};
//重载左移运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;
	return cout;
}
void test01()
{
	MyInteger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}
void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}

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

	system("pause");
	return 0;
}

输出：

2
2
0
1
请按任意键继续. . .

4. 赋值运算符重载
C++编译器至少给一个类添加4个函数

  • 默认构造函数（无参，函数体为空）
  • 默认析构函数（无参，函数体为空）
  • 默认拷贝构造函数，对属性进行值拷贝
  • 赋值运算符 operator= ，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深拷贝问题。
在这里插入图片描述
代码测试：

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

//赋值运算符重载
class Person
{
public:
	Person(int age)
	{
		cout << "构造函数调用" << endl;
		m_Age = new int(age);
	}
	
	//重载 赋值运算符
	Person & operator=(Person &p)
	{
		//编译器提供浅拷贝
		//m_Age = p.m_Age;
		//应该先判断是否有属性在堆区，如果有先是否干净，然会再深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		return *this;
	}
	~Person()
	{
		cout << "析构函数调用" << endl;
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	int* m_Age;
};

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);
	p3 = p2 = p1;
	//p2 = p1;//赋值操作
	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;

}

int main()
{
	test01();
	int a = 10;
	int b = 20;
	int c = 30;
	c = b = a;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	system("pause");
	return 0;
}

输出：

构造函数调用
构造函数调用
构造函数调用
p1的年龄为：18
p2的年龄为：18
p3的年龄为：18
析构函数调用
析构函数调用
析构函数调用
a = 10
b = 10
c = 10
请按任意键继续. . .

5. 关系运算符重载

  • 作用：可以让两个自定义类型对象进行比较
    代码测试：
#include<iostream>
using namespace std;
#include<string>

//关系运算符重载
class Person
{
public:
	Person(string name,int age)
	{
		m_Name = name;
		m_Age = age;
	}
	bool operator==(Person &p)
	{
		if (this->m_Age == p.m_Age && this->m_Name == p.m_Name)
		{
			return true;
		}
		return false;
	}
	bool operator!=(Person& p)
	{
		if (this->m_Age == p.m_Age && this->m_Name == p.m_Name)
		{
			return false;
		}
		return true;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);
	if (p1 == p2)
	{
		cout << "p1 和 p2 相等" << endl;
	}
	else
	{
		cout << "p1 和 p2 不相等" << endl;
	}
	if (p1 != p2)
	{
		cout << "p1 和 p2 不相等" << endl;
	}
	else
	{
		cout << "p1 和 p2 相等" << endl;
	}
}

int main()
{
	test01();
	
	system("pause");
	return 0;
}

输出：

p1 和 p2 相等
p1 和 p2 相等
请按任意键继续. . .

6. 函数调用运算符重载

  • 函数调用运算符()也可以重载
  • 由于重载后使用方式非常像函数的调用，因此称为仿函数
  • 仿函数没有固定写法，非常灵活

代码测试：

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

//函数调用运算符重载
class MyPrint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};
void MyPrint02(string test)
{
	cout << test << endl;
}
void test01()
{
	MyPrint myPrint;
	//传给了void operator()(string test)
	myPrint("hello world");//由于使用起来非常像函数调用，称为仿函数
	MyPrint02("hello world");//函数调用
}
//仿函数没有固定写法，非常灵活
//加法类
class MyAdd
{
public:
	int operator()(int num1,int num2)
	{
		return num1 + num2;
	}
};
void test02()
{
	MyAdd myAdd;
	cout << myAdd(18, 25) << endl;

	//匿名函数对象 MyAdd()(100, 100)
	//MyAdd()是匿名对象
	cout << MyAdd()(100, 100) << endl;
}
int main()
{
	test01();
	test02();
	
	system("pause");
	return 0;
}

输出：

hello world
hello world
43
200
请按任意键继续. . .
努力学习的代码小白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++运算符重载 成员函数与友元函数详解
12-31
代码如下:#include<iostream>using namespace std;class A{ int x,y; public: A(int xx,int yy):x(xx),y(yy){} A(){x=0;y=0;} A operator+(const A&b) //不加const限定，也可以 { return A(x+b.x,y+b.y);...
【P118 36】C++ 类和对象—友元（全局函数、类、成员函数）
程序员，他们想的是什么?他们想的永远都是技术，他们崇尚的也永远都是技术。
04-26 530
友元全局函数做友元 生活中你的家有客厅(Public)，有你的卧室(Private) 客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去 但是呢，你也可以允许你的好闺蜜好基友进去。 在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术 友元的目的就是让—个函数或者类访问另—个类中私有成员 友元的关键字为friend 友元的三种实现 ·全局函数做友元 ·类做友元 ·成员函数做友元 全局函数做友元 ...
C++中的头文件#include<iostream>和标准命名空间 using namespace std
肆拾伍的博客
12-06 8988
#include <iostream> using namespace std 在最开始接触C++的时候，我始终不明白为什么在所有程序开头都要加上这两句，随着后续对类的理解，以及其他语言比如python的学习，慢慢的就能够理解了。 这两行代码旨在简化程序，一般来说编译器都能够识别这两句，否则说明编译器不遵循C++98标准，实际上如果不加这两句代码也是可以的，但是需要对后续的代码进行...
c++ 怎样使用类与对象
就爱摆烂
04-05 1074
类对象作类成员 应用背景：有时候定义类成员时，可能需要某成员为一个类，方便进行使用 在这里我们以person类为例子，它包含两个类对象，姓名与手机,其中手机包括两个属性：品牌和价格。为了体现明确的逻辑包含关系，我们将手机定义为类对象。 #include<iostream> #include<string> using namespace std; //类对象作为类成员 //手机类 class Phone { public: Phone(string pName,int pp)
C++ 成员函数做友元遇到的问题 （错误C2027:使用了未定义类型）
chuomei5332的博客
11-13 4718
涨知识 最近在学习C++ 友元函数（成员函数做友元）这里遇到了一个小问题学习记录下(这个老师讲的超级好，推荐)。 起因 想创建两个类，Building类和GoodGay类，Building类中设置公开访问的SittingRoom和私有的BedRoom，类GoodGay中有两个函数 visit1() 和 visit2(),想把成员函数visit1()，设置为Building类的友元函数来访问私有的BedRoom，但是却出现了问题，最开始的代码如下。 #include<iostream> usin
上机作业 人民币类-运算符重载
12-09
设计人民币类，数据成员包含正负标志位、元、角、分 ，设计构造函数、重载`＋`、`－`、**前置自增**、**后置自增**、**前置自减**、**后置自减**、输出流插入运算符`、输入流提取运算符`>>` . 其中**前置自减**、**...
C++作业实验-运算符重载
06-20
主要是C++中，运算符重载的编写的实验，环境VS2010，内容很基本，与类相关
解析C++中不能重载为友元函数的四个运算符
12-26
现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数，而不可以重载为类的友元函数。不能重载为类的静态成员应该比较容易理解，因为静态成员函数是属于整个类的，不是属于某个对象...
C++运算符重载友元函数实例
08-17
一个实例，实现运算符重载（成员函数和非成员函数两种方式），友元函数的使用，注意事项等，自己学习时编写的，
C++核心入门-04类和对象-（3）C++对象模型、this指针和友元
qq_50615776的博客
07-31 169
C++核心入门-04类和对象-（3）C++对象模型和this指针4.3 C++对象模型和类型指针4.3.1 成员变量和成员函数分开存储4.3.2 this指针概念4.3.3 空指针访问成员函数4.3.4 const修饰成员函数 4.3 C++对象模型和类型指针 4.3.1 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象。 （1）空对象占用内存——占用1个字节空间 例子： #include<iostream> using namespac
c++学习笔记5
qq_41870790的博客
03-01 399
静态成员 在成员变量或成员函数前面加上static关键字，称为静态成员 静态成员分为： 静态成员变量：              所有对象共享一份数据          &nbsp...
ROS机器人入门教程（1）
weixin_42656213的博客
04-05 7150
！仅用作本人学习笔记，方便以后查看！
2021-05-29-PCB学习重点笔记之二，画原理图
weixin_42656213的博客
06-03 6883
一、原理图绘制 1. 走线与画线 区别：绘线和走线 绘线：用于标识，可以修改线的大小颜色等属性，但是不具备电气特性，比如两个电阻用绘线连接在一起，并不代表两个电气的连接，而是为了将不同电路图分成几个区域。也可以在工具栏的 放置 -> 绘图工具 -> 线 中找到该功能。画线的时候按快捷键SHIFT+空格，将走线模式切换为Any Angle 走线：用于电气上的连接。 2. 批量修改 在原理图中 右键->查找相似对象->点击一个元件，然后弹起一个对话框，按照下图选择： 然后应
自学计算机学习路线
weixin_42656213的博客
04-04 2955
参考视频：计算机专业最强指南 第五名 数据库、计算机网络 第四名 计算机网络、数学（离散数学、高数、概率论、线性代数…） 第三名 操作系统（OS，工作种许多性能优化都需要OS知识，熟悉Linux操作系统）、英语 第二名 算法（面试必考内容，必须刷题提高熟练度，无论什么工种，性能提升都依赖算法）、操作系统 第一名 数据结构（设计模式）、算法与数据结构（算法–解决问题的方法和思路） 一个GitHub的学习方法连接：TeachYourselfCS-CN 评论区的说法真得太真实了！ 你把问题简单的归因为
uarm视觉分拣代码解析、openmv颜色识别
weixin_42656213的博客
04-09 1646
以下代码为了做笔记方便，希望有错误的地方大家能给予修改意见，感谢！ 代码均来自https://github.com/uArm-Developer/Vision-Pick-and-Place Arduino参考链接：https://www.arduino.cc/reference/en/ 使用 ArduinoMega 1. Arduino 函数简要介绍 Serial相关函数 Arduino串行端口（也称为UART或USART），ArduinoMega有多个： //指示指定的串行端口是否已就绪。如果指定的
ROS机器人入门教程（2）
weixin_42656213的博客
04-05 1217
13. 参数的使用与编程方法 13.1 命令行实现参数配置 创建功能包： cd ~/catkin_ws/src catkin_create_pkg learning_parameter roscpp rospy std_srvs rosparam使用： ⚫ 列出当前多有参数 $ rosparam list ⚫ 显示某个参数值 $ rosparam get param_key ⚫ 设置某个参数值 $ rosparam set param_key param_value ⚫ 保存...
Java学习7-字符串-静态static-Arrays-Math
weixin_42656213的博客
04-12 1000
1. 字符串 1.1 字符串概述和特点 1.2 字符串的构造方法和直接创建 package Demo09; public class Demo01String { public static void main(String[] args) { // 使用空参构造 String str1 = new String(); System.out.println("第一个字符串：" + str1); // 根据字符数组创建
Java学习5-数组+面向对象+关键字+构造方法
weixin_42656213的博客
03-27 781
1. 数组 1.1 数组概念 1.2 数组的定义格式- 创建动态初、静态数组 package njust.c518.day0318.demo02; /* 两种常见的初始化方式： 1、动态初始化（指定长度）：在创建数组时，直接指定数组当中的数据元素个数 2、静态初始化（指定内容）：在创建数组时，不直接指定数据个数多少，而是直接将具体的数据内容进行指定 动态初始化的格式： 数据类型[] 数组名称 = new 数据类型[数组长度]; * 解析含义： 左侧数据类型：也就是数组当中保存的数据，全都..
友元函数重载--运算符
最新发布
05-10
友元函数重载--运算符的作用是用于对类中的某个数值进行自减操作。例如，如果有一个名为num的成员变量，我们可以通过实现--运算符来使其自减。示例代码如下： ``` class MyClass { private: int num; public: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

努力学习的代码小白

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

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

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

打赏作者

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

抵扣说明：

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

余额充值