C++ 继承

最新推荐文章于 2025-05-03 18:38:58 发布
最新推荐文章于 2025-05-03 18:38:58 发布
阅读量853 收藏 16
点赞数 22
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77429475/article/details/147656488
版权

文章目录

引入

在软件开发中，我们常常会遇到多个类拥有相似的成员或功能的情况。比如：

class Cat {
public:
    void eat() { cout << "Cat is eating" << endl; }
    void sleep() { cout << "Cat is sleeping" << endl; }
};

class Dog {
public:
    void eat() { cout << "Dog is eating" << endl; }
    void sleep() { cout << "Dog is sleeping" << endl; }
};

可以看到，Cat 和 Dog 中有大量重复代码。为了避免代码冗余、提升可维护性，我们可以将共同的部分提取出来，放到一个更通用的类中（比如 Animal），然后让 Cat 和 Dog 去继承这个基类。

继承是 C++ 面向对象编程三大特性之一（封装、继承、多态），它的主要作用包括：
代码复用：派生类自动拥有基类的成员函数和成员变量。
建立层次关系：通过 is-a 关系组织类结构。
实现多态基础：继承 + 虚函数 实现运行时多态（如虚函数表机制）。

使用继承，我们可以从通用到具体地构建系统，例如：

class Animal {
public:
    void eat() { cout << "Animal is eating" << endl; }
};

class Cat : public Animal {
public:
    void meow() { cout << "Meow!" << endl; }
};

class Dog : public Animal {
public:
    void bark() { cout << "Bark!" << endl; }
};

现在，Cat 和 Dog 不再重复 eat()，并且还能定义各自特有的行为，结构更清晰、扩展更方便。

一、继承的基本语法：

#include <iostream>
class Base {
public:
    void show() { std::cout << "Base" << std::endl; }
};

class Derived : public Base {
    // 派生类没有定义任何成员，但自动继承了 Base 的成员函数
};

int main() {
    Derived d;
    d.show(); // 调用的是 Base 中的 show()
    return 0;
}

语法结构解释：

class 派生类名 : 继承方式 基类名 {
    // 派生类定义
};

Base 是基类（父类）
Derived 是派生类（子类）
public Base 表示 公有继承，也就是 继承方式是 public

二、继承方式和基类成员

继承的类型:公有继承 public、保护继承 protected、私有继承 private

在这里插入图片描述

解释：protected 是对子类开放的封装，private 是只对当前类开放的封装。

class Base {
public:
    int x = 1;
protected:
    int y = 2;
};

class Derived : protected Base {
public:
    void test1() {
        x = 10; // x 变成 protected，可以访问
        y = 20; // y 本来就是 protected，可以访问
    }
};

class SubDerived : public Derived {
public:
    void test2() {
        x = 30; // x 是 protected，可以访问
        y = 40; // y 是 protected，可以访问
    }
};

上面是 protected 继承，子类 SubDerived 能访问 x 和 y，虽然它们对外部是隐藏的。

class Derived2 : private Base {
public:
    void test1() {
        x = 10; // x 变成 private，Derived2 自己能访问
        y = 20; // OK
    }
};

class SubDerived2 : public Derived2 {
public:
    void test2() {
        // x = 30; //  错误，x 是 private，不可访问
        // y = 40; //  错误
    }
};

在这里插入图片描述

上面是 private 继承，子类 SubDerived2 无法访问 x 和 y，它们被“锁死”在 Derived2 中。

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

2.1 基类对象赋值给派生类对象（不允许）

基类和派生类之间的赋值通常是不允许的，因为派生类包含了基类之外的成员，直接赋值可能会丢失派生类中的信息。

#include<iostream>
using namespace std;

class Base {
public:
    int baseValue;
    Base(int v) : baseValue(v) {}
};

class Derived : public Base {
public:
    int derivedValue;
    Derived(int v1, int v2) : Base(v1), derivedValue(v2) {}
};

int main() {
    Base b(10);
    Derived d1(20, 30);

    // 这行代码会报错
    // d1 = b; // 错误：不能将基类对象赋值给派生类对象

    return 0;
}

在这里插入图片描述

基类 Base 和派生类 Derived 在内存布局上不同。派生类 Derived 除了继承自基类 Base 外，还可能有额外的数据成员。
直接赋值基类对象到派生类对象，会丢失派生类的额外成员，因此编译器不允许这么做。

2.2派生类对象赋值给基类对象（允许，但只拷贝基类部分）

派生类对象赋值给基类对象（允许，但只拷贝基类部分）

#include<iostream>
using namespace std;

class Base {
public:
    int baseValue;
    Base(int v) : baseValue(v) {}
};

class Derived : public Base {
public:
    int derivedValue;
    Derived(int v1, int v2) : Base(v1), derivedValue(v2) {}
};

int main() {
    Derived d(20, 30);  // 派生类对象
    Base b(0);

    b = d;  // 派生类对象赋值给基类对象

    cout << "Base value: " << b.baseValue << endl;
    // 基类部分被赋值了，输出: Base value: 20

    return 0;
}

在这里插入图片描述

在这个例子中，d 是 Derived 类型的对象，它被赋值给 b，即基类类型的对象。
赋值后，b.baseValue 被正确地赋值为 d.baseValue，但是 d.derivedValue 不能拷贝给 b，因为 b 并不包含 derivedValue 成员。

2.3基类指针或引用指向派生类对象（允许）(多态章节讲)

基类的指针或引用可以指向派生类对象，这种赋值称为 多态，在运行时通过虚函数实现动态绑定。这样可以使基类指针或引用操作派生类的对象。

#include<iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base class" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class" << endl;
    }
};

int main() {
    Base* basePtr;
    Derived d;

    // 基类指针指向派生类对象
    basePtr = &d;

    basePtr->show();  // 调用的是 Derived 类中的 show() 方法，输出: Derived class

    return 0;
}

在这里插入图片描述

基类的指针 basePtr 可以指向派生类的对象 d。
通过基类指针调用虚函数 show() 时，实际上调用的是派生类 Derived 中的重写函数，因为虚函数实现了动态绑定。

三、继承中名字隐藏

作用域是独立的:
父类和子类有自己各自的成员变量和函数，即使重名也互不影响，但子类优先访问自己的作用域。
函数名相同就构成隐藏:
子类一旦定义了一个同名函数，哪怕参数不同，也会屏蔽所有父类同名函数,想要使用需要指定类域。

#include<iostream>
using namespace std;

class Base {
public:
    int x = 1;

    void func() {
        cout << "Base::func()" << endl;
    }

    void func(int n) {
        cout << "Base::func(int): " << n << endl;
    }
};

class Derived : public Base {
public:
    int x = 2;  // 与 Base::x 同名，隐藏

    void func() {  // 同名函数，隐藏了 Base::func 和 Base::func(int)
        cout << "Derived::func()" << endl;
    }

    void test() {
        cout << "x = " << x << endl;            // 访问的是 Derived::x
        cout << "Base::x = " << Base::x << endl; // 显示访问基类成员

        func();             // 调用 Derived::func()
        Base::func();       // 显示调用 Base::func()
        Base::func(100);    // 调用重载版本 Base::func(int)
    }
};

int main() {
    Derived d;
    d.test();

    return 0;
}

在这里插入图片描述

四、派生类的六个默认成员函数

（4.1）派生类的构造函数必须调用基类构造函数

默认情况下，派生类的构造函数会自动调用基类的默认构造函数。
如果基类没有默认构造函数，必须显式调用某个构造函数。

#include<iostream>
using namespace std;

class Base {
public:
    Base(int x) {
        cout << "Base构造函数: " << x << endl;
    }
};

class Derived : public Base {
public:
    // Derived 默认构造函数，必须显式初始化 Base
    Derived() : Base(100) {
        cout << "Derived构造函数" << endl;
    }
};

int main() {
    Derived d;
}

在这里插入图片描述

（4.2）拷贝构造函数自动调用基类的拷贝构造函数

基类如果有显示的拷贝构造：
编译器不会自动调用基类的拷贝构造函数；
你必须显式地在初始化列表中调用；
否则只会默认使用基类的默认构造函数，或者报错（如果没有默认构造函数）。

#include <iostream>
using namespace std;

class Base {
public:
    Base() {}
    Base(const Base&) {
        cout << "Base 拷贝构造函数" << endl;
    }
};

class Derived : public Base {
public:
    Derived() {}
    
    // 显式调用 Base 的拷贝构造
    Derived(const Derived& d) : Base(d) {
        cout << "Derived 拷贝构造函数" << endl;
    }
};

int main() {
    Derived d1;
    Derived d2 = d1;  // 输出两个拷贝构造函数
}

在这里插入图片描述

没有手动调用 Base 的拷贝构造

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "默认构造" << endl;
    }
    Base(const Base&) {
        cout << "Base 拷贝构造函数" << endl;
    }
};

class Derived : public Base {
public:
    Derived() {}
    Derived(const Derived& d) {
        cout << "Derived 拷贝构造函数" << endl;
    }
};


int main() {
    Derived d1;
    Derived d2 = d1;  
}

在这里插入图片描述

（4.3）为什么派生类重载了 operator= 后，需要手动调用基类的 operator=

在 C++ 中，如果我们在派生类中重载了 operator=，很多人以为编译器会自动帮我们调用基类的赋值运算符，其实并不会。

#include <iostream>
using namespace std;

class Base {
public:
    int a = 10;  // 有数据成员
};

class Derived : public Base {
public:
    int b = 20;

    Derived& operator=(const Derived& d) {
        b = d.b;
        cout << "Derived::operator= 被调用" << endl;
        return *this;
    }

    void show() {
        cout << "Base::a = " << a << ", Derived::b = " << b << endl;
    }
};

int main() {
    Derived d1;
    d1.a = 111;
    d1.b = 222;

    Derived d2;
    d2 = d1;

    d2.show();  // Base::a 没有被赋值
}

在这里插入图片描述

此时的基类到底有没有编译器生成的operator=? 有，调试的时候虽然是没有直接进入这个基类，因为你在 Derived 中手动写了 operator=，编译器不会自动帮你调用 Base::operator=，这是你自己的职责。所以你必须手动调用。

看下一个测试用例：我们手动调用基类的operator =

Derived& operator=(const Derived& d) {
    Base::operator=(d);  // 手动调用
    b = d.b;
    return *this;
}

在这里插入图片描述

此时就是明显的观察到调用了基类的operator= ，并且编译器是生成了operator= 这个功能。

（4.4）析构函数：先析构派生类，再析构基类

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base 构造" << endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        cout << "Derived 构造" << endl;
    }
};

int main() {
    Derived d;
}

在这里插入图片描述

（4.5）构造顺序：先构造基类，再构造派生类

class Base {
public:
    ~Base() {
        cout << "Base 析构" << endl;
    }
};

class Derived : public Base {
public:
    ~Derived() {
        cout << "Derived 析构" << endl;
    }
};

int main() {
    Derived d;
}

在这里插入图片描述

五、友元与继承

子类不能访问父类私有成员，除非父类主动“邀请”子类成为友元；同时，友元关系是不传递、不继承的。

(5.1)子类不是父类的友元

class Base {
private:
    int a = 1;
};

class Derived : public Base {
public:
    void func() {
        // a = 10; //  编译错误，子类不能访问 Base 的私有成员
    }
};

(5.2)友元关系不能继承

如果 A 是 B 的友元，那么 A 的子类或 B 的子类都不会自动拥有这个友元关系。

class A {
    friend class B;
private:
    int x = 10;
};

class B {
public:
    void f(A& a) {
        a.x = 20;  //B 是 A 的友元
    }
};

class B_Derived : public B {
public:
    void f2(A& a) {
        // a.x = 30; //错误，友元关系不会继承
    }
};

(5.3)友元类可以是派生类，也可以是基类

class Derived;

class Base {
    friend class Derived; //Derived 可访问 Base 的私有成员
private:
    int x = 1;
};

class Derived : public Base {
public:
    void f() {
        x = 100;  //友元访问私有成员
    }
};

(5.4)解决办法：声明

#include <iostream>
using namespace std;

class Derived; // 提前声明

class Base {
    friend void friendFunc(Base& b); // friendFunc 是 Base 的友元
protected:
    int base_protected = 1;
private:
    int base_private = 2;
};

class Derived : public Base {
protected:
    int derived_protected = 3;
private:
    int derived_private = 4;
};

// 定义友元函数
void friendFunc(Base& b) {
    cout << b.base_protected << endl;  // Base 的保护成员
    cout << b.base_private << endl;    // Base 的私有成员
    // cout << b.derived_protected << endl; // 错误：friendFunc 不是 Derived 的友元
}

Derived 类也加上 friend class FriendClass;，FriendClass 能访问 Derived 的私有和受保护成员

在这里插入图片描述

六、静态变量与继承

(6.1)子类会继承静态变量（但不是拷贝）

静态变量只有一份存储空间，在继承中不会为每个子类再创建新的副本。
子类可以访问父类的静态变量（只要权限允许：public 或 protected）。

#include<iostream>

using namespace std;


class Base {
public:
    static int count;
};

int Base::count = 0;

class Derived : public Base {};

int main() {
    Base::count = 1;
    Derived::count = 2;

    cout << Base::count << endl;    // 输出 2
    cout << Derived::count << endl; // 输出 2
}

在这里插入图片描述

(6.2)如果子类定义了同名静态变量

#include<iostream>

using namespace std;

class Base {
public:
    static int count;
};
int Base::count = 0;

class Derived : public Base {
public:
    static int count; // 隐藏了 Base::count
};
int Derived::count = 100;

int main() {
    cout << Base::count << endl;    // 输出 0
    cout << Derived::count << endl; // 输出 100
}

那么这个时候，子类会隐藏基类的静态变量。

在这里插入图片描述

七、菱形继承及菱形虚拟继承

(7.1)什么是菱形继承

      A
     / \
    B   C
     \ /
      D

类 B 和 C 都从 A 派生；

类 D 同时继承自 B 和 C；

这就导致：D 继承了两份 A 的成员。

(7.2)引发二义性

#include<iostream>

using namespace std;
class A {
public:
    int x;
};

class B : public A {};
class C : public A {};
class D : public B, public C {};

int main() {
    D d;
    d.x = 10;// 不明确是 B::A::x 还是 C::A::x
    d.B::x = 10; //  可以用作用域限定符解决，但不优雅
}

在这里插入图片描述

(7.3)虚拟继承（Virtual Inheritance）解决重复继承问题

通过在继承时加上 virtual 关键字，告诉编译器：这个基类只保留一份副本。

#include<iostream>

using namespace std;


class A {
public:
	int x;
};

class B : virtual public A {};  // 注意 virtual
class C : virtual public A {};
class D : public B, public C {}; 

int main() {
    D d;
    d.x = 10;
}

B 和 C 虚继承了 A；
D 只包含一份 A 的子对象；
这个机制通过 虚基表指针（vptr） 保证只构造一份基类子对象。

(7.4)虚拟继承的底层原理

上段代码，B类里面有基类A吗？
类 B 虽然写了 : virtual public A，但它：
不包含 A 的独立子对象（子对象指内存中独立的一份 A）；
它只是声明了“我依赖一个虚基类 A”，这意味着它知道将来某个派生类会真正提供这份 A 的实体。
所以：B 有继承关系上的 A，但没有真正的 A 成员对象。

#include <iostream>
using namespace std;

class A {
public:
    int x;
};

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.x = 1;
    d.b = 2;
    d.c = 3;
    d.d = 4;

    cout << "x = " << d.x << endl;
    cout << "b = " << d.b << endl;
    cout << "c = " << d.c << endl;
    cout << "d = " << d.d << endl;

    return 0;
}

在这里插入图片描述

地址        值
0x008FF754  48 9b 4b 00    ; 偏移0：B的vbptr（虚基表指针）或其它继承指针
0x008FF758  02 00 00 00    ; 偏移4：B::b = 2
0x008FF75C  54 9b 4b 00    ; 偏移8：C的vbptr（虚基表指针）
0x008FF760  03 00 00 00    ; 偏移12：C::c = 3
0x008FF764  04 00 00 00    ; 偏移16：D::d = 4
0x008FF768  01 00 00 00    ; 偏移20：A::x = 1（虚基类成员）

把 48 9b 4b 00 转成地址 0x004B9B48

0x004B9B48  00 00 00 00  
0x004B9B4C  14 00 00 00   存储的B的偏移量

14 00 00 00转换为十进制就是20

在这里插入图片描述

D 对象内存布局：
+---------------------+
| B::vbptr ---------->|
| B::b                |
+---------------------+
| C::vbptr ---------->|
| C::c                |
+---------------------+
| D::d                |
+---------------------+
| 共享的 A::x         |  <-- 只存在一份！由 D 初始化
+---------------------+
C++继承
Wzs040810的博客
02-03 1660
C++继承
C++继承详解
lim6ere的博客
03-29 1286
在本篇文章中我们将会学到有关继承方面的知识，其中C++中三大特性分别为：封装，继承多态。由此可见继承在学习中的重要性，接下来我们来一起看一下有关继承方面的知识吧！！！！😘 😚😘 😚😘 😚以上就是今天要讲的内容，本文仅仅详细介绍了C++继承的相关知识。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承的使用
JayceSun的博客
04-17 2021
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++继承（带你一篇文章搞定C++的继承）
2301_80344616的博客
10-23 4563
我们前面讲了模板进阶的全部内容，今天我们要进入C++里面更深层的内容了，今天我们来讲解C++的继承继承的概念继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，以前我们接触的函数层次的复用，继承是类设计层次的复用。什么是复用呢？
C++继承之private继承
flysnow010的博客
04-10 1597
通过继承机制，可以利用已有的对象类型来定义新对象类型。所定义的新对象类型不仅仅拥有新定义的成员，而且还同时拥有旧的成员。我们称已存在的用来派生新类的类为基类，又称为父类。由已存在的类派生出的新类称为派生类，又称为子类。 private继承 派生类中父类public成员变成private成员。
C++继承[万字详解]
weixin_47257473的博客
03-16 4255
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
std::print 和 std::println
janeqi1987的专栏
04-28 1019
std::print和是 C++23 新增的格式化输出函数，旨在替代传统的std::cout链式调用。它们基于实现，支持类型安全的格式化字符串，语法更简洁，性能更优15。直接输出到stdout（默认）或指定的流。自动在输出末尾添加换行符。支持与相同的格式化语法（如{}占位符）。
深入理解C语言中的整形提升与算术转换
qinyuz的博客
05-01 591
在C语言中，整形提升（Integer Promotion）是一个重要但容易被忽视的概念。它指的是在表达式中，任何小于。是无符号char，赋值-1会转换为255（0xFF）长度为标准操作数长度，使用标准长度可以提高运算效率。都是有符号char，值为-1（内存表示：0xFF）：符号扩展为0xFFFFFFFF（即-1）：零扩展为0x000000FF（即255））操作数在使用前都会被自动转换为普通整型。：确保不同大小的整型在运算时有一致的表现。有符号类型：高位补符号位。无符号类型：高位补0。是2字节，所以前两个。
STL之list容器
Laydya的博客
05-03 755
1.list的底层是双向链表结构，双向链表中的每个元素在互不相关的独立结点中，在结点中通过指针指向前一个元素和后一个元素2.list是可以在常数范围内在任意位置的插入和删除的序列式容器，并且该容器可以前后双向迭代3.vector的优点：支持随机访问，间接的就支持了排序/二分查找/堆排序等缺点：1.头部和中部的插入效率低，需要挪动数据2.插入数据空间不够需要增容，增容需要开新空间，拷贝数据，释放旧空间list的优点：没有增容代价，且任意位置插入都是0（1）；
STL之vector容器
Laydya的博客
05-02 1078
1.vector是可变大小数组的容器2.像数组一样，采用连续的空间存储，也就意味着可以通过下标去访问，但它的大小可以动态改变3.每次的插入都要开空间吗？开空间就要意味着先开临时空间，然后在拷贝旧的到新的上面，在释放原来的，就时间而言，这是一个相对代价很高的任务；显然这是不行的，vector的分配策略：会分配一些而外的空间以适应可能的增长，例如我们平时说的以1.5或者2倍的方式增容，不同的库选择不同的策略权衡空间的使用和重新分配，以至于在插入一个元素时能在常数时间内插入；
游戏代码C
最新发布
2301_81771576的博客
05-03 292
以下将结合不同编程语言的特点及游戏开发中的实际应用，展示多种语言的游戏代码示例（以简单游戏为例，展示代码结构和逻辑差异）。3. Python/JavaScript/Lua：语法简洁，适合快速开发，代码量最少。Unity引擎集成度高，C#代码简洁但功能强大，适合快速开发跨平台游戏。1. C++：需手动管理资源（如字体加载），代码行数最多但性能最优。Lua语法极简，常用于游戏逻辑脚本（如《魔兽世界》插件）。1. C# + Unity（面向对象，适合跨平台开发）Python语法简洁，适合快速验证游戏逻辑。
第十一届蓝桥杯 2020 C/C++组 门牌制作
2301_80558092的博客
05-01 482
简单的数位切分问题，循环让i从1遍历到2020，每次定义临时变量temp存储i的值，每次通过temp%10取当前temp的最后一位，再通过temp/=10去掉当前temp的最后一位。把每次取的数位判断是否为2，把temp切到0就代表全部数位都切分出来了
【uom】 0 配置文件（Cargo.toml）
weixin_43219667的博客
04-29 457
这个配置文件表明 uom 是一个功能完善的单位计量库，支持多种数值类型和单位系统，可以在无标准库环境下使用，并提供了丰富的测试和示例。配置文档生成时启用的特性，包括各种数值类型支持（如 usize, u32, 大整数，有理数等）和 serde 支持。可选的 num-rational/num-bigint/num-complex: 分别支持有理数、大整数和复数。rust-version: 最低支持的 Rust 版本 1.65.0。支持各种数值类型（整数、大整数、有理数、复数等）mks: 米-千克-秒单位制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值