c++多态

已于 2023-08-28 10:25:32 修改
阅读量114 收藏 1
点赞数
分类专栏： C++ 学习 文章标签： c++ 算法 开发语言 数据结构
于 2023-08-21 22:38:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012011912/article/details/132412606
版权
本文详细介绍了C++中的多态性，包括基本概念、使用场景、对象模型，以及虚函数、虚析构函数和纯虚函数的运用。重点讲解了如何利用多态提高代码灵活性、减少重复和运行时动态调用。同时，讨论了析构派生类和抽象类的特性和使用方法。
摘要由CSDN通过智能技术生成

一、多态基本概念

在C++中，多态性是面向对象编程的一个重要概念，它允许我们通过基类指针或引用来调用派生类的方法，从而实现在运行时选择不同的实现。这种特性大大增强了代码的灵活性和可维护性。
如果不使用虚函数，那么基类指针只能调用基类成员函数，不能调用派生类成员函数。多态性的核心概念是虚函数（Virtual Function）。当我们在基类中声明一个成员函数为虚函数时，它可以在派生类中被重写（覆盖），并且通过基类的指针或引用调用时，会根据实际指向的对象类型来调用相应的派生类方法，从而访问派生类的成员变量。

  • 基类指针指向基类对象时就使用基类的成员函数和数据
  • 基类指针指向派生类对象时就使用派生类的成员函数和数据（这里的数据需要填通过派生类成员函数来使用）

基类指针表现出了多种形式，这种现象称为多态。

1.1 示例代码

首先，我们定义一个基类 Animal，其中包含一个虚函数 speak()。接着，我们有派生类 Dog ，它重写了基类的虚函数。现在我们可以使用多态性来创建基类指针，并在运行时调用派生类的方法：

  • 指针调用：

    class Animal {
public:
    virtual void speak() {
        std::cout << "叫叫叫" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "汪汪汪" << std::endl;
    }
};

int main() {
    Animal* animal = new Animal;
    Animal* dog = new Dog;

    animal->speak();//叫叫叫
    dog->speak();//汪汪汪
}

  • 引用调用：

    class Animal {
public:
    virtual void speak() {
        std::cout << "叫叫叫" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "汪汪汪" << std::endl;
    }
};

int main() {
    Animal animal;
    Dog dog;

    Animal& animal1 = animal;
    Animal& dog1 = dog;
    animal1.speak();//叫叫叫
    dog1.speak();//汪汪汪
}

1.2 注意事项

  1. 如果函数定义在类外，只需要在基类的函数声明中加上 virtual 关键字，函数定义时不能加。

    class Animal {
public:
    virtual void speak();//函数声明时需要加上virtual
};

void Animal::speak() {//函数定义时不加
    std::cout << "叫叫叫" << std::endl;
}

class Dog : public Animal {
public:
    void speak() {
        std::cout << "汪汪汪" << std::endl;
    }
};

int main() {
    Animal *dog = new Dog;
    dog->speak();//汪汪汪
}

  2. 派生类中重写虚函数的函数签名必须与基类中的虚函数一致。
    函数签名包括函数的名称、参数列表和参数类型

  3. 如果派生类没有重写虚函数，基类的虚函数会被继续使用。

    class Animal {
public:
    virtual void speak() {
        std::cout << "叫叫叫" << std::endl;
    }
};

class Dog : public Animal {
public:
};

int main() {
    Animal *dog = new Dog;
    dog->speak();//叫叫叫
}

  4. 如果想在派生类中调用基类的虚函数，可以使用类名和作用域解析符。

    class Animal {
public:
    virtual void speak() {
        std::cout << "叫叫叫" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
    	//Animal::speak();也可以在派生类里调用基类函数
        std::cout << "汪汪汪" << std::endl;
    }
};

int main() {
    Animal *dog = new Dog;
    dog->Animal::speak();//叫叫叫
    dog->speak();//汪汪汪
}

  5. 如果要在派生类中重新定义基类的函数，则将它设置为虚函数;否则，不要设置为虚函数。
    原因：

    • 效率更高：虚函数会带来开销。
    • 指出不要重新定义该函数：让程序员知道，这个函数没有virtual关键字，就不需要重新定义该函数。

二、多态使用场景

2.1 示例

  • 使用多态：
    class Animal {
public:
    virtual void speak() {
        std::cout << "叫叫叫" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        std::cout << "汪汪汪" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() {
        std::cout << "喵喵喵" << std::endl;
    }
};

int main() {
    std::vector<Animal*> arr;
    arr.push_back(new Dog);
    arr.push_back(new Cat);

    for(Animal* animal:arr){
        animal->speak();//汪汪汪，喵喵喵
    }
}
  • 不使用多态：
    class Dog {
public:
    void speak() {
        std::cout << "汪汪汪" << std::endl;
    }
};

class Cat {
public:
    void speak() {
        std::cout << "喵喵喵" << std::endl;
    }
};

int main() {
    std::vector<Dog> arr_dog;
    std::vector<Cat> arr_cat;
    arr_dog.push_back(Dog());
    arr_cat.push_back(Cat());

    for(Dog dog:arr_dog){
        dog.speak();//汪汪汪
    }
    for(Cat cat:arr_cat){
        cat.speak();//喵喵喵
    }
}

2.2 优点

  1. 灵活性和可扩展性： 使用多态的代码中，我们只需在基类中添加新的派生类，而不必修改现有的代码。这使得代码更具灵活性和可扩展性。在不使用多态的情况下，每当添加新的类时，都需要修改主代码来处理新类的实例，增加了维护成本。

  2. 减少重复代码： 使用多态，我们只需在基类中定义一次函数，然后让派生类继承并重写，从而减少了重复代码。在不使用多态的情况下，每个类都需要单独实现相似的函数，导致代码冗余。

  3. 简化代码维护： 当需要修改公共操作时，只需更改基类中的代码，而不必在每个派生类中进行修改。这样可以减少维护工作并降低出错的风险。

  4. 运行时决定调用： 多态允许在运行时根据实际对象类型来决定调用哪个函数。这种灵活性可以根据具体情况来选择不同的实现，从而更好地适应程序的需求。

  5. 适用于抽象和通用操作： 多态特别适用于处理抽象的操作，如在这个例子中的"叫"。基类可以定义抽象的操作，而派生类可以根据自己的特点进行实现。

三、多态的对象模型

多态的对象模型可以理解为在面向对象编程中，对象和函数之间的关系，特别是在涉及继承和多态性的情境下。多态性允许同一方法名在不同的对象类型上具有不同的实现，以提供更灵活的代码结构和更具扩展性的设计。

在C++中，多态性通过虚函数和继承来实现。下面是对你提供的内容进行进一步解释：

  1. 类的普通成员函数： 在类中定义的普通成员函数的地址是静态的，这意味着在编译阶段就已经确定了函数的调用地址。这种情况下，无论对象的实际类型如何，调用的都是静态绑定的函数。

  2. 虚函数和虚函数表： 当基类中声明虚函数时，C++为每个对象创建一个虚函数表（VTable），其中存储了虚函数的名称和地址。这样，即使通过基类的指针或引用访问派生类对象，也可以在运行时根据实际对象的类型来调用正确的函数。（注意：派生类会继承基类的虚函数和虚函数表）

  3. 派生类的虚函数重写： 如果派生类重写了基类中的虚函数，派生类的函数将会取代虚函数表中基类函数的位置。这意味着通过基类指针或引用调用虚函数时，会根据实际对象的类型来动态选择正确的函数实现。

  4. 多态的种类：

    • 静态多态（编译时多态）： 这种多态在编译时期就已经确定了要调用的函数地址，主要有函数重载和函数模板。函数重载允许同一个函数名拥有不同的参数列表，编译器会根据调用时的参数类型选择合适的函数。函数模板允许在编译时根据参数类型生成不同的函数实例。
    • 动态多态（运行时多态）： 也称为动态绑定，它在运行时根据实际对象的类型来选择要调用的函数。一般用于基类指针或引用指向派生类对象时，通过虚函数的动态绑定来调用派生类中的实现。

多态性的核心思想在于将函数调用的具体实现推迟到运行时，从而更好地适应不同的对象类型和扩展需求。这种灵活性使得代码更易于维护和扩展，同时也更贴近实际问题的建模。

四、如何析构派生类

在C++中，析构函数的调用顺序与构造函数相反。析构函数在销毁对象时被调用。派生类的析构函数会在执行完派生类的清理工作后自动调用基类的析构函数，无需显式调用。

4.1 虚构派生类

class Base {
public:
    Base() { std::cout << "基类构造函数" << std::endl; }
    ~Base() { std::cout << "基类析构函数" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "派生类构造函数" << std::endl; }
    ~Derived() { std::cout << "派生类析构函数" << std::endl; }
};

int main() {
    Derived d;  // 创建派生类对象
    return 0;
}

基类构造函数
派生构造构函数
派生类析构函数
基类析构函数

如果手动调用派生类的析构函数，也会自动调用基类的析构函数：

class Base {
public:
    Base() { std::cout << "基类构造函数" << std::endl; }
    ~Base() { std::cout << "基类析构函数" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "派生类构造函数" << std::endl; }
    ~Derived() { std::cout << "派生类析构函数" << std::endl; }
};

int main() {
    Derived d;  // 创建派生类对象
    d.~Derived();
}

基类构造函数
派生类构造函数
派生类析构函数
基类析构函数
派生类析构函数
基类析构函数

4.2 虚析构函数

如果使用基类指针指向派生类对象并尝试删除基类指针，只会调用基类的析构函数。如果希望正确地调用派生类的析构函数，必须将基类的析构函数声明为虚析构函数。

class Base {
public:
    Base() { std::cout << "基类构造函数" << std::endl; }
    ~Base() { std::cout << "基类析构函数" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "派生类构造函数" << std::endl; }
    ~Derived() { std::cout << "派生类析构函数" << std::endl; }
};

int main() {
    Base* ptr = new Derived();  // 使用基类指针指向派生类对象
    delete ptr;  // 此处会调用派生类的析构函数，然后调用基类的析构函数
    return 0;
}
基类构造函数
派生类构造函数
基类析构函数

class Base {
public:
    Base() { std::cout << "基类构造函数" << std::endl; }
    virtual ~Base() { std::cout << "基类析构函数" << std::endl; }
};

class Derived : public Base {
public:
    Derived() { std::cout << "派生类构造函数" << std::endl; }
    ~Derived() { std::cout << "派生类析构函数" << std::endl; }
};

int main() {
    Base* ptr = new Derived();  // 使用基类指针指向派生类对象
    delete ptr;  // 此处会调用派生类的析构函数，然后调用基类的析构函数
    return 0;
}
基类构造函数
派生类构造函数
派生类析构函数
基类析构函数

原因解释：

  1. 静态绑定与动态绑定： C++是一种静态类型语言，这意味着在编译时需要确定每个变量的类型。当你使用基类指针指向派生类对象时，编译器只知道这是一个基类指针，因此在编译时，它将使用基类的析构函数。这种行为被称为静态绑定，因为在编译时绑定（决定调用哪个函数）已经确定了。
  2. 虚函数和动态绑定： 为了实现多态性，C++引入了虚函数和动态绑定机制。当你将基类的析构函数声明为虚函数时，编译器会在运行时检查对象的实际类型，然后根据实际类型调用正确的析构函数。这种行为被称为动态绑定，因为在运行时绑定（决定调用哪个函数）发生。

所以，如果你不将基类的析构函数声明为虚析构函数，当你使用基类指针删除派生类对象时，编译器只会使用基类的析构函数，无法正确调用派生类的析构函数。这可能会导致资源泄漏和不正确的对象清理。通过声明基类的析构函数为虚函数，你告诉编译器在运行时进行动态绑定，以便在删除派生类对象时正确调用派生类的析构函数。

4.3 析构派生类要点

  1. 析构派生类对象时，会自动调用基类的析构函数。与构造函数不同的是，在派生类的析构函数中不用显式地调用基类的析构函数，因为每个类只有一个析构函数，编译器知道如何选择，无需程序员干涉。
  2. 析构函数可以手工调用，如果对象中有堆内存，析构函数中以下代码是必要的:
    delete ptr;
ptr = nullptr;//如果不写这一句话，就会变成指针悬挂，如果再delete ptr就会报错，而delete空指针不会吧报错
  3. 用基类指针指向派生类对象时，delete 基类指针调用的是基类的析构函数，不是派生类的，如果希望调用派生类的析构函数，就要把基类的析构函数设置为虚函数。
  4. 对于基类，即使它不需要析构函数，也应该提供一个空虚析构函数。
    这是因为当你的基类在继承关系中作为派生类的基类时，可能会发生资源泄漏或未定义行为，除非基类具有虚析构函数。
    这是为了确保以下情况下的正确行为：
    • 如果派生类在析构函数中分配了资源（如堆内存或打开的文件），而基类没有虚析构函数，当你通过基类指针删除派生类对象时，只会调用基类的析构函数。这将导致派生类对象中的资源没有被正确释放，可能导致资源泄漏。
  5. 赋值运算符函数不能继承赋值运算符函数不继承： 赋值运算符函数是基于对象类型的操作，因此它们不会被隐式继承。这意味着如果你在基类中定义了一个赋值运算符函数，它不会被派生类隐式继承。如果你希望在派生类中使用相同的赋值操作，你需要在派生类中重新定义该赋值运算符函数。
  6. 友元函数不是类成员，不能继承。

五、纯虚函数和抽象类

纯虚函数是一种特殊的虚函数，它在基类中声明但没有实际的函数体。它的目的是为了让派生类去实现这个函数，以便实现多态性。纯虚函数常常用于描述基类中的通用行为，而具体的实现则由派生类提供。

5.1 纯虚函数的声明和使用

纯虚函数的声明采用以下语法：

virtual 返回值类型 函数名(参数列表) = 0;

纯虚函数只有函数名、参数和返回值类型，没有函数体。它在基类中为派生类保留了一个函数名，以便派生类可以重定义这个函数，实现自己的功能。如果一个类中包含了至少一个纯虚函数，那么这个类就被称为抽象类。

5.2 抽象类的特点和用途

抽象类是包含纯虚函数的类，无法实例化对象，但可以创建指向它的指针和引用。抽象类的主要作用是为了定义一组接口，规定了派生类必须实现的函数，从而实现多态性。

class Animal{
public:
    virtual void speak()=0;
};

class Dog:public Animal{
public:
    virtual void speak(){
        cout<<"汪汪汪"<<endl;
    }
};

int main() {
    //Animal* animal = new Animal;错误，无法实例化抽象类对象
    Animal* dog = new Dog;
    dog->speak();
}

在这个例子中，Animal 是一个抽象类，它包含一个纯虚函数 speak，而 Dog 是一个派生类，实现了 speak 函数。我们通过使用指向基类的指针来实现多态性，这样可以在运行时确定调用的是派生类的函数。

  • 注意：派生类必须重定义抽象类中的所有纯虚函数，否则派生类也会成为抽象类，无法实例化对象。

5.3 纯虚析构函数

基类中的纯虚析构函数必须要实现

在C++中，如果一个类中有纯虚函数，那么这个类就是抽象类，不能实例化生成对象，只能派生。由它派生的类的纯虚函数如果没有被实现，那么，该派生类还是个抽象类。只有全部实现了纯虚函数的派生类才可以被实例化。定义一个函数为纯虚函数，一般表示该函数没有被实现。但是，这不代表纯虚函数不能被实现。纯虚函数也是可以定义的。

在C++中，如果一个类中有纯虚析构函数，那么这个类必须要有一个虚析构函数的定义。因为虚析构函数工作的方式是：最底层的派生类的析构函数最先被调用，然后各个基类的析构函数被调用。这就是说，即使是抽象类，编译器也要产生对纯虚析构函数的调用，所以要保证为它提供函数体。如果不这么做，链接器就会检测出来，最后还是得回去把它添上。

所以基类中的纯虚析构函数必须要有代码实现。

  • 注意：C++中，纯虚析构函数的定义必须在类之外，而不能在类的内部，因为纯虚析构函数必须有定义体。如果在类内部定义纯虚析构函数，那么编译器就会认为这个析构函数是一个普通的虚析构函数，而不是一个纯虚析构函数。这样就会导致编译错误
class Animal{
public:
    virtual ~Animal()=0;
};

Animal::~Animal() {
    cout<<"基类析构函数"<<endl;
};

class Dog:public Animal{
public:
    ~Dog(){
        cout<<"派生类析构函数"<<endl;
    }
};

int main() {
    Animal* dog = new Dog;
    delete dog;
}
派生类析构函数
基类析构函数
海绵宝宝丶哈
关注
专栏目录
优化重复冗余代码的8种方式！
Java笔记虾
08-29 162
前言日常开发中，我们经常会遇到一些重复冗余的代码。大家都知道重复代码不好，它主要有这些缺点：可维护性差、可读性差、增加错误风险等等。最近呢，我优化了一些系统中的重复代码，用了好几种的方式，感觉挺有用的。所以本文给大家讲讲优化重复冗余代码的几种方式~抽取公用方法抽个工具类反射泛型继承和多态设计模式函数式LambdaAOP切面1. 抽取公用方法 抽取公用方法，是最常用的代码去重方式~比如这个例子，分别...
C++之使用智能指针share_ptr实现多态
四叶草姚的博客
09-04 8451
C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板（重载和多态无关）。多态也是面对对象编程的关键所在。 和内置指针一样，智能指针类也支持派生类向基类的类型转换，这意味着我们可以将一个派生类对象的指针存储在一个基类的智能指针内。（C++Primer）。 我们先定义一个基类： class Person { public: string name; Person(){} ...
C++多态
weixin_50569901的博客
04-20 1万+
C++中的多态分为静态多态和动态多态两种，其中： 静态多态在编译阶段实现，其原理是由函数重载实现，通过不同的实参调用其相应的同名函数。 动态多态通过虚函数实现，以下着重介绍 动态多态的两个必要条件： 必须通过基类的指针或者引用调用 被调用的必须是虚函数，且在派生类中实现了该虚函数的重写 以下解释何为通过基类的指针或者引用调用 int main() { Person p; student s; Person &tmp1 = p; Person &tmp2 = s;//tm
C++ 多态 超详细讲解
热门推荐
qq_53558968的博客
05-18 5万+
文章目录多态概念引入1、C++中多态的实现1.1 多态的构成条件1.2 虚函数1.3虚函数的重写1.4 C++11 override && final1.5 重载，覆盖(重写)，重定义（隐藏）2、抽象类2.1 抽象类的概念2.2 接口继承和实现继承3、 多态的原理3.1 虚函数表3.2多态的原理3.3动态绑定与静态绑定4 、继承中的虚函数表4.1 单继承中的虚函数表4.2 多继承中的虚函数表other 一些有意思的题目 多态概念引入 多态字面意思就是多种形态。 我们先来想一想在日常生活中
C++ 多态
jun8086的博客
10-31 652
c++ 多态
C++多态详解
lim6ere的博客
03-29 851
我们知道C++语言的三大特性（封装，继承，多态）在之前的文章中我们已经学习了封装和继承，在这篇文章中我们将会学习到有关多态的相关问题。这两个关键字是c++11新增的🌟重载：同一作用域中，函数名相同，函数参数不同的函数🌟 重定义（隐藏）：父类和子类两个不同的作用域，只要父类和子类的函数名相同就可以。🌟重写（覆盖）：两个函数分别在子类和父类的作用域，两个函数必须是虚函数，这两个函数函数名，参数，返回值相同（有例外，特殊考虑）。🌟如果子类和父类中既满足重写又满足隐藏，重写优先。
C++多态的用法详解
分享学习的知识，记录我的技术成长道路
04-23 1万+
C++多态是在继承的基础上实现的，了解多态之前我们需要掌握一定的C++继承的知识，本文将介绍C++中多态的概念，构成条件以及用法。
c++多态 详解
qq_39117115的博客
03-09 1174
综上：如果满足多态，看指向对象的类型，调用这个类型的成员函数如果不满足多态， 看调用者类型，调用这个类型的成员函数解释：满足多态的情况下，我们定义Parent * p= new student，这个会调用Student的发生重写的函数我们定义Parent *p =new Parent ，这个会调用Parent中被重写的函数不满足多态的情况下，我们定义Student *s =new Student，这个会调用Student的函数。
C++ 多态类型
索命的博客
11-06 510
C++ 多态入门
c++多态实现原理
karl2000的专栏
03-07 497
我们可以为每个“类”定义一个结构体，其中包含数据成员和一个指向函数指针数组的指针（模拟 vptr）。
C++多态Demo
05-01
这个“C++多态Demo”示例中，我们看到长方形和三角形作为形状（Shape）类的派生类，体现了面向对象编程中的继承和多态概念。 首先，让我们来理解一下基础的面向对象概念： 1. **类（Class）**: 类是创建对象的蓝图...
C++多态的实现机制深入理解
12-26
在面试过程中C++的多态实现机制经常会被面试官问道。大家清楚多态到底该如何实现吗？下面小编抽空给大家介绍下多态的实现机制。 1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2. 存在虚...
C++ 多态的游戏例程
01-20
1）头文件 game.h #ifndef GAME_H #define GAME_H // base class class CCreature { protected: int m_nLifePower， m_nPower; public: virtual void Attack(CCreature *pCreature){} virtual void Hurted...
使用socket编程来实现一个简单的C/S模型（TCP协议）
最新发布
caiji0169的博客
10-02 1026
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 653
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 420
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 392
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 234
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
c++ 多态
05-25
C++中的多态（Polymorphism）是指在父类和子类之间的相互转换，以及在不同对象之间的相互转换。 C++中的多态性有两种：静态多态和动态多态。 1. 静态多态 静态多态是指在编译时就已经确定了函数的调用，也称为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值