C++面向对象核心-继承

最新推荐文章于 2024-05-13 09:55:25 发布
最新推荐文章于 2024-05-13 09:55:25 发布
阅读量1.8k 收藏 26
点赞数 38
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74937538/article/details/135400974
版权

1、继承

1.1 概念

继承是面向对象的三大特性之一，体现了代码复用的思想。

继承就是在一个已存在的类的基础上建立一个新的类，并拥有其特性。

  • 已存在的类被称为“基类”或者“父类”
  • 新建立的类被称为“派生类”或者“子类”
  • 对象间没有继承关系

#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name = "孙";
public:
    void set_name(string name)
    {
        this->name = name;
    }

    string get_name()
    {
        return name;
    }

    void work()
    {
        cout << "我的工作是厨师，我负责炒菜" << endl;
    }
};

// 派生类
class Son:public Father
{

};

int main()
{
    Son son;
    cout << son.get_name() << endl;
    son.work();

    return 0;
}

派生类差异化

上面的代码，Son类的功能几乎与Father类重叠，在实际的使用过程中，派生类会做出一些与基类的差异化。

  • 修改继承过来的基类内容

属性：1、公有的属性可以直接更改。2、私有的属性，需要使用基类提供的公有函数，进行更改。

成员函数：函数隐藏，通过派生类实现一个同名同参的函数，来隐藏基类的函数。

调用隐藏函数，需要指定作用域

  • 新增派生类的内容

#include <iostream>
#include <array>
#include <vector>
#include <list>
#include <deque>
#include <map> // 头文件
using namespace std;
class Father
{
private:
    string name = "孙";
public:
    void set_name(string name)
    {
        this->name = name;
    }
    string get_name()
    {
        return name;
    }
    void work()
    {
        cout<<"我的工作是厨师，我负责炒菜 "<<endl;
    }
};
//派生类
class Son:public Father
{
 public:
    void init()
    {
        set_name("王");
    }
    //函数隐藏，隐藏父类同名函数
    void work()
    {
        cout<<"我的工作是学生"<<endl;
    }
    void game()
    {
        cout<<"我还玩游戏"<<endl;
    }
};
int main()
{
    Son son;//无参构造函数
    cout << son.get_name()<<endl;//孙
    son.work();//我的工作是学生
    son.game();//我还玩游戏
    son.init();
    cout << son.get_name()<<endl;//王
    son.Father::work();//”我的工作是厨师，我负责炒菜“；调用隐藏函数，需要指定作用域
    return 0;
}

派生类往往是类的具象化，基类则是派生类的抽象。

基类和派生类是相对的，一个类可能又存在基类，又存在派生的情况，取决于那两个类进行比较。

1.2 构造函数

1.2.1 派生类与基类构造函数的关系

构造函数和析构函数不能被继承。

#include <iostream>
using namespace std;
// 基类
class Father
{
private:
    string name;
public:
    // 有参构造函数
    Father(string name):name(name){}

    string get_name()
    {
        return name;
    }
};
// 派生类
class Son:public Father
{
public:
    // 编译器自动添加的构造函数，若没有该构造函数，编译器自动添加
    Son():Father(){}
};
int main()
{
    Son son;//创建对象时发现该类由基类，则找基类构造对象
    cout << son.get_name() << endl;
    return 0;
}

派生类的任意一个构造函数，都必须直接或者间接调用基类的任意构造函数。

1.2.2 解决方案

1.2.2.1 补充基类的无参构造函数

#include <iostream>
using namespace std;
// 基类
class Father
{
private:
    string name;
public:
    Father()
    {
        name  = "王";
    }

    // 有参构造函数
    Father(string name):name(name){}

    string get_name()
    {
        return name;
    }
};
// 派生类
class Son:public Father
{
public:
    // 编译器自动添加的构造函数
    Son():Father(){}
};
int main()
{
    Son son;
    cout << son.get_name() << endl;

    return 0;
}
1.2.2.2 手动在派生类中调用基类构造函数
1.2.2.2.1 透传构造

在派生类的构造函数中，调用基类的构造函数，实际上编译器自动添加派生类的构造函数，调用基类无参构造时，采用的就是这种方式。

#include <iostream>
using namespace std;
// 基类
class Father
{
private:
    string name;
public:
//    Father()
//    {
//        name  = "王";
//    }
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};
// 派生类
class Son:public Father
{
public:
    // 编译器自动添加的构造函数，透传构造
    // Son():Father(){}
    // 手动添加的构造函数，透传构造
    Son():Father("张"){}
    // 手动添加派生类的有参构造函数
    Son(string name):Father(name){}
};
int main()
{
    Son son("王");
    cout << son.get_name() << endl;
    return 0;
}

1.2.2.2.2 委托构造

一个类的构造函数可以调用这个类中的另一个构造函数。要避免循环委托。

委托构造的性能低于透传构造，但是代码的维护性更好。因为通常一个类中构造函数都会委托给能力最强（参数最多）的构造函数。（效率低）代码重构时，只需要更改这个能力最强的构造函数即可。

#include <iostream>
using namespace std;
// 基类
class Father
{
private:
    string name;
public:
//    Father()
//    {
//        name  = "王";
//    }
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};
// 派生类
class Son:public Father
{
public:
    // 编译器自动添加的构造函数，透传构造
    // Son():Father(){}
    // 手动添加的构造函数，透传构造
    Son():Son("张"){}
    // 手动添加派生类的有参构造函数
    Son(string name):Father(name){}
};
int main()
{
    Son son("王");
    cout << son.get_name() << endl;

    return 0;
}



#include <iostream>

using namespace std;

// 基类
class Father
{
private:
    string name;
    int i;
public:

    // 有参构造函数

    Father(string name,int i):name(name),i(i){}
    string get_name()
    {
        return name;
    }

    int get_i()
    {
        return i;
    }


};

// 派生类继承基类  公有继承
class Son:public Father
{
public:
    // 编译器自动添加的构造函数，透传构造
    // Son():Father(){}

    // 手动添加构造函数，委托构造
    Son():Son("张"){}

    Son(string name,int i = 1):Father(name,i){}

};

int main()
{
    Son son("hello",2);
    cout << son.get_name() << endl;
    cout << son.get_i() << endl;

    return 0;
}

1.2.2.2.3 继承构造

只需要加这一句话，编译器就会添加上面两种构造函数（using Father::Father;）

C++11新增的写法，只需要一句话，就可以自动给派生类添加n个（n为基类构造函数的个数）构造函数。并且每个派生类的构造函数与基类的构造函数格式相同，每个 派生类的构造函数都通过透传构造调用对应格式的基类构造函数。

#include <iostream>
using namespace std;
//基类
class Father
{
private:
    string name;
public:
    //委托构造
    Father():Father("王"){}
    //有参函数构造
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};
//派生类
class Son:public Father
{
public:
    //    //编译器自动添加的构造函数,透传构造
    //    //Son():Father(){}
    //    //手动添加的构造函数，透传构造
    //    Son():Father("张"){}
    //    //手动添加派生类的有参构造函数
    //    Son(string name):Father(name){}
    //只需要加这一句话，编译器就会添加上面两种构造函数
    using Father::Father;
};
int main()
{
    Son son;//无参构造函数
    Son son1("张");
    cout << son.get_name()<<endl;
    cout << son1.get_name()<<endl;
    return 0;
}

1.3 对象的创建与销毁流程

在继承中，构造函数与析构函数的调用。

#include <iostream>

using namespace std;

class Value
{
private:
    string str;
public:
    Value(string str):str(str)
    {
        cout << str <<"构造函数" << endl;
    }

    ~Value()
    {
        cout << str << "析构函数" << endl;
    }
};

class Father
{
public:
    static Value s_value;
    Value val = Value("Father 成员变量");
    Father()
    {
        cout << "Father 构造函数被调用了" << endl;
    }
    ~Father()
    {
        cout << "Father 析构函数被调用了" << endl;
    }
};
Value Father::s_value = Value("静态FatherValue创建了");

class Son:public Father
{
public:
    static Value s_value;
    Value val = Value("Son 成员变量");

    Son()
    {
        cout << "Son构造函数被调用了" << endl;
    }
    ~Son()
    {
        cout << "Son析构函数被调用" << endl;
    }

};
Value Son::s_value = Value("静态SonValue被创建了");

int main()
{
    cout << "主程序开始执行" << endl;
    // 局部代码块
    {
        Son s;
        cout << "对象执行中" << endl;
    }
    cout << "主程序结束了" << endl;
    return 0;
}

上面的执行结果中，可以得到下面的规律：

  • 以“对象执行中”为轴，上下对称，先创建静态后创建非静态，先创建基类，后创建派生类，先创建成员变量，后创建对象。先析构成员变量后析构函数，先析构派生类，后析构基类，先析构非静态，后析构静态。
  • 在创建的过程中，同类型的内存区域，基类先开辟。
  • 静态的创建早于非静态
  • 对象的创建，晚于类中成员变量的创建。

1.4 多重继承

1.4.1 概念

C++支持多重继承，即一个派生类可以有多个基类。派生类对于每个基类的关系仍然可以看作是一个单继承。

#include <iostream>
using namespace std;
class Sofa
{
public:
    void sit()
    {
        cout << "沙发可以坐着" << endl;
    }
};
class Bed
{
public:
    void lay()
    {
        cout << "床可以躺着" << endl;
    }
};
class SofaBed:public Sofa,public Bed
{
   public:
};
int main()
{
    SofaBed sb;
    sb.sit();
    sb.lay();
    return 0;
}

1.4.2 可能出现的问题

1.4.2.1 问题1-重名问题

当多个基类具有重名成员时，编译器在调用的过程中会出现二义性。

解决方式：使用基类的类名::方式调用。

#include <iostream>
using namespace std;
class Sofa
{
public:
    void sit()
    {
        cout << "沙发可以坐着" << endl;
    }
    void test()
    {
        cout << "打扫沙发" << endl;
    }
};
class Bed
{
public:
    void lay()
    {
        cout << "床可以躺着" << endl;
    }
    void test()
    {
        cout << "打扫床" << endl;
    }
};
class SofaBed:public Sofa,public Bed
{
   public:
};
int main()
{
    SofaBed sb;
    sb.sit();
    sb.lay();
//    sb.test(); // 错误二义性，两个类中都继承到相同的成员函数名
    sb.Bed::test();//作用域指定
    sb.Sofa::test();
    return 0;
}

1.4.2.2 问题2-菱形继承

当一个派生类有多个基类，且这些基类又有同一个基类，就会出现二义性问题，这种情况也被称为菱形继承（钻石）继承。

1）作用域加类名解决

#include <iostream>

using namespace std;

class Furniture
{
public:
    void func()
    {
        cout << "家具厂里有家具" << endl;
    }

};
class Sofa:public Furniture
{
public:
};

class Bed:public Furniture
{
public:
};

class SofaBed:public Sofa,public Bed
{
   public:
};


int main()
{
    SofaBed sb;
//    sb.func();
//作用域加类名完成
    sb.Sofa::func();
    sb.Bed::func();
    return 0;
}

2）使用虚继承virtual

虚继承解决二义性是通过虚基类指针和虚基类表实现的。在下面代码中Sofa和Bed类会创建一个虚基类指针和虚基类表。所有同类型对象共用一张虚基类表，每个对象内部增加一个隐藏的虚基类指针成员变量，这个虚基类指针指向虚基类表。当Sofa和Bed类作为基类有了派生类SofaBed时，SofaBed对象中也会有隐藏的虚基类指针，但是SofaBed没有自己的虚基类表。在调用Furniture的成员时，SofaBed对象会通过虚基类指针找到对应的虚基类表，通过查表避免二义性。

#include <iostream>

using namespace std;

class Furniture
{
public:
    void func()
    {
        cout << "家具厂里有家具" << endl;
    }

};
// 虚继承
class Sofa:virtual public Furniture
{
public:
};

class Bed:virtual public Furniture
{
public:
};

class SofaBed:public Sofa,public Bed
{
   public:
};


int main()
{
    SofaBed sb;
    sb.func();
    return 0;
}

练习多重继承：

定义学生类，有姓名，学号，性别，年龄等私有成员变量，有构造函数，有打印信息的成员函数。

要求通过构造函数可以给属性赋予初始值。

定义大学生类，继承自学生类，大学生有专业名、成绩的私有成员变量，还有是否获得奖学金的成员函数（成绩为判断依据）。隐藏基类打印信息的成员函数，新的打印信息的成员函数也要能打印姓名、学号、性别、年龄信息。

要求通过构造函数可以给属性赋予初始值。

再定义研究生类，继承自大学生类，有导师姓名和工资的私有成员变量，有打印工资这个成员函数。

要求通过构造函数可以给属性赋予初始值。

#include <iostream>

using namespace std;
class Student
{
private:
    string name;
    int stdnum;
    string sex;
    int age;
public:
    //有参构造
    Student(string name,int stdnum,string sex,int age):name(name),stdnum(stdnum),sex(sex),age(age){}
    void show_student()
    {
        cout<<"姓名："<<name<<endl<<"学号："<<stdnum<<endl<<"性别："<<sex<<endl<<"年龄 "<<age<<endl;
    }
    string get_name()
    {
        return name;
    }
};
class Undergraduate:public Student
{
private:
    string major;
    float grade;
public:
//透传构造
    Undergraduate(string name,int stdnum,string sex,int age,string major,float grade):Student(name,stdnum,sex,age),major(major),grade(grade){}
    //奖学金判断
    void jodge_scholarship()
    {
        if(this->grade>=95)
        {
            cout<<Student::get_name()<<"获得奖学金"<<endl;
        }
        else
        {
            cout<<Student::get_name()<<"未获得奖学金"<<endl;
        }
    }
    //打印大学生信息
    void show_undergraduate()
    {
        Student::show_student();
        cout<<"专业："<<major<<endl<<"成绩："<<grade<<endl;
    }
};
class Graduate:public Undergraduate
{
private:
    string totor;//导师
    int pay;
public:
    //构造
    Graduate(string name,int stdnum,string sex,int age,string major,float grade,string totor,int pay):Undergraduate(name,stdnum,sex,age,major,grade),totor(totor),pay(pay){}
    void get_pay()
    {
        cout<<"薪资待遇："<<pay<<endl;
    }
    void show_graduate()
    {
        cout<<"导师："<<totor<<endl;
        cout<<"薪资："<<pay<<endl;
    }

};

int main()
{
    cout<<"学生类"<<endl;
    Student std1("张三",123,"男",18);
    std1.show_student();
    cout<<"大学生类"<<endl;
    Undergraduate std2("张三",123,"男",18,"嵌入式",99);
    std2.show_undergraduate();
    std2.jodge_scholarship();
    cout<<"研究生类"<<endl;
    Graduate std3("张三",123,"男",18,"嵌入式",99,"沈子",9999);
    std3.show_student();
    std3.show_graduate();
    std3.get_pay();
    return 0;
}

满山的猴子我的腚最红
关注
  • 38
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
面向对象--继承
简之恨寒的博客
08-08 2373
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。...
头歌C++面向对象实训- 类的继承与派生
热门推荐
代码不会敲的博客
05-14 1万+
C++ 面向对象 - 类的继承与派生 一、实训目的 1.了解继承的相关概念 2.掌握保护继承的使用 3.掌握私有继承的使用 4.掌握多继承的使用 二、实训内容 1.公有继承 —— 学生信息类 采用公有继承设计学生信息类。 2.保护继承 —— 学生信息类 3.研究生信息类 采用私有继承完成学生信息类和研究生信息类的设计。 4.狼人类 采用多继承设计一个狼人类 三、实训所实现系统主要功能 1.公有继承 —— 学生信息类 设计 Student 类，并实现 Set 和 PrintSID 函数 2.保护继承 —— 学
【带头学C++】----- 八、C++面向对象编程 ---- 8.1 面向对象编程概述
Phofomy的博客
11-23 1079
面向对象（Object-Oriented）是一种编程范式，它将程序设计中的数据和操作封装成对象。封装、继承和多态。封装（Encapsulation）是指将数据和操作封装在一个对象中，对象对外提供接口来访问和操作数据，同时隐藏具体的实现细节。这样做可以提高代码的可维护性、可重用性和安全性。继承（Inheritance）是指通过定义新的类，这个新的类可以继承已有类的属性和方法。通过继承，新的类可以扩展或修改已有类的功能。继承可以减少代码的冗余，并支持代码的重用。多态（Polymorphism）
C++面向对象 - 继承、派生和多态
念去去
07-26 5459
公有继承 —— 学生信息类 任务描述 本关任务：采用公有继承设计学生信息类。 相关知识 继承 继承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。 C++ 中的继承关系就好比现实生活中的父子关系，继承一笔财产比白手起家要容易得多，原始类称为基类，继承类称为派生类，基类是对派生类的抽象，派生类是对基类的具体化。它们是类似于父亲和儿子的关系，所以也分别叫父类和子类。而子类又可以当成父类，被另外的类继承。 继承方式 不同的继承方式决定了基类成
C++面向对象
qq_57222058的博客
06-07 1358
1.3.1 简述一下什么是面向对象参考回答面向对象是一种编程思想，把一切东西看成是一个个对象，比如人、耳机、鼠标、水杯等，他们各自都有属性，比如：耳机是白色的，鼠标是黑色的，水杯是圆柱形的等等，把这些对象拥有的属性变量和操作这些属性变量的函数打包成一个类来表示面向过程和面向对象的区别面向过程：根据业务逻辑从上到下写代码面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程1.3.2 简述一下面向对象的三大特征参考回答面向对象的三大特征是封装、继承、多态。封装：将数据和
c++面向对象
m0_52559870的博客
08-05 837
class 类名{成员}；示例：//类：一个种类，具有什么属性和行为{//私有属性int age;score = y;}{}void setAge(int x)//给age赋值{age = x;}{}{cout
C++面向对象核心思想引导--建议人人都看
qq_45142474的博客
07-21 653
C++面向对象核心思想引导先告知的秘密面向对象封装public级别private级别protected级别封装总结继承继承的目的：多态多态的价值显示：面向对象整个抽象知识链条总结 先告知的秘密 关于这篇博客，我再三推敲要不要写出来，若写出来吧，感觉尽是废话，因为没有牵扯到C++的任何 知识点，若不写吧，感觉总是欠缺点什么，C++与C的区别在于它面向对象的能力，而面向对象思想 本身又是抽象的，不好概...
面向对象程序（C++）设计基础
铁路十六宿舍的博客
02-12 1617
本文由浅入深的对面向对象语言涉及的概念进行了详解，以C++给读者针对重要的概念举例，帮助读者能够快速实现从过程语言（c）到面向对象语言的编程思路转换。
整合--侯捷--C++面向对象高级编程（一）
amzirl的博客
09-15 1315
侯捷
头歌Educoder实验：C++ 面向对象 - 类的继承与派生
m0_64262556的博客
12-21 6433
在公有继承中，派生类成员可以访问继承的基类的 public 部分与 protected 部分，但是不能访问 private 部分，只有基类成员以及基类的友元可以访问 private 部分。现在已有一个基类 People，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值）。现在已有一个基类 People，它有一个公有成员变量姓名 Name，一个公有成员函数 PrintName（函数的功能是打印出 Name 的值）。
Linux系统设计-听说C与Linux更搭配：C基础 C++面向对象编程 ， linux系统编程以及一些操作系统的相关知识
01-10
它继承了Unix以网络为核心的设计思想，是一个性能稳定的多用户网络操作系统，Linux是许多企业和服务提供商的首选操作系统，用于部署Web服务器、数据库服务器、邮件服务器等。Linux系统具有高效的网络功能和稳定的...
C++程序设计-西工大-1
09-04
其功能强大、面向对象、数据表示丰富、代码运行效率高、可移植性好，适合编写系统软件和各类应用程序。在TIOBE排行榜上，C++语言多年来始终处于前五位。学习程序设计从C++入手，对于培养利用计算机求解现实问题的...
C++商品管理系统.7z
08-12
之前大一的c++的课程设计报告，有源代码和实验报告，实验报告文字说明的...在实现过程中，需利用面向对象程序设计理论的基础知识，充分体现出C++语言关于类、继承和封装等核心概念，每一个类应包含数据成员和成员函数。
C++ 使用matplot++ 处理数据生成svg图表
最新发布
小蝈蝈的博客
05-13 159
python的图表库很丰富，C++依赖于python的 matplotlib的库却有很多功能不足，显得很鸡肋，其他的一些库没有过多的研究，Matplot++编译需要依赖一堆第三方库，可以参考官网，但是github上也提供了编译好的静态库，使用Matplot++同时需要下载安装gnuplot，并将gnuplot的bin加入到环境变量。将include、lib加入到对应的位置，并配置好路径和库连接，这部分不多说了。这里主要说说不依赖于python的纯C++ 的图表库 Matplot++
Linux学习C语言版 LED 灯实验
qq_44219883的博客
05-10 652
大部分情况下都是使用 C 语言去编写的。只是在开始部分用汇编来初始化一下 C 语言环境，比如初始化 DDR、设置堆栈指针 SP 等等，当这些工作都做完以后就可以进入 C 语言环境，也就是运行 C 语言代码，一般都是进入 main 函数。所以我们有两部分文件要做：①、汇编文件汇编文件只是用来完成 C 语言环境搭建。②、C 语言文件C 语言文件就是完成我们的业务层代码的，其实就是我们实际例程要完成的功能。
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 177
UE5 C++ 的FString类型取值问题。
多线程测试+互斥锁（1）【C++】
weixin_45690131的博客
05-10 232
多线程测试
2024OD机试卷-手机App防沉迷系统 (java\python\c++)
WRJ_Jack的博客
05-12 73
智能手机方便了我们生活的同时，也侵占了我们不少的时间。 “手机App防沉迷系统”能够让我们每天合理地规划手机App使用时间，在正确的时间做正确的事。 它的大概原理是这样的： 1. 在一天24小时内，可以注册每个App的允许使用时段 2. 一个时间段只能使用一个App，举例说明：不能同时在9:00-10:00注册App2和App3 3. App有优先级，数值越高，优先级越高。注册使用时段时，如果高优先级的App时间和低优先级的时段有冲突，则系统会自动注销低优先级的时段，如果App的优先级相 同，则后添加的Ap
C++面向对象编程思想
04-13
面向对象编程的核心概念包括封装、继承和多态。 1. 封装：封装是将数据和操作数据的方法封装在一起，形成一个类。类可以看作是一个模板，描述了对象的属性和行为。通过封装，可以隐藏内部实现细节，只暴露必要的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

满山的猴子我的腚最红

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

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

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

打赏作者

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

抵扣说明：

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

余额充值