瞅瞅C++中的对象模型（中）

最新推荐文章于 2024-09-21 14:33:15 发布
最新推荐文章于 2024-09-21 14:33:15 发布
阅读量158 收藏
点赞数 1
分类专栏： # 计算-编程语言 文章标签： C++对象模型 继承 多态 虚函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/plm199513100/article/details/111057606
版权
本文深入探讨C++对象模型，特别是虚函数表的工作原理及其在一般继承、多重继承中有无虚函数覆盖情况下的行为表现，揭示多态实现机制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

瞅瞅C++中的对象模型（中）

前言

上一篇讲了C++对象模型中的一部分，这里接着总结。

1.4 一般继承无虚函数覆盖

这里说的情况主要是子类继承了父类的虚函数，但没有改写父类的虚函数。 继承关系图如下：
在这里插入图片描述
实验代码如下：

Base 类和前一个相同。

//Derive类：
class Derive:public Base{
public:

    Derive(int val = 0):d_data(val){
        cout<<"constructor in Derive\n";
    }

     //以下三个是测试的虚函数
    virtual void f1() { cout << "virtual Derive::f1" << endl; }
    virtual void g1() { cout << "virtual Derive::g1" << endl; }
    virtual void h1() { cout << "virtual Derive::h1" << endl; }


    void testInDerive(){
        cout<<"show data member in derive: "<<d_data<<endl;
    }

    int d_data;

};

mian函数：

#include<iostream>
using namespace std;

#define MAXSIZE 100

#include "derive1.h"

typedef void(*Fun)();

int main()
{
    Base b(100),b1(1000);

    Derive d(200);
    cout<<"the size of d(Derive):"<<sizeof(d)<<endl;

    Fun pFun = NULL;

//    cout << "virtual  pointer's  address :" << *(int*)(&d) << endl;
//    cout << "the address of first virtual function is：" << (int*)*(int*)(&d) << endl;


    cout<<"\nvirtual function test.....\n";
    cout<<"\n for b(Base)\n";

//    pFun = (Fun)*((int*)*(int*)(&b));
//    pFun();

    pFun = (Fun)*((int*)*(int*)(&b)+0);  // Base::f()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&b)+1);  // Base::g()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&b)+2);  // Base::h()
    pFun();

    cout<<"\n for d(derive):\n";
//    pFun = (Fun)*((int*)*(int*)(&d));
//    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+0);  // Base::f()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+1); // Base::g()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+2);  // Base::h()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+3);  // Derive::f1()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+4);  // Derive::g1()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+5);  // Derive::h1()
    pFun();

    cout<<"\ndata member test...\n";
    int *pdata = (int*)((int*)(&d)+1);      //虚函数加4个字节即是第一个数据成员的地址
    cout<<"b_data:"<<*pdata<<endl;

    pdata = (int*)((int*)(&d)+2);
    cout<<"d_data"<<*pdata<<endl;

    int c;
    cin>>c;
    return 0;
}

结果如下：
在这里插入图片描述
同样的，这里我想说以下几点：
（1）、对于有虚函数的继承来说，子类会共用父类的vptr槽位，也就是说子类不会再增加一个针对子类的vptr（只针对这种情况，多重继承和虚继承在此不考虑）。子类的虚函数添加在继承父类的虚函数表中。
 
（2）、子类数据成员添加在继承自父类的数据成员之后。

 
基本示意图如下：
在这里插入图片描述

 

1.5 一般继承有虚函数覆盖

前面算是有了一点多态的模子，但是还没有真正实现多态。如果要实现多态，一般来说需要在子类中改写（overwrite）父类的同名函数。 ok，那么如果子类有改写父类的虚函数，其内存模型又是怎么样的呢？

en,稍微修改一下实验代码，使其继承结构如下所示：
在这里插入图片描述
修改Derive类中的函数如下：

class Derive:public Base{
public:

    Derive(int val = 0):d_data(val){
        cout<<"constructor in Derive\n";
    }

     //以下三个是测试的虚函数
    virtual void f1() { cout << "virtual Derive::f1" << endl; }
 
    //重写父类的g函数
    virtual void g() { cout << "virtual Derive::g1" << endl; }	
 	//重写父类的h函数
    virtual void h() { cout << "virtual Derive::h1" << endl; }

    void testInDerive(){
        cout<<"show data member in derive: "<<d_data<<endl;
    }

    int d_data;

};

也要稍微改下main函数：

#include<iostream>
using namespace std;

#define MAXSIZE 100

#include "derive1.h"

typedef void(*Fun)();

int main()
{
    Base b(100),b1(1000);

    Derive d(200);
    cout<<"the size of d(Derive):"<<sizeof(d)<<endl;

    Fun pFun = NULL;

//    cout << "virtual  pointer's  address :" << *(int*)(&d) << endl;
//    cout << "the address of first virtual function is：" << (int*)*(int*)(&d) << endl;


    cout<<"\nvirtual function test.....\n";
    cout<<"\n for b(Base)\n";

//    pFun = (Fun)*((int*)*(int*)(&b));
//    pFun();

    pFun = (Fun)*((int*)*(int*)(&b)+0);  // Base::f()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&b)+1);  // Base::g()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&b)+2);  // Base::h()
    pFun();

    cout<<"\n for d(derive):\n";
//    pFun = (Fun)*((int*)*(int*)(&d));
//    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+0);  // Base::f()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+1); // Derive::g()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+2);  // Derive::h()
    pFun();

    pFun = (Fun)*((int*)*(int*)(&d)+3);  // Derive::f1()
    pFun();

//    pFun = (Fun)*((int*)*(int*)(&d)+4);  // Derive::g1()
//    pFun();
//
//    pFun = (Fun)*((int*)*(int*)(&d)+5);  // Derive::h1()
//    pFun();

    cout<<"\ndata member test...\n";
    int *pdata = (int*)((int*)(&d)+1);      //虚函数加4个字节即是第一个数据成员的地址
    cout<<"b_data:"<<*pdata<<endl;

    pdata = (int*)((int*)(&d)+2);
    cout<<"d_data"<<*pdata<<endl;

    return 0;
}

 
最终的实验结果如下图所示：
在这里插入图片描述
 
这个实验主要就想说一点，即子类的同名函数会在虚函数表中覆盖掉父类的虚函数地址。即像下图这样：
在这里插入图片描述

 
okok,重点来了，这和多态有什么关系？

通过，这种“悄无声息”（其实背后是编译器帮我们实现了替换）的替换，我们就可以用父类的指针或者引用指向整个继承体系中的不同对象，在实际调用的时候，虽然函数名字相同，但是实际调用的函数已经不同了。

如下图所示。
在这里插入图片描述
如果bp指向的真实对象是b,那么bp->g()，调用的就是Base 类的虚函数； 相反，如果bp指向的是d,那么bp->g()，最终调用的就是Derive 里的虚函数g()。 由此达到了同样的代码根据不同的实际对象调用不同的函数，也就是实现了多态（确切的说是多态的一种）。

 
上面将的基本上是C++中的内存模型的重点和难点了。 接下来的部分算是补充，因为说实话，多重继承和虚继承在工程实践中用到的并不是非常多（就我目前了解的来说），从某种程度上来说算是个“鸡肋”， 但是出于完整性考虑，下面也就一并总结了。

 

1.6 多重继承无虚函数覆盖

多重继承是C++支持的特性之一，即一个子类可以有多个父类，可以继承多个父类的数据成员和成员函数（当然，虚函数也可以被继承下来）。为了支持多重继承下的多态，C++中的内存模型设计了子类可以继承父类的多个虚表指针（从某种程度上来说也就相当于继承了父类的多个虚表） 。

下面就来小探究一波。
 
 
设计一个继承类图，如下。
在这里插入图片描述
 
 
参考【2】，设计了实验代码，如下。

Base1类

class Base1 {

public:

    Base1(int val = 10):b1_data(val){ cout<<"constructor in base1\n";}      //构造函数

    //以下三个是测试的虚函数
    virtual void f() { cout << "virtual Base1::f" << endl; }
    virtual void g() { cout << "virtual Base1::g" << endl; }

    virtual void h1() { cout << "virtual Base1::h1" << endl; }

    void show(){cout<<"Base1:: show"<<endl;}     //普通的成员函数
    int b1_data;     //数据成员
};

Base2类

class Base2 {
public:
    Base2(int val = 20):b2_data(val){ cout<<"constructor in base2\n";}      //构造函数

    //以下三个是测试的虚函数
    virtual void f() { cout << "virtual Base2::f" << endl; }
    virtual void g() { cout << "virtual Base2::g" << endl; }

    virtual void h2() { cout << "virtual Base2::h2" << endl; }
    
    void show(){cout<<"Base2:: show"<<endl;}     //普通的成员函数
    int b2_data;     //数据成员

};

Base3类：

class Base3 {
public:
    Base3(int val = 30):b3_data(val){ cout<<"constructor in base3\n";}      //构造函数

    //以下三个是测试的虚函数
    virtual void f() { cout << "virtual Base3::f" << endl; }
    virtual void g() { cout << "virtual Base3::g" << endl; }
    virtual void h3() { cout << "virtual Base3::h3" << endl; }

    void show(){cout<<"Base3:: show"<<endl;}     //普通的成员函数
    int b3_data;     //数据成员
};

Derive类

class Derive:public Base1,public Base2,public Base3{
public:

    Derive(int val = 100):d_data(val){
        cout<<"constructor in derive\n";
    }

//    virtual void f(){cout << "virtual Derive::f" << endl;}      //重写子类的虚函数
//
//    virtual void h1(){cout << "virtual Derive::h1" << endl;}    //重写子类的虚函数

    virtual void i(){cout << "virtual Derive::i" << endl;}      //增添的虚函数
    int d_data;       //数据成员
};

main函数：

typedef void(*Fun)();
int main()
{
    Base1 b(100),b1(1000);

    Derive d(200);
    cout<<"the size of d(Derive):"<<sizeof(d)<<endl;

    int** pVtab = (int**)&d;
    Fun pFun = NULL;

    cout<<"\nvirtual function test.....\n";


    cout << "[0] Base1:: vptr->" << endl;

    pFun = (Fun)pVtab[0][0];
    cout << "     [0] ";
    pFun();

    pFun = (Fun)pVtab[0][1];
    cout << "     [1] ";
    pFun();

     pFun = (Fun)pVtab[0][2];
    cout << "     [2] ";
    pFun();

    pFun = (Fun)pVtab[0][3];
    cout << "     [3] ";
    pFun();

    pFun = (Fun)pVtab[0][4];
    cout << "     [4] ";
    cout<<pFun<<endl;

    cout << "[1] Base1.b1_data = " << (int)pVtab[1] << endl;

    int s = sizeof(Base1)/4;

    cout << "\n[" << s << "] Base2::_vptr->"<<endl;
    pFun = (Fun)pVtab[s][0];
    cout << "     [0] ";
    pFun();

    pFun = (Fun)pVtab[s][1];
    cout << "     [1] ";
    pFun();

    pFun = (Fun)pVtab[s][2];
    cout << "     [2] ";
    pFun();

    pFun = (Fun)pVtab[s][3];
    cout << "     [3] ";
    cout<<pFun<<endl;

    cout << "["<< s+1 <<"] Base2.b2_data = " << (int)pVtab[s+1] << endl;

    s = s + sizeof(Base2)/4;

    cout << "[" << s << "] Base3::_vptr->"<<endl;
    pFun = (Fun)pVtab[s][0];
    cout << "     [0] ";
    pFun();

    pFun = (Fun)pVtab[s][1];
    cout << "     [1] ";
    pFun();

    pFun = (Fun)pVtab[s][2];
    cout << "     [2] ";
    pFun();

    pFun = (Fun)pVtab[s][3];
    cout << "     [3] ";
    cout<<pFun<<endl;

    s++;
    cout << "["<< s <<"] Base3.b3_data = " << (int)pVtab[s] << endl;
    s++;
    cout << "["<< s <<"] Derive.d_data = " << (int)pVtab[s] << endl;

    return 0;
}

实验结果如下图：

在这里插入图片描述
上图说明了以下几点内容：
（1）、红色圈圈表明了，子类会继承父类所有的虚表指针，从某种程度上来说也算是继承了其虚函数表。同时，如果子类有新增的虚函数，则就会添加在第一个继承的虚函数表中。

（2）、蓝色圈圈表明了，就多继承来说，子类会继承父类的虚表指针和其数据成员，并且按照声明的顺序依次排布。

（3）、黄色圈圈表明了，子类继承下来的虚函数表，只有最后一个虚函数表末尾会置空为0.

 
 
有点蒙？ 来，一图胜千言。
在这里插入图片描述

1.7 多重继承有虚函数覆盖

这里的情况就是在上面多重继承的基础上，子类会覆盖父类的虚函数。

根据 参考【2】设计了下面的继承图。
在这里插入图片描述
实验代码只需要稍微修改一下Derive类，使其重写一些父类的一些函数如下：

Derive类

class Derive:public Base1,public Base2,public Base3{
public:

    Derive(int val = 100):d_data(val){
        cout<<"constructor in derive\n";
    }
    virtual void f(){cout << "virtual Derive::f" << endl;}      //重写子类的虚函数
    virtual void h1(){cout << "virtual Derive::h1" << endl;}    //重写子类的虚函数
    virtual void i(){cout << "virtual Derive::i" << endl;}      //增添的虚函数
    int d_data;       //数据成员

};

 
实验结果如下：
在这里插入图片描述
 
 
这里就有一点要说明的，子类中重写父类的函数，对应继承下来的虚函数表都需要进行更改。 示意图如下：
在这里插入图片描述

en… 没想到这第一部分还没写完，看起来有点多，还得放在下一篇博客来总结虚继承的情况了。

参考

【1】、C++ 虚函数表解析
【2】、C++ 对象的内存布局（上）
【3】、C++ 对象的内存布局(下)

Java开发 - 问君能有几多愁，Spring Boot瞅一瞅。
CodingFire的博客
02-10 2万+
对于这个问题，不用多说，先上百度词条：Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。
逻辑回归模型的实现---原理、公式、调用sklearn库实现详解
嗒獭想睡觉
08-29 994
机器学习中有非常多的模型，那么模型的原理是什么？参数怎么使用？模型如何选择？这是困扰我比较久的问题，借最近学习sklearn顺便学一学我最近项目里面需要的模型。 ----------目录-------------- 1. 如何选择合适的模型？ 2. 公式与原理 3. 调用sklearn库实现逻辑回归代码详解 1. 如何选择合适的模型？ 在sklearn官网上有这样一幅图，标明了数...
理解c++对象模型，子类与父类关系
大鹏
04-09 1007
#include using namespace std; class base { public: int bval; base() { bval = 0; } }; class deri:public base { public: int dval; deri(){dval = 1;}; }; void SomeFunc
c++对象模型系列
tanglanting12的专栏
09-15 1379
一、指针与引用 一 概括 指针和引用，在C++的软件开发中非常常见，如果能恰当的使用它们能够极大的提 高整个软件的效率，但是很多的C++学习者对它们的各种使用情况并不是都了解，这就导致了实际的软件开发中经常会内存泄漏，异常抛出，程序崩溃等问题。对 于C和C++的初学者，那更是被它们搞的迷迷糊糊。本篇作为[深入C++]系列的第一节，我们就带领大家把指针和引用这个基本功练好。 二 指针 指
瞅瞅C++中的对象模型（上）
BLSpan的博客
12-12 196
瞅瞅C++中的多态前言一、内存布局问题参考 前言 看了《深度探索C++对象模型》中的Data 语义和Function语义，知识有些杂乱，需要梳理总结一波，所以这里总结总结C++中的多态机制，希望可以便人便己。 以下的总结没有什么特别的章法，主要是按照我的理解分成了以下几个部分： （1）、内存布局问题 （2）、类成员的访问效率问题 （3）、… 一、内存布局问题 参考 ...
瞅瞅C++中的对象模型（下）
BLSpan的博客
12-13 370
瞅瞅C++中的对象模型（下）前言1.9 重复继承1.10 单一虚拟继承1.11 菱形继承二、总结参考 前言 上一篇讲了C++对象模型中的多重继承部分，这一篇该总结总结虚继承的部分了。 1.9 重复继承 1.10 单一虚拟继承 1.11 菱形继承 二、总结 参考 ...
【C++】类和对象1.0
X__cheng的博客
06-04 623
我们看PrintA函数内部需要用到this指针解引用的哦，this指针接收到的值是空指针，而且成员变量_a是存储在this指向的空间里面的（成员变量存储在类实例化对象里面），当然会崩溃了。这两个对象个中成员变量是不同的（需要存储不同的属性，所以说是不同的），但是调用同一份函数（类方法是一样的）。this指针是隐藏起来的，拿上面代码来说：当d1调用Init函数时，传递的实参不仅仅有明面上的2024、6和4，还有该对象的地址，即d1的地址，而且第一个传递d1的地址。这些都是编译器完成的，我们不应该显示写出来。
【C++】速通类和对象，看这一篇就够了
慕雪华年的博客
06-20 1209
本篇博客是学校大一下C++期末考察的要求，包含了C++中类和对象的大部分内容
关于C++
qq_44988404的博客
09-08 421
文章目录一个课程的目录：c++ 线扣扣的书籍群某天语录：其他 C++ 入门教程_C语言中文网 C++ 中STL用法详细总结 c语言网： https://www.dotcpp.com/oj/problemset.html 牛客网： https://www.nowcoder.com/intelligentTest 力扣网： https://leetcode-cn.com/?utm_source=LCUS&utm_medium=banner_redirect&utm_campaign=transf
c语言中什么情况下会出现随机数,C语言中如何产生随机数
weixin_34853336的博客
05-23 1268
今天看到一段小程序 ，里面用到随机数。才发现在C语言中产生随机数不像matlab中那么简单。C中也有rand()函数，但是rand()函数产生的数不是真正意义上的随机数，是一个伪随机数，是根据一个数，我们称它为种子，为基准以某个递推公式推算出来的一系列数。范围在0~RAND_MAX之间。RAND_MAX和rand()一样也定义在stdlib.h中，其值至少为32767。当计算机正常开机后，种子是固...
learn C++ NO.18——多态
sinzz的博客
09-21 742
本篇文章介绍了多态以及相关概念。主要介绍了多态的语法、多态的条件、多态的底层实现以及抽象类等概念。
计算广告小窥[下]要啥自行车！
龙心尘
08-26 6000
一是总结自己已掌握的知识，二是降低同学们的学习成本。本人能力有限，更缺乏实践经验，文章内容多为书籍和论文的读后感，若有不当或者错误之处，还望各位同学指出，我定悉心求教。在此，向编写《计算广告》的刘鹏和王超两位老师致谢，向各位paper作者致谢。
ML学习分享系列3_计算广告小窥[下]要啥自行车！
热门推荐
寒小阳
08-22 2万+
提笔写这篇博客，我的内心是惶恐的。原因很简单，作为一个资历尚浅的研究生，是没有资格对计算广告这样一个伟大的行业、领域和学科来评头论足的。之所以这么做，一是总结自己已掌握的知识，二是降低同学们的学习成本。本人能力有限，更缺乏实践经验，文章内容多为书籍和论文的读后感，若有不当或者错误之处，还望各位同学指出，我定悉心求教。在此，向编写《计算广告》的刘鹏和王超两位老师致谢，向各位paper作者致谢。
三菱PLC FX5U伺服机器人编程：涵盖程序、触摸屏、IO表及电气图设计 · 电气工程 v1.2
最新发布
05-23
内容概要：本文详细介绍了三菱PLC FX5U伺服机器人编程的全过程，涵盖了从硬件编程到触摸屏交互以及电气图设计等多个方面。首先，文章阐述了项目的背景，即开发一个四轴伺服程序以控制机器人的动作。接着，深入探讨了FX5U程序的编写方法，采用结构化编程方式，定义了多个功能模块，如运动控制、IO处理和报警处理等。然后，讲解了威纶通触摸屏程序的设计，为用户提供直观的操作界面。此外，还提到了IO表和材料清单的作用，确保硬件与软件间的无缝对接并列出所需的资源。最后，强调了eplan和PDF电气图在设计电气系统和布线图中的重要性，并讲述了程序调试与优化的具体步骤。 适合人群：对工业自动化控制系统感兴趣的工程师和技术人员，尤其是那些从事PLC编程、机器人控制和HMI设计的专业人士。 使用场景及目标：适用于需要深入了解三菱PLC FX5U伺服机器人编程的技术人员，旨在帮助他们掌握完整的开发流程，提高实际操作能力。 其他说明：文中不仅提供了理论知识，还有具体的代码实例和实践经验分享，有助于读者更好地理解和应用所学内容。
新电大电子商务安全导论考试答案考点版考试必过.doc
05-23
新电大电子商务安全导论考试答案考点版考试必过.doc
C++本科毕业设计-ROS机械臂上位机源码（下载即用）
05-23
C++本科毕业设计-ROS机械臂上位机源码（下载即用），个人经导师指导并认可通过的高分设计项目，评审分98分，项目中的源码都是经过本地编译过可运行的，都经过严格调试，确保可以运行！主要针对计算机相关专业的正在做大作业、毕业设计的学生和需要项目实战练习的学习者，资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的话可以放心下载使用。 C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源码（下载即用）C++本科毕业设计-ROS机械臂上位机源
新版项目管理教材.doc
05-23
新版项目管理教材.doc
新版拍卖行网站建设方案.doc
05-23
新版拍卖行网站建设方案.doc
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值