1.5 C++学习之常函数（常对象）&运算符重载&继承

于 2019-10-27 23:38:11 发布
阅读量903 收藏 5
点赞数
分类专栏： C++学习笔记 文章标签： 继承 运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwz45698752/article/details/102728352
版权

文章目录

常函数&常对象

  • 成员函数用const修饰，则该函数为常函数
  • 常函数内不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数
class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}

	//this指针的本质是指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	//换句话说，声明为常函数后指针指向的值也不可以修改
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改this指针的指向，因为Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() const {    //常函数
		//mA = 10000;   //不可以修改成员属性
	}

public:
	int m_A;
	mutable int m_B; //可修改，可变的
};


//const修饰对象  常对象
void test01() {
	const Person person; //对象前加const，变为常对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; /是常对象可以修改mutable修饰的成员变量

	//常对象访问成员函数
	person.MyFunc(); //常对象只能调用常函数
	//常对象不可以调用普通成员函数，因为普通成员函数可以修改属性

}

在这里插入图片描述

  • this指针本质是指针常量，即指针的指向不可修改，但是this指针指向的对象的数据是可以修改的
  • 声明为常函数后，this指针指向的值也不可以修改了
  • 通过限制不允许修改this指针指向的值和指针的指向不可修改，达到不能通过this修改成员变量的目的，即常函数的底层原理

友元

  • 友元的目的就是让函数或者类能访问另一个类中私有成员

  • 关键字为 friend

  • 友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元

全局函数做友元

class Building
{
	//告诉编译器 goodGay这个全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building * building);
	//不需要写在public作用域下，如下面的public:

public:

	Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}


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 b;
	goodGay(&b);
}

类做友元

  • 该类的成员函数能访问另一个类的私有属性
class Building; 
//先告诉编译器有Building类，方便goodGay中使用，然后再创建该类
class goodGay
{
public:

	goodGay();
	void visit();

private:
	Building *building;
};


class Building
{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

//成员函数的类外实现，加入作用域
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}

//构造函数的类外实现
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;
}

成员函数做友元


class Building;

class goodGay
{
public:

	goodGay();
	void visit(); //只让visit函数作为Building的好朋友，可以访问Building中私有内容
	void visit2();  //一般的成员函数不可以访问私有内容

private:
	Building *building;
};


class Building
{
	//告诉编译器goodGay类中的visit成员函数是Building好朋友，可以访问私有内容
	friend void goodGay::visit();

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

//类外实现成员函数
Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}

goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visit()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	cout << "好基友正在访问" << building->m_BedRoom << endl;
}

void goodGay::visit2()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	//cout << "好基友正在访问" << building->m_BedRoom << endl;
}

void test01()
{
	goodGay  gg;
	gg.visit();

}

运算符重载

  • 运算符重载：对已有的运算符重新定义，以适应不同的数据类型

加号运算符重载

在这里插入图片描述

  • 作用：实现自定义数据类型相加
  • 成员函数或全局函数两种方式可以来实现运算符重载
  • 运算符重载也可以发生函数重载
  • 理解运算符重载的本质调用方式
class Person {
public:
	Person() {};
	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数方式实现重载
	Person operator+(const Person& p) {
	//const防止修改，引用方式传递
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
		//值方式返回，会调用拷贝构造函数来创建新的对象
	}


public:
	int m_A;
	int m_B;
};

//全局函数方式实现重载
//Person operator+(const Person& p1, const Person& p2) {
//	Person temp(0, 0);  //创建新的对象
//	temp.m_A = p1.m_A + p2.m_A;
//	temp.m_B = p1.m_B + p2.m_B;
//	return temp;
//}

//运算符重载可以发生函数重载 
Person operator+(const Person& p2, int val)  
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	Person p3 = p2 + p1;
	  //相当于 Person p3 =p2.operaor+(p1)，即本质调用方式
	
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;


	Person p4 = p3 + 10; 
	//相当于Person p = operator+(p3,10)
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

1：对于内置数据类型的表达式的的运算符是不可能改变的（1+1一定为2）
2：不要滥用运算符重载（加法就是加法，不是减法）

左移运算符重载

  • 作用：可以输出自定义数据类型
class Person {
	friend ostream& operator<<(ostream& out, Person& p); 
	 //友元方式让全局函数可以访问私有内容

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现不了cout<<p
	//若通过如下函数实现，则重载调用时是p << cout 不是我们想要的效果，具体见图
	//void operator<<(Person& p){
	//}

private:
	int m_A;
	int m_B;
};

//只有全局函数能实现左移重载
//ostream对象只能有一个，即标准输出流对象全局只能有一个，所以要使用引用方式来传递
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;  
	//间接通过cout输出属性内容
	return out;
	//链式编程，所以重载时要返回标准输出流对象
}

void test() {

	Person p1(10, 20);

	cout << p1 << "hello world" << endl;
	 //链式编程，所以重载时要返回标准输出流对象
}

int main() {

	test();
	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述

  • 上图为简化cout <<p
  • 报错是因为返回值的问题，要返回输出流
  • 重载左移运算符配合友元可以实现输出自定义数据类型

递增运算符重载

  • 作用： 通过重载递增运算符，实现自己的整型数据
class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);

public: 
	MyInteger() {
		m_Num = 0;
	}
	
	//前置++，引用方式返回，类比之前链式编程的解释，比如++(++a)
	//因为引用方式能一直对一个数据进行递增操作
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回自身
		return *this;   //要是void，调用cout<<++a时变成cout <<void，不符合operator<<的语法，所以要返回自身（一个对象）
		//this是指向自身的指针，*this即该对象
	}

	//后置++
	MyInteger operator++(int) { 
	//int代表占位参数，用于区分前置和后置递增
		//先返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，实现先返回再++；
		m_Num++;
		return temp;  //若返回引用，则方法执行完成释放temp所占内存空间，导致后续的非法操作（都释放了，还操作，报错）
	}

private:
	int m_Num;
}; 


//重载左移运算符
ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}


//前置++是先++ 再返回
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;
}
  • 前置递增返回引用，后置递增返回值

赋值运算符重载

c++编译器至少给一个类添加4个函数

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝（浅拷贝）
  4. 赋值运算符 operator=, 对属性进行值拷贝（浅拷贝）

  • 如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题，如图

  • 关注如何重载 operator=和何时重载

  • m_Age是地址属性
    在这里插入图片描述

示例：

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}
 
	//重载赋值运算符 
	Person& operator=(Person &p)
	{
	 //应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;  
		//为了a=b=c的连等操作，且为引用方式，保证对同一个数据进行操作
	}


	~Person()
	{
		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; //赋值操作

	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;
}

关系运算符重载

**作用：**重载关系运算符，可以让两个自定义类型对象进行对比操作

示例：

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

	bool operator==(Person & p)
	{
		if (this->m_Name == p.m_Name  && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	bool operator!=(Person & p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	string m_Name;
	int m_Age;
};

void test01()
{
	//int a = 0;
	//int b = 0;

	Person a("孙悟空", 18);
	Person b("孙悟空", 18);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}
}


int main() {

	test01();

	system("pause");

	return 0;
}

函数调用运算符重载

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

示例：



class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}

};


void test01()
{
	//重载的（）操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");  //调用方式类似函数
} 

//-----------
//仿函数很灵活，没有固定写法
//加法类
class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test02()
{
	MyAdd add;
	int ret = add(10, 10);
	cout << "ret = " << ret << endl;

	//匿名函数对象的调用  
	//不想设置对象名，则匿名对象 MyAdd()
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl; 
	 //匿名对象在当前行执行完后，立刻释放
}

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

在这里插入图片描述

继承

继承是面向对象三大特性之一

基本语法

  • 继承的好处：减少重复的代码

class A : public B;

A 类称为子类 或 派生类

B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己的成员。

从基类继承过来的表现其共性，而新增的成员体现了其个性

继承方式

  • 继承的语法：class 子类 : 继承方式 父类

一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承
  • 观察下图子类和父类间权限的变化
    在这里插入图片描述

示例：

class Base1
{
public: 
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//--------------------------------
//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A; //可访问 public权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A; //其他类只能访问到公共权限
}

//--------------------------------
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};


//--------------------------------
class Son2:protected Base2
{
public:
	void func()
	{
		m_A; //可访问 protected权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};

void myClass2()
{
	Son2 s;
	//s.m_A; //不可访问
}

//--------------------------------
//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};


class Son3:private Base3
{
public:
	void func() 
	{
		m_A; //可访问 private权限
		m_B; //可访问 private权限
		//m_C; //不可访问
	}
};

class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};

继承中的对象模型

**问题：**从父类继承过来的成员，哪些属于子类对象中？

示例：

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};

//公共继承
class Son :public Base
{
public:
	int m_D;
};

void test01()
{
  
	cout << "sizeof Son = " << sizeof(Son) << endl;  //16
}

int main() {
	test01();
	system("pause");
	return 0;
}
  • 父类中所有非静态成员属性都会被子类继承下来
  • 父类中私有成员属性是被编译器隐藏了，因此访问不到，但确实被继承下来，如图所示
    在这里插入图片描述
  • 如下呈现了查看类对象内存布局的过程

在这里插入图片描述
打开工具窗口后，定位到当前CPP文件的盘符

然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名

在这里插入图片描述

结论： 父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

继承中构造和析构顺序

  • 子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

示例：

class Base 
{
public:
	Base()
	{
		cout << "Base构造函数!" << endl;
	}
	~Base()
	{
		cout << "Base析构函数!" << endl;
	}
};

class Son : public Base
{
public:
	Son()
	{
		cout << "Son构造函数!" << endl;
	}
	~Son()
	{
		cout << "Son析构函数!" << endl;
	}

};


void test01()
{
	//继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反
	Son s;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base - func()调用" << endl;
	}

	void func(int a)
	{
		cout << "Base - func(int a)调用" << endl;
	}

public:
	int m_A;
};


class Son : public Base {
public:
	Son()
	{
		m_A = 200;
	}

	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
public:
	int m_A;
};

void test01()
{
	Son s;

	cout << "Son下的m_A = " << s.m_A << endl;
	cout << "Base下的m_A = " << s.Base::m_A << endl;

	s.func(); //子类函数
	//s.func(10)会报错
	//因为当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数，子类没有带参函数，而父类又被隐藏
	s.Base::func();   //父类函数
	s.Base::func(10);  //父类函数

}
int main() {

	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

  • 总结：
  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

继承同名静态成员处理方式

  • 问题：继承中同名的静态成员在子类对象上如何进行访问？

  • 静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可

  • 访问父类同名成员 需要加作用域

示例：

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;  //类内声明，类外初始化

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名静态成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "通过类名访问： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	//第一个::表示通过类名方式访问，第二个::表示访问父类作用域下
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func();
	s.Base::func();

    //通过类名访问
	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，若想访问父类中被隐藏的同名成员，需要加作作用域访问
	Son::Base::func(100);
}

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

多继承

  • C++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

  • 多继承可能会引发父类中有同名成员出现，需要加作用域区分

示例：

class Base1 {
public:
	Base1()
	{
		m_A = 100;
	}
public:
	int m_A;
};


class Base2 {
public:
	Base2()
	{
		m_A = 200;  
	}
public:
	int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};


//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;  //1+1+2  = 4   4*4 = 16
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

菱形继承

菱形继承概念：

​ 两个派生类继承同一个基类

​ 又有某个类同时继承者两个派生类

​ 这种继承被称为菱形继承，或者钻石继承

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

在这里插入图片描述

示例：

class Animal
{
public:
	int m_Age;
};

//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 100;
	st.Tuo::m_Age = 200;
   //当菱形继承，两个父类拥有相同数据，需要加以作用域区分
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
	//数据有一份就可以了，菱形继承导致数据有两份，资源浪费
	//若虚继承，则一份数据，此时大家的age都是200
	cout << "st.m_Age = " << st.m_Age << endl;
}


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

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题

在这里插入图片描述

  • 右图为没有虚继承，左图为引入了虚继承，原理如下：

  • vbptr是指向各自类的虚基类表（该表记录偏移量数据）的指针

  • 加上各自偏移量(0+8,4+4)后找到唯一数据（m_Age在8处），保证数据（m_Age）的唯一性

  • 可见虚继承从父类中继承下来的只是指针vbptr，而不是数据

剑雨巍巍
关注
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值