C++继承浅析

最新推荐文章于 2021-09-22 15:01:49 发布
最新推荐文章于 2021-09-22 15:01:49 发布
阅读量169 收藏
点赞数
分类专栏： 笔记 C++ 文章标签： c++ 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46359697/article/details/109144868
版权
笔记 同时被 2 个专栏收录
31 篇文章 3 订阅
订阅专栏
C++
11 篇文章 0 订阅
订阅专栏

C++继承浅析

前言

由于自己也是刚学了继承，写这篇博文的目的就是巩固一下自己对继承这个概念的理解，可能在以后的学习过程中会再次对继承有更深入的解析。
继承是面向对象三大特性之一
有些类与类之间存在特殊的关系，例如下图中：

在这里插入图片描述

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

这个时候我们就可以考虑利用继承的技术，减少重复代码.

1.继承的用法

1.1单继承

class A : 继承方式 ：B
A 为 子类或派生类
B 为 父类或基类
继承方式：Public Private Protected

1.2多继承

**class A : 继承方式 ：B，继承方式 ：C… **
A 为 子类或派生类
B 为 父类或基类
继承方式：Public Private Protected

2.继承的优点

例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处。

2.1普通实现

//Java页面
class Java 
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "JAVA学科视频" << endl;
	}
};
//Python页面
class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP 
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++页面
	cout << "C++下载视频页面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();

}

int main() {

	test01();

	system("pause");

	return 0;
}

2.2 继承实现

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left()
	{
		cout << "Java,Python,C++...(公共分类列表)" << endl;
	}

};

//Java页面
class Java : public BasePage
{
public:
	void content()
	{
		cout << "JAVA学科视频" << endl;
	}
};
//Python页面
class Python : public BasePage
{
public:
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP : public BasePage
{
public:
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

void test01()
{
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "--------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "--------------------" << endl;

	//C++页面
	cout << "C++下载视频页面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.left();
	cp.content();


}

int main() {

	test01();

	system("pause");

	return 0;
}

对比普通实现和继承实现，我们发现，继承实现节省了很多代码，很多不必要且重复的代码都省去了。因此，这就是继承的一个优点。

3.继承方式

class 子类 : 继承方式 父类
继承方式有三种

  • Public
  • Privated
  • Protected

继承方式的不同，会导致子类从父类继承到的成员属性和函数会不一样。
在这里插入图片描述
在这里插入图片描述

3.1公有继承

继承的方式为公有，那么
父类中为Public作用域下的成员属性子类中也为Public
父类中为Protected作用域下的成员属性子类中也为Protected
父类中为Private作用域下的成员属性子类中也为Private

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; //其他类只能访问到公共权限
}

子类的成员函数可以访问Public和Protected作用域下的成员属性，但是不可以访问Private作用域下的成员属性。
对象可以只能访问到公共作用域下的成员属性。
注意，不可以通过类名对非静态成员函数进行调用。

3.2保护继承

继承的方式为保护，那么
父类中为Public作用域下的成员属性子类中也为Protected
父类中为Protected作用域下的成员属性子类中也为Protected
父类中为Private作用域下的成员属性子类中也为Private

//保护继承
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; //不可访问
}

子类成员函数可以访问Protected作用域下的成员属性，但是不可以访问Private作用域下的成元属性。
对象不可以访问成员属性，因为Protected继承没有Public作用域下的成员属性。

3.3私有继承

继承的方式为私有，那么
父类中为Public作用域下的成员属性子类中也为Private
父类中为Protected作用域下的成员属性子类中也为Private
父类中为Private作用域下的成员属性子类中也为Private

//私有继承
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;
	}
};

子类中的成员函数可以访问原父类中非Private作用域下的成员属性，但还是不可以访问原父类中的Private作用域下的成员属性。
对象不可以访问类中的成员属性。
由于此时子类中的所有成员属性都处于Private作用域下，因此，孙类不可以访问任何子类中成员属性。

总结：无论是何种继承，父类中Private作用域下的成员属性子类都是不可以访问的。

4.继承中的对象模型

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

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

int main() {

	test01();

	system("pause");

	return 0;
}

最后的结果，大家可以运行一下，为16.
这意味着什么：
意味着父类中的任何作用域下的成员属性都被继承给子类了，但是为什么我们不可以访问父类中的私有成员属性呢，因为它被编译器给隐藏后访问不到。

5.继承中构造和析构顺序

子类继承父类，所有成员属性都被子类继承，除析构和构造函数之外，所有的成员函数也被子类继承。
子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题：父类和子类的构造和析构顺序是谁先谁后？

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

为什么，跑一跑不就知道了嘛。

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

6.继承同名成员处理方式

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

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
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.Base::func();
	s.Base::func(10);

}
int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

总结：

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

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

问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域
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);
}
int main() {

	//test01();
	test02();

	system("pause");

	return 0;
}

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

8.多继承语法

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承

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

class Base2 {
public:
	Base2()
	{
		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
	}
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;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

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

9.菱形继承

菱形继承概念：

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

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

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

典型的菱形继承案例：
在这里插入图片描述
菱形继承问题：

  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;
	cout << "st.m_Age = " << st.m_Age << endl;
}


int main() {

	test01();

	system("pause");

	return 0;
}

总结：

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

总结

本篇文章主要是我为了对继承有更牢固的记忆而写的，大概的讲述了继承的用法和需要注意的事项，看完这篇文章后，你应该会有很大的收获，起码你对继承最基本的理解有了。

嵌入式定制设计工坊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++之继承
huheqing的博客
05-19 331
1）为什么要继承 实现代码复用。 在实例化一个派生类对象时，先调用基类构造函数，在调用派生类构造函数； 销毁派生类对象时，析构函数调用顺序正好相反#include<iostream> #include<string> using namespace std;class Person{ public: Person(){ cout << "Person()" << end
非常规的自我实现——听陆向谦讲创业
AlienTech for better life!~
01-08 8053
前天选课的时候，偶然看见一个叫做「创业创新与领导力」的课程，正好在星期六晚上，于是就选了。今天晚上在主楼报告厅上了这个课，感觉远远超出我的预期。在进入课堂签到时，发现有两份不同的签到本，一个是为选课的清华学生，另一个是微博上报名的，看来是开放式的课程。上课前老师还强调了所有人必须使用微博与老师互动，真是令人耳目一新。 这个课的内容是「陆向谦领导力论坛」的一部分，老师叫陆向谦，每个星期请一个业
c++继承浅析
moodytong的专栏
04-10 697
<br />      面向对象语言的三个显著特征就是继承，多态和封装。<br />      在c++里面允许多重继承，本文就不同继承方式进行简单描述，同时简单讲一下继承时候的一些问题，以及多重继承。<br />      派生类的生成过程分为3步走：第一步是吸收基类成员，实际上派生类包含了基类中除构造函数和析构函数之外的所有成员；第二步是改造基类成员，一方面是基类成员的访问控制，另一方面是对基类数据或函数成员的覆盖，所谓覆盖就是在派生类中声明一个和基类数据或函数同名的成员；第三步就是添加新的成员。在基类
浅析C++ 仿函数
08-24
浅析C++ 仿函数 C++ 仿函数是一种特殊的函数对象，具有类似函数的功能，但又是对象。它可以作为函数的参数传递，解决了函数指针参数类型不兼容的问题。 1. 仿函数的必要性 在介绍仿函数之前，需要了解为什么需要...
浅析C++中的虚函数
09-05
如果派生类没有重定义虚函数，那么它将继承基类的虚函数。 **三、动态绑定过程** 虚函数的调用涉及到一个称为虚表（Virtual Table，简称vtbl）的数据结构。每个含有虚函数的类都会有一个虚表，其中存储了类中所有虚...
浅析c与c++中struct的区别
09-05
在C和C++中，`struct`关键字都有用于定义自定义数据类型的用途，但它们在两种语言中的行为和语义...此外，C++中的`struct`可以继承其他`struct`或`class`，并可以作为模板参数，这些都是C语言中struct不具备的功能。
浅析C#与C++相关概念的比较
09-05
- 继承：C#仅支持公有继承，没有C++中的私有继承和保护继承。 - 封装：C#使用sealed关键字封存类，防止继承；C++通过私有构造函数实现类似效果，但也可通过静态函数创建实例。 3. 类型转换： - C#支持用户定义的...
什么是带宽
qq_46359697的博客
09-22 1万+
带宽Preface1.什么是带宽2.深入理解带宽3.带宽与宽带辨析总结 Preface 因为需要使用esp8266作为让STM32与上位机进行通信的桥梁，我就想测试一下esp8266实际的吞吐量，这里面就扯到了带宽的概念。 1.什么是带宽 "带宽"是由英文词汇bandwidth直译过来的。而在不同的领域，对带宽的理解角度也有所不同。 1、电子通信领域：指某个信号具有一定的频带宽度。也就是说，信号的带宽指的是该信号所包含的不同频率成份所占据的频率范围。 注意：频带是相对基带而存在的概念，指的是经过调制后能在信
STM32启动详细流程之__main
qq_46359697的博客
03-26 8899
__main -> main1.前言2.必备知识2.1. 用户程序在FLASH中的组织架构2.2. 用户数据在SRAM中的组织架构2.3. 2.加载地址 链接地址 运行地址 存储地址2.3.4.代码重定向2.3.4.1.位置无关码3.__main函数4._rt_entry函数4.1.procedure4.2.Usage5.自己实现__main函数5.1.消除警告6.自己实现__rt_entry函数7.问题思考7.1.为什么我们可以自己编写__main和__rt_entry7.2.当一个用户程序运行
无法找到函数或变量解决方法
qq_46359697的博客
10-30 7172
无法找到函数或变量解决方法1.前言2.头文件中没有写声明3.没有添加头文件的路径3.1点击魔术棒3.2点击c++/c3.3 添加头文件所在文件夹4.预编译指令重复5.总结 1.前言 最近有人问了我一个函数无法找到的问题，确实，函数无法找到是有很多方面的因素，并且某些方面是真的很坑。你明明已经定义了函数，但在main函数调用它的时候却说找不到。借此，写下一篇文章关于函数或变量无法找到的解决方法，用于示范IDE为keil5。如果你现在正在学32，那么这篇文章对你来说可能是很有帮助了。 2.头文件中没有写声明
stm32f4xx.h文件的详解
qq_46359697的博客
07-09 6975
stm32f4xx.h详解 我的上一篇博客中详细讲解了system_stm32f4xx.c文件，在那个文件中，包含了唯一一个头文件，而这个头文件在开发过程中起到至关重要的作用，如果没有这个文件，就像大厦没有了根基，是肯定会倒的，所以，今天我们来深入了了解一下这么重要的文件它的内容到底是怎样的。 受先我们先来看下这个文件的思维导图，以及该文件的介绍。 这段文字已经大概地介绍了一下这个文件的内容，接下来，我们详细解释。 首先，在这里大家可能有点懵逼，这是个什么东西，这就是混合编程的一种用法，在这里我们并没
STM32之stm32f4xx_conf.h讲解
qq_46359697的博客
07-10 4940
stm32f4xx_conf.h文件的讲解 在我的上一篇博客中又讲解到stm32f4xx.h文件的讲解，在那个头文件中包含了4个头文件。 这四个头文件中第一个是非常难的，如果你32学的不是很扎实的话劝你们最好别去碰，涉及很多汇编和底层知识你只需要知道每次你新建一个项目的时候你把以下四个头文件加到你的项目文件夹下即可。 其他的你也就别管了。 第二个头文件这个在我之前写过的博客中已经提到，并且也很简单，第三个头文件功能就是为关键字创立一个新的名字，还有其他的一些参数，不是很难。我们今天主要讲解一下stm3
gcc详细编译过程
qq_46359697的博客
02-06 4291
GCC详细编译过程
STM32之system_stm32f4xx.c的理解
qq_46359697的博客
07-08 4195
对system_stm32f4xx的理解 上一篇博客解释了stm32的启动文件，在启动文件中，在进入__mainC库函数之前，进入了SystemInit函数，如下图所示。 那，今天我们就来探究一下这个函数的功能是什么，这个函数在这个文件system_stm32f4xx.c中，所以我们今天所要讲解的内容就是system_stm32f4xx.c文件。 首先，我们先来看下这个文件的思维导图。 This file provides two functions and one global variable to
HC-05蓝牙模块的理解
qq_46359697的博客
07-17 4062
HC-05蓝牙模块的理解 最近在玩蓝牙模块，看了看以前玩的时候用的是串口1，想用串口2试试，然而调试了将近一下午都没有调试出来，最后发现竟是一个字母的错误，但在这期间却又学到的新的东西，也有所感悟，故作了这么一篇文章。 先给大家看一看本文的思维导图。 一.代码 1.代码的移植 其实本质都是一样的，就是换一下引脚，配置一些不同的参数而已，可以模仿串口一的程序来写。一个头文件和源文件。 以上就是蓝牙模块的所有代码了， 因为printf函数已经给串口1用了，所以我自己又做了一个蓝牙发送数据的函数，很简
IMX6ULL之IOMUXC
qq_46359697的博客
11-06 3879
IMX6ULL之IOMUXC前言引脚的命名与功能配置IOMUXC1.Overview2.Block Diagram3.Functional description4.Daisy chain - multi pads driving same module input pin总结 前言 IMX6ULL芯片利用IOMUX机制来解决引脚复用的问题,和之前学到的STM32芯片解决引脚复用的解决方式有很大的不同，主要就是配置一下寄存器： 1.PAD控制寄存器 2.MUX控制寄存器 3.Select Input控制寄存
C++多态
qq_46359697的博客
10-20 2853
C++多态前言动态多态多态的构造多态的使用多态底层剖析解答纯虚数函数和抽象类虚析构和纯虚析构总结 前言 多态是C++面向对象三大特性之一 多态分为两类 静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 动态多态: 派生类和虚函数实现运行时多态 静态多态和动态多态区别： 静态多态的函数地址早绑定 - 编译阶段确定函数地址 动态多态的函数地址晚绑定 - 运行阶段确定函数地址 静态多态比较简单，如果想要对静态多态中的函数重载了解， 可以参考这篇博文： C++函数提高 动态多态 通过一个例子

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值