C++---继承

最新推荐文章于 2024-05-05 00:04:39 发布
最新推荐文章于 2024-05-05 00:04:39 发布
阅读量764 收藏
点赞数 5
分类专栏： C++语法知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MEANSWER/article/details/116174062
版权

继承

1. 继承的概念及定义

1.1 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类（父类）特性的基础上进行扩展，增加功能，这样产生新的类，称派生类（子类）。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。（C++是一个面向对象的语言，其中三大特性为：封装、继承、多态，目前已经学习了前两个，封装的本质为了能够更好的管理，数据和方法都放到类中进行管理，在通过访问限定符进行限制。继承的本质就是想要让代码的复用性更高）

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

class Person{
public: 
	void Print() 
	{ 
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected: 
	string _name = "peter"; // 姓名 
	int _age = 18; // 年龄
}; 
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了Student和Teacher复用了Person的成员。

class Student : public Person
{
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected: 
	int _jobid; // 工号
};
int main()
{ 
	Student s; 
	Teacher t; 
	s.Print(); 
	t.Print();  
	return 0; 
}

在这里插入图片描述

1.2 继承的定义

1.2.1 定义格式

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。
在这里插入图片描述

1.2.2 继承关系和访问限定符

在这里插入图片描述

1.2.3 继承基类成员访问方式的变化

在这里插入图片描述
总结

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
  4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

2. 基类和派生类对象赋值转换

  • 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象
  • 基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。（因为当你指向父类的时候，是有可能发生越界情况的，因为子类中或许有属于自己的一部分成员变量，父类中是没有的。）
    在这里插入图片描述
#include<iostream>
#include<string>
using namespace std;

class Person{
protected: 
	string _name; // 姓名 
	string _sex; // 性别 
	int _age; // 年龄
};
class Student : public Person
{
public : 
	int _No ; // 学号
};
void Test()
{
	Student s;

	// 1.子类对象可以赋值给父类对象/指针/引用 
	Person p = s;
	Person* pp = &s;
	Person& rp = s;

	//2.基类对象不能赋值给派生类对象 
	//s = p;   直接报错

	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针 
	pp = &s;
	Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
	ps1->_No = 10;

	// 这种情况转换时虽然可以，但是会存在越界访问的问题,程序会崩
	pp = &p;
	Student* ps2 = (Student*)pp;
	ps2->_No = 10;
}
int main()
{
	Test();
	return 0;
}

在这里插入图片描述
把最后的指针指向父类，在强制转换为子类的代码屏蔽掉就不会崩了。

3. 继承中的作用域

  1. 在继承体系中基类和派生类都有独立的作用域。
  2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
  3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
  4. 注意在实际中在继承体系里面最好不要定义同名的成员。
// Student的_num和Person的_num构成隐藏（重定义）关系
//可以看出这样代码虽然能跑，但是非常容易混淆
#include<iostream>
#include<string>
using namespace std;

class Person
{
protected: 
	string _name = "小李子"; // 姓名 
	int _num = 111; // 身份证号
}; 
class Student : public Person
{
public: void Print() 
{ 
	cout<<" 姓名:"<<_name<< endl;
	cout<<" 身份证号:"<<Person::_num<< endl; 
	cout<<" 学号:"<<_num<<endl; 
}
protected: 
	int _num = 999; // 学号
}; 
void Test()
{ 
	Student s1; 
	s1.Print();
};
int main()
{
	Test();
	return 0;
}

在这里插入图片描述
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏
一道题来解释：

  • B中的fun和A中的fun不是构成重载，因为不是在同一作用域（不要一看到函数名相同，参数不同就认为是函数重载）
  • B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏
class A
{ 
public: 
	void fun() 
	{ 
		cout << "func()" << endl; 
	} 
}; 
class B : public A
{
public: 
	void fun(int i)
	{ 
		cout << "func(int i)->" << i << endl; 
	}
}; 
void Test()
{ 
	B b; 
	b.fun(10); 
};

在这里插入图片描述

4. 派生类的默认成员函数

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

  1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
  2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
  3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
  4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
  5. 派生类对象初始化先调用基类构造再调派生类构造。（初始化的顺序不是真正定义的顺序，声明才是）
  6. 派生类对象析构清理先调用派生类析构再调基类的析构。（先定义的后析构）

在这里插入图片描述

在这里插入图片描述

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

class Person
{
public: 
	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; //学号
};
void Test ()
{ 
	Student s1 ("jack", 18); 
	cout << endl;

	Student s2 (s1); 
	cout << endl;

	Student s3 ("rose", 17); 
	s1 = s3 ;
	cout << endl;
}

int main()
{
	Test();
	return 0;
}

在这里插入图片描述

5. 继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
在这里插入图片描述

6. 继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。

#include<iostream>
#include<string>
using namespace std;
class Person{
public: Person() 
{ 
	++_count; 
}
protected:
	string _name; // 姓名
public : 
	static int _count; // 统计人的个数。
};
int Person :: _count = 0;
class Student : public Person
{
protected : int _stuNum ; // 学号
};
class Graduate : public Student
{
protected : string _seminarCourse ; // 研究科目
};
void TestPerson()
{
	Student s1 ; 
	Student s2 ; 
	Student s3 ; 
	Graduate s4 ; 
	cout <<" 人数 :"<< Person ::_count << endl; 
	Student ::_count = 0; 
	cout <<" 人数 :"<< Person ::_count << endl;
}

int main()
{
	TestPerson();
	return 0;
}

在这里插入图片描述

7. 复杂的菱形继承及菱形虚拟继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承
在这里插入图片描述
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
在这里插入图片描述
菱形继承：菱形继承是多继承的一种特殊情况。
在这里插入图片描述
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。
在这里插入图片描述

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

class Person{
public: string _name; // 姓名
}; 
class Student : public Person
{
protected : int _num ; //学号
};
class Teacher : public Person
{
protected : int _id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected : string _majorCourse ; // 主修课程
};
void Test ()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	//Assistant a ; 
	//a._name = "peter"; 
	
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决,且是一种指标不治本的手段 
	a.Student::_name = "xxx"; 
	a.Teacher::_name = "yyy";
}

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
在这里插入图片描述

class Person
{
public: string _name; // 姓名
};
class Student : virtual public Person
{
protected : int _num ; //学号
};
class Teacher : virtual public Person
{
protected : int _id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected : string _majorCourse ; // 主修课程
};
void Test ()
{ 
	Assistant a; 
	a._name = "peter";
}

7.1 虚拟继承解决数据冗余和二义性的原理

class A
{ 
public: int _a; 
}; 

// class B : public A
class B : virtual public A
{
public: int _b;
}; 
// class C : public A
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;
}

在不加virtual的情况下，来计算D这个类的大小，可以发现是20个字节（在32位平台上）
在这里插入图片描述

调出内存监视窗口
在这里插入图片描述
加上virtual之后，再来深入的了解一下虚拟继承是如何来解决数据冗余与二义性的问题的。

①加上virtual之后的D类大小是多少呢？答案是24个字节。不是应该消除一个重复的_a吗？变为16个字节吗？
在这里插入图片描述
为什么呢？调出监视窗口。在这里插入图片描述
这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针（原先存放_a位置的指针），指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
在这里插入图片描述
在这里插入图片描述

8. 继承的总结和反思

  1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

  2. 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java。

  3. 继承和组合

  • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
  • 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
  • （is-a关系可以理解为什么是什么的意思。比如：奔驰、宝马是车，has-a可以理解为什么有什么的意思。比如：车有一个轮胎）
  • 优先使用对象组合，而不是类继承 。（因为代码需要保证高内聚，低耦合特性）
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见
    。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高（这样并不好，因为一旦一个地方的代码出现问题，由于两者之间的关系紧密，就有可能导致修改起来过于复杂，考虑的因素也将很多）。
  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
  • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

用代码在解释一个is-a关系和has-a关系

// Car和BMW Car和Benz构成is-a的关系 
class Car
{ 
protected: string _colour = "白色"; // 颜色 
		   string _num = "陕ABIT00"; // 车牌号
};  
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 _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
	Tire _t; // 轮胎
};
没什么..
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
C++ 继承
小喇叭儿滴滴的吹
08-10 788
对于继承，我们先不说概念。下面我还是先用C模拟并借助汇编的方式来理解它，侧重于学习继承的内存模型。 我们先来看代码，设计三个类，People类，Teacher类，Student类 struct Person { int age; //年龄 int sex; //性别 }; struct Teacher { int age; //年龄 int sex; //性...
C++--继承和组合
qq_46659987的博客
04-27 905
继承和组合 public继承是一种 is-a 的关系，组合是一种 has-a 的关系； 一般优先使用对象组合，而不是类继承； 继承允许根据基类的实现来定义派生类的实现，在继承方式中，基类的内部细节对子类可见。继承一定程度上破坏了基类的封装，基类的改变，对派生类有很大的影响，派生类与基类的依赖关系很强，耦合度很高； 对象组合是类继承之外的一种复用选择。对象内部徐杰是不可见的，组合类之间没有很强的依赖关系，耦合度低，代码维护性好。 //继承 is a class Car { protected: str
C++---继承（父类和子类构造和析构顺序）
nihao_2014的博客
08-01 1642
继承方式 1、公共继承（public） 2、保护继承（protected） 3、私有继承（private） 注意：父类中的私有成员子类以任意方式继承都不能访问 例： # include<iostream> using namespace std; //父类 class Base { public: int m_a; protected: int m_b; private: int m_c; }; //以public方式继承的子类 class Base_son :p
C++:继承-继承权限
最新发布
WolvenSec的博客
05-05 849
在C++中，类的权限分为公有、私有和保护三种。这些权限控制了类的成员（数据成员和成员函数）对外部代码的可见性和访问性。在 C++类的继承中，也对应着三种继承权限，分别是公有继承（public inheritance）、保护继承（protected inheritance）和私有继承（private inheritance）。这些权限决定了派生类如何继承基类的成员以及外部访问的方式。
C++-05继承和多态
03-11
C++继承和多态的学习笔记
Dev-c++ 5.9.2
06-22
而C++是C语言的超集，增加了面向对象的特性，如类、继承和多态，更适合开发大型复杂软件。 2. **AStyle**：压缩包中的"AStyle"可能指的是Artistic Style，这是一个源代码格式化、美化和标准化工具。它可以自动格式...
Learn-C++-through-English-and-Chinese完整版资料.ppt
11-17
* 继承 * 类型转换和强转 C++编程实践 C++语言的编程实践包括： * 编写系统、应用程序和库 * 开发游戏 * 开发操作系统 * 开发数据库管理系统 * 开发 web 应用程序等 C++语言是一种功能强大、灵活的编程语言，它...
C++-入门教程-10
03-15
这需要我们在继承的基础上添加或重写方法，展示了C++的继承和多态性。 5. 文件交互（09 职工管理系统-文件交互-写文件.mp4、10 职工管理系统-文件交互-读文件1-文件未创建.mp4）： 在实际应用中，数据的持久化存储...
C++-2320-1-2
02-15
5. **继承与多态**：继承允许一个类（子类）继承另一个类（父类）的属性和行为，实现代码重用。多态是子类能够以不同的方式响应相同的消息，通过虚函数和纯虚函数实现。 6. **模板**：C++的模板提供了一种泛型编程...
数据结构---哈希（Hash）
MEANSWER的博客
06-19 4292
哈希1. 哈希概念2. 哈希函数3. 哈希冲突3.1 闭散列3.1.1 闭散列模拟实现3.2 开散列3.2.1 开散列模拟实现4. 基于开散列实现unordered_set5. 基于开散列实现unordered_map6. 闭散列和开散列对比7. 哈希的应用7.1 位图 对于set和map来说底层所使用的是红黑树，其在搜索上面已经很厉害了，为什么还需要在搞一个unordered_set和unordered_map呢？ #include<iostream> #include<vector&g
C++类与对象再升华
MEANSWER的博客
03-10 1578
C++类与对象升华补充1. 再谈构造函数1.1 初始化列表2. C++11的成员初始化新玩法3. 友元4. static成员5. 内部类6. 再次理解封装 1. 再谈构造函数 1.1 初始化列表 初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。 2. C++11的成员初始化新玩法 3. 友元 4. static成员 5. 内部类 6. 再次理解封装 C++类与对象初识 链接: link. C++类与对象升华 链接: link. ...
C++11---智能指针
MEANSWER的博客
07-31 1508
智能指针1. 为什么引入智能指针？1.1 内存泄漏2.智能指针的使用及原理2.1 RAII2.2 智能指针的原理3. C++98- - -auto_ptr4. unique_ptr5. shared_ptr5.1 循环引用6. weak_ptr 1. 为什么引入智能指针？ void Func() { vector<int*> v; int* p = new int; v.push_back(p); //因为push_back的时候有可能需要申请空间，但是万一申请内存失败了怎么办 v.a
C++的类与对象升华
MEANSWER的博客
02-09 1202
日期类具体化分析C++的类与对象（二）1. 类的6个默认成员函数2. 构造函数2.1 特性3. 析构函数4. 拷贝构造函数5. 赋值操作符重载 链接: link. 1. 类的6个默认成员函数 如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情况下，编译器都会自动生成下面6个默认成员函数，如果写了，那就使用我们所写的。 class Date {}; 2. 构造函数 简单点说：完成初始化的工作。 对于上述代码，如果我没有或者忘记了初始化就直接使用，是会出现大问题
C++---String的模拟实现
MEANSWER的博客
03-29 1062
不是为了去造更好的轮子，只是为了能够更好的理解和使用，所以对于string内部的成员函数的如何实现是非常值得学习的。
C++入门语法知识（一）
MEANSWER的博客
01-31 591
C++入门语法1. C++关键字（C++98）2. 命名空间2.1 命名空间的定义2.2 命名空间的使用3.C++输入&输出4. 缺省参数4.1 缺省参数概念4.2 缺省参数分类5. 函数重载 1. C++关键字（C++98） C++总计63个关键字，C语言32个关键字 ps：下面我们只是看一下C++有多少关键字，不对关键字进行具体的讲解。后面我们学到以后再细讲。 2. 命名空间 在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很
C++11---右值引用和Lambda表达式
MEANSWER的博客
07-22 526
右值引用1. 右值引用2. 为什么要引入右值引用？ 1. 右值引用 C++98中提出了引用的概念，引用即别名，引用变量与其引用实体公共同一块内存空间，而引用的底层是通过指针来实现的，因此使用引用，可以提高程序的可读性。为了提高程序运行效率，C++11中引入了右值引用，右值引用也是别名，但其只能对右值引用。 左值（原来所接触的引用）：可以放到 “=” 左边的值一般就是可修改的值 右值：一般是不可以修改的一些值。比如：常量、临时变量、返回值 #include<iostream> using na
C++---map和set
MEANSWER的博客
05-27 461
map和set1. 关联式容器2. 键值对3. 树形结构的关联式容器3.1 map3.1.1 map的迭代器3.1.2 map的容量与元素访问3.1.3 map中元素的修改3.2 multimap3.3 set3.3.1 set的模板参数列表3.3.2 set的容量3.3.3 set修改操作3.4 multiset 1. 关联式容器 在初阶阶段，我们已经接触过STL中的部分容器，比如：vector、list、deque、forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列
私有继承详解：C++ MFC基础教程
本资源是一份详细的C++-MFC基础教程，针对初学者设计，特别关注私有继承这一核心概念。私有继承在C++中扮演着重要的角色，它允许派生类（私有派生类）完全控制基类（私有基类）的成员访问。在私有继承模式下，基类的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值