继承（C++）

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量300 收藏
点赞数
分类专栏： C++ 文章标签： c++ 继承 组合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kpl_20/article/details/132381811
版权

继承

一、初识继承

概念

继承：保持原有类特性的基础上进行扩展，增加功能，产生新的类。新的类就叫做派生类（子类），原有类就叫做基类（父类）。
继承的作用：继承机制是面向对象程序设计使代码可以复用的最重要的手段，继承是类设计层次的复用，呈现了面向对象程序设计的层次结构。

“登场”

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
		cout << endl;
	}

protected:
	string _name = "张三";
	int _age = 18;
};

//继承后，父类的Person成员（成员函数 + 成员变量）都会成为子类一部分
class Student : public Person
{
protected:
	int _stuId;
};

int main()
{
	Student s;
	s.Print();
	return 0;
}

展现继承
结论：代码体现出Student对Person的继承（复用）

语法格式

定义格式

继承方式

继承方式和访问限定符：
继承方式和访问限定符

九种继承方式组合

C++中的继承方式和访问限定符组合，形成了九种情况的继承结果

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见

eg:实例演示三种继承关系下基类成员的各类型成员访问关系的变化

class Person
{
public:
	void Print()
	{
		cout << "名字：" << _name << endl;
	}
protected:
	string _name = "张三";
private:
	int _age = 18;
};

//class Student : protected Person
//class Student : private Person
class Student : public Person
{
protected:
	int _stuId = 111;
};


int main()
{
	Student s;
	s.Print();
	return 0;
}

关系变化

小结（对九种组合解释）

不需要全部记完，这两种是最常用的记住即可：
常用

  1. 在九种组合表中，基类的私有成员是不可见的。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符， 继承方式)，(public > protected > private)。 Min:两者的较小者。
  2. 基类private成员在派生类中什么方式都不可见。不可见：基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能访问
  3. 基类成员不想在类外直接被访问，但要在派生类中能访问，就要定义为protected。保护成员限定符是因为继承才出现的
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。建议：显示写
  5. 实际运用一般都是public继承，扩展维护性强

二、继承的特性

赋值转换 一一 切片 / 切割

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这个过程叫切片或者切割，不会产生临时变量，发生赋值兼容，就同把派生类中父类那部分切来赋值过去。

原理：（切片 / 切割）
切片/切割

eg：证明：不会产生临时变量

class Person
{
protected:
	string _name;
	string _sex;
	int _age;
};

class Student : public Person
{
public:
	int _No;
};

int main()
{
	int i = 0;
	//double& d = i;   //error
	const double& rd = i;   //int赋值给double类型的值，会产生临时变量，所以要+const

	//派生类对象可以直接赋值给基类对象，不要+const，也就证明，这个过程没有产生临时变量
	Student s;
	Person& p = s;
	return 0;
}

注意：派生类对象赋值给基类的对象（或者基类的指针，或者基类的引用）这个过程称为向上转换。

拓展（不作详细介绍）： 基类的指针和引用可以通过强转赋值给派生类的指针或者引用，但基类的指针是指向派生类对象时才安全。-- 这个过程称为向下转换。注意：基类对象不能赋值给派生类对象。

eg：

class Person
{
//protected:
public:
	string _name = "peter";
	string _sex = "male";
	int _age = 18;
};

class Student : public Person
{
public:
	int _No = 2140104111;
};

int main()
{
	Student s;
	//1.派生类对象可以赋值给父类对象/指针/引用
	Person p = s;
	Person* ptrp = &s;
	ptrp->_age = 21;
	Person& rp = s;
	rp._name = "张三";

	//2.基类对象不能赋值给派生类对象
	//s = p;   //error
	return 0;
}

代码分析：
代码分析

注意：使用保护继承，成员权限会发生变化

Person p = s;  //就会出现错误

这是因为保护继承下，派生类的对象只能被派生类或派生类的子类引用，而不能被基类引用。

原理： 因为非公有派生类（私有或保护派生类）不能实现基类的全部功能，例如在派生类外不能调用基类的公用成员函数访问基类的私有成员。因此，只有公有派生类才是基类真正的子类型，它完整地继承了基类的功能。

作用域 一一 隐藏 / 重定义

  1. 在继承体系中基类和派生类都有独立的作用域
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问（子类成员隐藏父类成员），这叫做隐藏（或者重定义）。 （在子类成员中，可以 基类::基类成员 显示访问。但是指定作用域，如果找不到会直接报错，不会再去访问别的域。eg:派生类成员）
  3. 成员函数隐藏：函数名相同就构成隐藏
  4. 建议：最好不要定义同名成员
    拓展：访问成员遵循就近原则（编译器既定顺序）：局部域-当前类域-父类域-全局域

eg1：成员变量

class Person
{
protected:
	string _name = "张三";
	int _num = 111;
};

class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名：" << _name << endl;

		//指定显示访问
		cout << "Person::_num:" << Person::_num << endl;

		//默认访问子类。子类隐藏了父类
		cout << "_num:" << _num << endl;
	}

protected:
	int _num = 999;
};

int main()
{
	Student s;
	s.Print();
	return 0;
}

//output:
//姓名：张三
//Person::_num:111
//_num : 999

eg2：成员函数

//fun不构成重载，因为不在同一作用域
//fun构成隐藏，成员函数满足函数名相同
class A
{
public:
	void fun()
	{
		cout << "fun()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "fun(int i)->" << i << endl;
	}
};


int main()
{
	B b;
	b.fun(1);
	//b.fun();    //参数不匹配

	//指定访问
	b.A::fun();
	return 0;
}

//output:
//fun()
//fun(int i)->1
//fun()

三、派生类的默认成员函数

派生类的默认成员函数

演示代码：后面会分为四个部分进行拆分讲解

class Person
{
public:
	//如果没有默认构造,必须在派生类的初始化列表显示调用
	//Person(const char* name)
	Person(const char* name = "peter")
		:_name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person& operator=(const Person& p)" << endl;
		if (this != &p)
		{
			_name = p._name;
		}
		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}

protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num)
		:Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator=(const Student& s)
	{
		cout << "Student& operator=(const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
		}
		return *this;
	}

	~Student()
	{
		cout << "~Student()" << endl;
	}

protected:
	int _num;
};


int main()
{
	Student s1("jack", 18);   //构造函数
	Student s2(s1);           //拷贝构造函数
	Student s3("rose", 17);   
	s1 = s3;                  //赋值运算符重载
	return 0;
}

构造和析构调用和执行顺序图：
调用结构

1. 构造函数

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认构造，则必须在派生类构造的初始化列表阶段显式调用
  2. 派生类对象初始化先调用基类构造再调派生类构造

eg1：（有默认构造）

class Person
{
public:
	Person(const char* name = "张三")
		:_name(name)
	{
		cout << "Person()" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num)
		:_stuId(num)
	{
		cout << "Student()" << endl;
	}
protected:
	int _stuId;
};

int main()
{
	Student s("jack", 18);
	return 0;
}

代码F11逐语句执行过程：
代码F11逐语句执行过程

eg2：（没有默认构造）
基类没有默认构造，在派生类必须显示调用，Person先初始化，然后是_stuId。（基类先声明，所以先初始化Person）

//没有默认构造
class Person
{
public:
	Person(const char* name)
		:_name(name)
	{
		cout << "Person()" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num)
		:Person(name)  //在初始化列表调用基类默认构造。如同定义匿名对象
		, _stuId(num)
	{
		cout << "Student()" << endl;
	}
protected:
	int _stuId;
};

int main()
{
	Student s("jack", 18);
	return 0;
}

代码F11逐语句执行过程：代码F11逐语句执行过程

2. 拷贝构造

  1. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化

演示代码的拷贝构造部分：
拷贝构造

3. 赋值运算符重载

  1. 派生类的operator=必须调用基类的operator=完成基类的复制

赋值运算符重载

4. 析构函数

  1. 派生类的析构会在调用完成后自动调用基类的析构函数清理基类成员。原因：为了保证派生类对象，先清理派生类成员再清理基类成员的顺序
  2. 因为后续的一些场景，析构函数要构成重写，重写的条件之一就是函数名相同。所以编译器对析构函数名进行特殊处理，处理成destructor()。所以父类析构函数不+virtual，子类析构函数和父类析构函数构成隐藏关系。

析构函数

四、延伸知识

1. 继承与友元

友元关系不能继承，所以基类的友元不能访问子类私有成员和保护成员

eg:

class Student;  //先声明，因为在Person中引用了Student对象
class Person
{
	friend void Dispaly(const Person& p, const Student& s);
protected:
	string _name = "张三";
};

class Student : public Person
{
protected:
	int _stuId = 0;
};
void Dispaly(const Person& p, const Student& s)
{
	cout << s._name << endl;  //ok
	cout << p._name << endl;  //ok
	cout << s._stuId << endl;  //error   
}

int main()
{
	Dispaly(Person(), Student());
	return 0;
}

注意：如果想要在Display()中调用s._stuId，要在Student类中也加上友元

2. 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员

class Person
{
public:
	Person()
	{
		++_count;
	}
protected:
	string _name;
public:
	static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int stuId;
};
class Graduate : public Student
{
protected:
	string _seminarCourse;
};

int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << "人数：" << Person::_count << endl;
	Graduate::_count = 0;
	cout << "人数：" << Person::_count << endl;
	return 0;
}

//output:
//人数：4
//人数：0

注意：静态成员属于父类和派生类，在派生类不会单独再拷贝一份，继承的是使用权。eg:上面的代码使用的始终都是一个_count

五、单继承和多继承

单继承

单继承：一个子类只有一个直接父类时称这个关系为单继承
单继承

多继承

多继承

菱形继承

菱形继承：多继承的一种特殊情况。
菱形继承
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承由数据冗余（浪费空间）和二义性（不知道访问谁） 问题，在Assistant的对象中Person成员有两份

成员模型
菱形继承代码：

class Person
{
public:
	string _name;
};

class Student : public Person
{
protected:
	int _stuId;
};

class Teacher : public Person
{
protected:
	int _workId;
};

class Assistant : public Student, public Teacher
{
protected:
	string _course;
};

int main()
{
	Assistant a;
	//这样会有二义性问题，无法明确访问的哪一个
	//a._name = "peter";   //error

	//显示指定访问那个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";

	return 0;
}

对于菱形继承解决不了的问题，出现了虚拟继承。

菱形虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余问题。

语法

如上面菱形继承代码的继承关系，在Student和Teacher继承Person时使用虚拟继承。
eg:
虚拟继承

原理

借用简化的菱形继承体系，通过内存窗口观察对象成员的模型

菱形继承

class A
{
public:
	int _a;
};

class B : public A
{
public:
	int _b;
};

class C : public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

菱形继承

菱形虚拟继承

class A
{
public:
	int _a;
};

class B : virtual public A
{
public:
	int _b;
};

class C : virtual public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

菱形虚拟继承

注意： D中为什么B和C部分要找属于自己的A
解释：
在这里插入图片描述
菱形虚拟继承的原理解释：
菱形虚拟继承的原理解释

总结

  1. 虚拟继承的缺陷：虚拟继承会增加程序的复杂性，因为派生类需要特别处理虚基类的初始化和访问。虚拟继承还可能导致一些性能上的损失，因为派生类需要额外的指针来访问虚基类。-- 不建议使用菱形继承
  1. 继承和组合：
    • public继承是一种is-a的关系。eg：植物和花
    • 组合是一种has-a的关系。 eg：轮胎和车

拓展知识：组合

**优先使用对象组合，而不是类继承，**组合耦合度低，代码维护性好

  1. 白盒测试：知道底层
  2. 黑盒测试：不知道底层
  1. 继承，通过生成派生类的复用称为白箱复用(white-box reuse)。白箱（相对可视性而言）：在继承方式中，基类内部细节对子类可见。继承一定程度破坏了基类的封装。耦合度高：基类的改变极大的影响派生类，两者关系紧密
  2. 组合，新的更复杂的功能可以通过组装或组合对象获得。被组合对象具有良好定义的接口。这种复用风格称为黑箱复用(black-box reuse)，**对象内部细节不可见。**组合类之间没有很强的依赖关系，耦合度低

eg:

//继承
//Car和BMW  Car和Benz构成is-a关系
class Car
{
protected:
	string _color = "白色";
	string _num = "陕IT6666";
};

class BMW : public Car
{
public:
	void Drive()
	{
		cout << "好开" << endl;
	}
};

class Benz : public Car
{
public:
	void Drive()
	{
		cout << "好坐" << endl;
	}
};

//组合
//Tire和Car构成has-a关系
class Tire
{
protected:
	string _brand = "Michelin";
	size_t _size = 17;
};

class Car
{
protected:
	string _color = "白色";
	string _num = "陕IT6666";
	Tire _t;
};
kpl_20
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++继承详解
博客记录学习轨迹，方便日后复习
09-03 3376
在现实生活中我们会遇到不同身份的人具有相同属性，比如说在一个学校的管理系统中，我们有教师身份、学生身份等等，他们各自都有如下的属性：我们可以发现，教师和学生除了入职年限和入学年限这一属性不同，其他的姓名、年龄、性别属性是相同的，于是我们可以把不同身份的相同属性提取出来，成为一个公共的属性。在C++中引入了继承的概念，将不同类的相同属性提取出来成为一个独立的公共类，其他类只需要继承这个公共类就可以使用共同的属性。
C++继承介绍
09-05
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual
多继承 C++
生活需要深度
02-06 2805
多继承即一个子类可以有多个父类，它继承了多个父类的特性。 C++ 类可以从多个类继承成员，语法如下： class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,… { <派生类类体> }; 其中，访问修饰符继承方式是public、protected或private其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在让我们一起看看下面的实例： 另外多继承(环状继承),A-&g...
C++ 继承详解
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 6万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
C++ 虚拟继承
TABE_的博客
03-01 4606
这里写目录标题为什么需要虚继承虚拟继承中的内存分布情况sizeof问题 为什么需要虚继承 虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2，而类B1、B2都继 承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。实现的代码如 下： class A class B1:public virtual A; class B2:public virtual A; class D:public B1
c++类继承
dtxew love c++
07-25 3548
继承是一种简化代码的手段之一，使代码可以实现复用。它允许在原来类的功能上进行扩展，衍生出新的功能。也可以把多个类的基本信息提取到某个类，减少代码的冗余。其中被继承的类通常叫做父类或基类，继承下来的类叫做子类或派生类。...
C++中的继承
weixin_57023347的博客
08-27 5678
一.继承的概念及定义 发现问题：当我们编写一个类时，发现这个类与类外一个类的成员变量和成员方法相似，并且具有一定的包含关系时，我们编写的这两个类会有很多相似的地方。 比如： 1.1 继承的概念 继承机制是面向对象程序设计使代码可以复用的重要手段。它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生的类称为派生类。 继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承使类设计层次的复用。 ...
C++保护继承
fanying1115的博客
11-17 1077
保护继承（protected） 继承的访问控制 ①基类的public和protected成员：都以protected身份出现在派生类中； ②基类的private成员：不可直接访问。 访问权限 ①派生类中的成员函数：可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员； ②通过派生类的对象：不能直接访问从基类继承的任何成员。 protected成员的特点...
C++之继承
m0_57234892的博客
04-07 7876
继承的概念及定义 继承的概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 这就比如我们设计一个学生管理系统，学校中有老师，学生，工作人员等，我们要记录他们的信息比如学生有电话，姓名，地址，学号等这些信息。 class Student { str
C++ 多重继承
xiaogangjava的博客
11-29 4372
C++ 编程语言技术知识积累
详解c++ 继承
08-18
主要介绍了c++ 继承的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
c++继承分类
04-28
在Qt中编写的c++继承分类的视频
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 914
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 70
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 263
C语言如何在链表中的指定位置插⼊结点？
PyQt5 中的 List View
xy_optics的博客
05-16 823
有时候，标准模型可能无法满足特定的需求，这时可以自定义数据模型。自定义模型需要继承自 QAbstractItemModel 类，并实现一些关键的方法，如 data()、rowCount()、columnCount() 等，以便 List View 能够正确地显示数据。# 自定义数据模型类return 1# 使用自定义模型。
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 622
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
多重继承和多层继承c++
05-19
C++支持多重继承和多层继承。 多重继承是指一个派生类可以从多个基类中继承特征。例如： ``` class Base1 { public: void foo() { cout ; } }; class Base2 { public: void bar() { cout ; } }; class Derived...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

kpl_20

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

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

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

打赏作者

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

抵扣说明：

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

余额充值