C++类（未完结）

已于 2023-06-17 22:20:32 修改
阅读量409 收藏
点赞数 1
文章标签： c++ 开发语言
于 2023-06-16 15:47:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62390970/article/details/131248437
版权
本文介绍了C++中的类和面向对象编程的基本概念，包括类的定义、属性和方法，以及面向对象的三大特性——封装、继承和多态。详细讲解了构造函数、拷贝构造函数、移动构造函数的作用，以及this指针的使用。还讨论了const对象和const成员函数在保证数据安全方面的重要性。
摘要由CSDN通过智能技术生成

目录

类的特点

类，c++程序员的工具箱中最基础且最重要的工具之一。是面向对象编程的基础。

  • 什么是类？

    类，是用户自定义的数据类型，类似结构体（struct）。在c语言中我们常使用struct，而在c++中我们用类比较多。

面向对象

面向对象编程（通常缩写为OOP）的本质是，根据需要解决的问题涉及的对象来编写程序。因此程序开发过程的一部分就是涉及一组类型来满足这个要求。

两大成员

属性

对象的某些特征数据，比如一个学生对象，我们可能需要定义他的姓名，学号、各科成绩等。同理，对于一个立方体，我们可能需要定义它的长、宽、高。

方法

类中提供的一些函数，比如学生对象，可以提供一个info函数，输出学生信息。sumGrade方法，返回学生总成绩的。立方体对象，我们就可以设计两个函数（方法），分别计算表面积和体积。

三大特性

封装

类的一些函数和方法，我们不想让它们在类外直接访问（通过对象直接），就可以把它们封装起来。比如学生的成绩，只允许查询而不允许修改，我们就可以把成绩封装起来，不能直接拿到学生成绩，而是通过我们定义的没被封装的函数（方法）来访问。而我们不提供修改的方法，这样就实现了只允访问，而不能修改。总结一句话，对于封装的数据，禁止直接访问该数据，但可以通过对象的成员函数来访问。

类的所有成员默认为私有，表示不能在类的外部直接访问他们。

实现：

通过c++为我们提供的public、protected、private关键字可以很轻松的实现。

继承

根据一个类定义另一个类。比如，我们先定义一个human类，属性有姓名、性别、年龄、家庭住址等。我们此时又想定义一个学生类，此时我们就可以通过继承human来继承human类的姓名、性别、年龄、家庭住址等属性，然后在另外定义成绩、学号属性就行。这样就不需要在再重新定义属性。

多态

多态表示在不同时刻有不同的形态。c++中的多态性总是设计使用指针或引用来调用对象对象的成员函数。这个说起来有些复杂，之后给代码演示。

类的定义

类是用户自定义数据类型。使用class关键字定义类。

class ClassNamed
{
	// 属性
    // 方法
};  // ; 不可省

定义了一个类，类的名称为ClassName。类名首字母一般为大写字母。

类的成员（方法、属性）都在类中定义（方法的实现可放在类外）。

类的成员函数默认为私有，在类外不能直接访问。可以使用public关键字后跟一个冒号，表示后面定义的成员都能在类外直接访问（直至遇到下一个private:或protected：）。

class ClassName
{
private:
    // 私有成员。定义在外部不能直接访问的成员。
    // something...
    
public:
    // 公开成员。定义在外部能直接访问的成员。
    // something...
};

下面我们定义一个立方体盒子

class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
    double get_volume() // 成员函数（方法），计算Box体积
    {
        double volume = length * width * height;	// 计算体积
        return volume;							 // 返回体积
    }
};

类和结构体的区别

区别：C++类的成员默认是私有的，C++结构的成员默认是公开的。其他各方面，几乎一样。

在C++我们常使用类，而结构体一般是定义一些小型对象。结构体可以直接放在类中，作为类的成员属性。

类的构造函数

  1. 构造函数，作用是用来构造类的对象（类似用int定义变量。int a=2; a就是一个int型的对象。）。

  2. 本质都是一种函数，可以有参数但没有返回值。

  3. 没有返回值是指，我们不给出返回值，不是指返回值为空，这是一种规定。

默认调用函数和无参构造函数

class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
   	Box()	// 无参构造函数
    {
        length = 1.0;
        width = 1.0;
        height = 1.0;
        cout << "调用无参构造函数" << endl;
    }
};
  1. 默认构造函数没有参数，没有参数，没有返回值。一定是没有，而不是返回值为空。
  2. 如果类没有任何构造函数，编译器会自动生成一个默认的默认构造函数。
  3. 如果类已经定义了构造函数，此时编译器不会给出默认构造函数，此时我们需要定义无参构造函数（或者显式定义无参构造函数）。否则Box box1;错误。
// 测试构造函数
#include <iostream>
using namespace std;
class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
    // Box () = default; 
   	Box()	// 默认构造函数
    {
        length = 1.0;
        width = 1.0;
        height = 1.0;
        cout << "调用无参构造函数" << endl;
    }
public:
    double get_volume() // 成员函数（方法），计算Box体积
    {
        double volume = length * width * height;	// 计算体积
        return volume;							 // 返回体积
    }
};

int main()
{
    Box box1;	// 调用无参构造函数，构造对象box1
    cout << box1.get_volume() << endl;	
    return 0;
}

/*output
	调用无参构造函数
	1
*/

一般构造函数

class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
   	Box()	// 无参构造函数
    {
        length = 1.0;
        width = 1.0;
        height = 1.0;
    }
    
    Box(double _len, double _wid, double _hei)	// 一般构造函数1
    {
        length = _len;
        width = _wid;
        height = _hei;
    }
    
    Box(double _len, double _wid)	// 一般构造函数2
    {
        length = _len;
        width = _wid;
        height = 1.0;
    }
};

  1. 一般构造函数可以不止一个。

  2. 一般构造函数通过函数参数来区分。

  3. 一般构造函数定义对象。Box box2(参数1，参数二， 。。)

// 测试一般构造函数
#include <iostream>
using namespace std;
class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
   	Box()	// 无参构造函数
    {
        length = 1.0;
        width = 1.0;
        height = 1.0;
        printf("无参构造函数被调用\n");
    }
    
    Box(double _len, double _wid, double _hei)	// 一般构造函数1
    {
        length = _len;
        width = _wid;
        height = _hei;
        printf("构造函数 Box(double _len, double _wid, double _hei) 被调用\n");
    }
    
    Box(double _len, double _wid)	// 一般构造函数2
    {
        length = _len;
        width = _wid;
        height = 1.0;
        printf("构造函数 Box(double _len, double _wid) 被调用\n");
    }
    
public:
    double get_volume() // 成员函数（方法），计算Box体积
    {
        double volume = length * width * height;	// 计算体积
        return volume;							 // 返回体积
    }

};

int main()
{
    Box box1;	                // 调用默认构造函数
    Box box2(2.0, 3.0);         // 调用一般构造函数2
    Box box3(2.0, 3.0, 4.0);    // 调用一般构造函数1
    
    cout << "box1: " << box1.get_volume() << endl;	
    cout << "box2: " << box2.get_volume() << endl;	
    cout << "box3: " << box3.get_volume() << endl;	
    
    return 0;
}

/*output
	无参构造函数被调用
    构造函数 Box(double _len, double _wid) 被调用
    构造函数 Box(double _len, double _wid, double _hei) 被调用
    box1: 1
    box2: 6
    box3: 24
*/

拷贝构造函数

如果我们需要通过一个现有对象，去构造一个新的相同的对象，此时我们就需要使用到拷贝构造函数。

class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
   	Box()	// 无参构造函数
    {
        length = 1.0;
        width = 1.0;
        width = 1.0;
    }
    
    Box(double _len, double _wid, double _hei)	// 一般构造函数
    {
        length = _len;
        width = _wid;
        height = _hei;
    }

    Box(const Box& box)	// 拷贝构造函数
    {
        length = box.length;
        width = box.width;
        height = box.height;
    }
};
  1. 拷贝构造函数的参数是一个常量引用。
// 测试拷贝构造函数
#include <iostream>
using namespace std;
class Box
{
 private:
    double length;	// 盒子的长
    double width;   // 盒子的宽
    double height; 	// 盒子的高
    
public:
   	Box()	// 无参构造函数
    {
        length = 1.0;
        width = 1.0;
        height = 1.0;
        printf("无参构造函数被调用\n");
    }
    
    Box(double _len, double _wid, double _hei)	// 一般构造函数1
    {
        length = _len;
        width = _wid;
        height = _hei;
        printf("构造函数 Box(double _len, double _wid, double _hei) 被调用\n");
    }
    
    Box(const Box& box)	// 拷贝构造函数
    {
        length = box.length;
        width = box.width;
        height = box.height;
        printf("拷贝构造函数被调用\n");
    }
    
public:
    double get_volume() // 成员函数（方法），计算Box体积
    {
        double volume = length * width * height;	// 计算体积
        return volume;							 // 返回体积
    }

};

int main()
{
    Box box1;	                // 调用默认构造函数
    Box box2(2.0, 3.0, 4.0);    // 调用一般构造函数
    Box box3(box2);            // 调用拷贝构造函数
    
    cout << "box1: " << box1.get_volume() << endl;	
    cout << "box2: " << box2.get_volume() << endl;	
    cout << "box3: " << box3.get_volume() << endl;	
    
    return 0;
}

/*output
    无参构造函数被调用
    构造函数 Box(double _len, double _wid, double _hei) 被调用
    拷贝构造函数被调用
    box1: 1
    box2: 24
    box3: 24
*/

移动构造函数

  1. 用一个现有对象去创建一个新对象。
  2. 一般当对象管理者堆上的属性时，才会用到。
class A
{
 private:
    int *ptr;
    
public:
   	A() {ptr = new int();}	// 无参构造函数
    
    A(int *_p)	{ptr = _p;}// 一般构造函数
    
    A(const A& _a)	// 拷贝构造函数
    {
		ptr = new int( *(_a.ptr) );
    }
    
    A(A&& _a)  	// 移动构造函数
    {
		ptr = _a.ptr;
        _a.ptr = nullptr;
    }
    
    ~A()	// 析构函数 后面说
    {
        if (ptr != nullptr)
        	delete ptr;
    }
};
  1. 看不明白也没关系，这里没有细讲。
  2. 移动构造函数可以不着急掌握。等后面对类很熟悉后，在了解也不晚，不影响类的使用。

类的析构函数

当我们调用构造函数创建对象时，当超出这个对象作用域时，会调用构造函数将对象析构。

class A
{
 private:
    int *ptr;
    
public:
   	A() {ptr = new int();}	// 无参构造函数
    
    A(int *_p)	{ptr = _p;}// 一般构造函数
    
    Box(const A& _a)	// 拷贝构造函数
    {
		ptr = new int( *(_a->ptr) );
    }
    
    ~Box()	// 析构函数
    {
        if (ptr != nullptr)
        	delete ptr;
    }
};

  1. A的对象在构造之处，使用new在堆上创建了int数据。我们知道，new出的数据，一定要调用delete删除。

  2. c++编译器不会自动调用delete，需要手动调用。所以我们在析构函数进行此操作。

2023/6/17更新

this指针

简单使用

在执行任何成员函数时，该成员函数都自动包含一个隐藏的指针，称为this指针。

this指针指向此成员函数的对象本身，存放的是该成员函数的地址。

比如，我们有时候会写出这样的成员函数。

class A
{
private:
   int age; 
public:
    void setAge(int age)  // 设置 age, 函数参数为了好理解， 也同属性名一样的 age
    {
        // age = age;  // 失败
        this->age = age;
    }
    
    /*
    void setAge (int newAge) 
    {
    	// do something
    	int age = 456;
    	//do somethings
    	// age = newAge; // 还是不行，编译器分辨不清这是函数中定义的临时变量还是私有属性age。
    	this->age = newAge; // 正确。 this指向的变量专指属性，不存在任何歧义。
    }
    */
    
    void printAge() { cout << age << endl; }
};

为设置私有属性 age 的值，我们需传入新的age值。如果我们把setAge参数名也设置为age。如果不借助this指针，我们只能这样写，age = age, 但测试后发现这样是错误的，无法成功更改age值，因为编译器不知道这两个age分别代表什么。

此时，this也就排上用场了， this->age = age; 用this->age特指对象的age属性，与传入的age参数区分开来，设置成功。

this指针确实在成员函数中存在，且给我们提供一种没有歧义的设置属性的手段。

函数返回对象指针和引用

this 是指向此对象的指针。 *this是对象本身。

借助 this指针实现 "方法链"。类似这种形式 ObjectName.func1().func2().func3()

#include <iostream>
using namespace std;

class Student
{
private:
    int age;
    char sex;
    string name;
    
public:
    Student& setAge (int _age) // 返回对象引用
    {
        this->age = _age;
        return *this;
    }
    
    Student & setSex (char _sex)
    {
        this->sex = _sex;
        return *this;
    }
    
    Student & setName (const string& _name)
    {
        this->name = _name;
        return *this;
    }

    void printInfo () 
    {
        cout << "姓名: " << name << endl;
        cout << "性别: " << sex << endl;
        cout << "年龄: " << age << endl;
    }
};

int main()
{
    Student stu;

    stu.setAge(19).setName("张三").setSex('M');
    stu.printInfo();

    return 0;
}

/*output
	姓名: 张三
    性别: M
    年龄: 19
*/

const

const对象和const成员函数

const 变量是不能修改其值的变量。自然，也可以定义类类型的const变量。这种变量称为const对象。构成const对象状态的任何成员变量不能被修改。

也就是说，const 对象的任何成员变量本身是一个 const 变量，因而不能修改。

class Box
{
public:
    double length;
    double width;
    double height;
    
    // 使用默认生成的默认无参构造函数
    Box() = default;
    
    // 构造函数
    Box (double _len, double _wid, double _hei) : length(_len), width(_wid), height(_hei) {} 
    
    // 求体积
    double getVolume() { return length * width * height ;}
};

Box类的长宽高是公有的，是可以直接通过对象名修改的。例如

Box b1(1, 2, 3);
b1.length = 1.6;
b1.width = 1.5;
b1.height = 1.8;

如果想创建一个不可被修改的Box对象，可借助const。

const Box b2(1, 2, 3);
cout << b2.length << endl; // ok
// b2.length = 1.6;   // error
// b2.width = 1.5;    // error
// b2.height = 1.8;   // error

同样const也可作用域指针和引用。

Box b1(1, 2, 3);
const Box* ptr = &b1;
// ptr->length = 2.3;  // error 

void printBox(const Box& box);	// 在printBox函数中也不可修改box的值

const 成员函数

上面我们通过 const Box b2(1, 2, 3); 定义了一个Box的const对象，此时我们我们不在能修改成员变量，一定程度上保证了数据的安全性。但也带来了一个问题：getVolume()函数也将不可调用。

为什么？因为编译器并不知道 getVolume() 是否修改了成员变量，此时b2.getVolume();编译通不过。

解决方案：将getVolume函数设置成const 成员函数。

// 修改后的 getVolume
double getVolume() const  // const 关键字标识此函数不修改任何成员变量
{ return length * width * height ;}

// b2.getVolume(); 将能通过编译。

对于const对象，只能调用 const 成员函数。因此，应该将不修改对象的所有成员函数指定为const。

框住
关注
C++实现的垃圾回收管理类
06-27
这个垃圾回收管理类的目标是自动跟踪和清理在程序执行过程中分配但未释放的动态内存。在C++标准库中，没有内置的垃圾回收机制，因此开发者必须自己编写代码来跟踪和管理内存。这个类提供了一种方式，通过在对象生命...
C/C++项目开发：C++类封装之角色移动.txt
07-24
本视频为C/C++编程经典项目之C++类封装之角色移动项目。教你们如何实现拳皇游戏角色移动！主要利用C语言知识以及C++编程知识以及少量算法、数据结构的知识来制作，本视频并不建议完全零基础的小伙伴下载学习，因为...
C++的类
weixin_61488314的博客
05-01 4022
类的定义有两种方式,一种是定义和声明都放在类体中,另一种是声明和定义分离分别放在.h和.cpp中我们把结构体,类等放在头文件.h其中之一的目的就是为了方便我们去看,这个类的功能,那么当成员函数的声明与定义都放在头文件.h中时,未免就会造成头文件代码过多,不容易查看。此时我们就要让声明与定义分离,把成员函数的定义放到.cpp文件中,但是要加上类域,不然编译器就会分不清这个函数到底是普通函数还是成员函数。例如上述代码成员函数定义在.cpp文件中就要这样写：要指明类域且返回类型放在最前面。
c++类继承
dtxew love c++
07-25 4396
继承是一种简化代码的手段之一，使代码可以实现复用。它允许在原来类的功能上进行扩展，衍生出新的功能。也可以把多个类的基本信息提取到某个类，减少代码的冗余。其中被继承的类通常叫做父类或基类，继承下来的类叫做子类或派生类。...
C++类模板实例化
jinzhu1911的专栏
09-04 1万+
C++类模板实例化 文章目录C++类模板实例化1. 简介2. 类模板实例化2.1 隐式实例化（Implicit instantiation）2.2 显示实例化（Explicit instantiation）2.3 类模板中的静态成员 1. 简介 该文章主要总结C++类模板实例化的方法。类模板的实例化包含两种： 隐式实例化（Implicit instantiation） 显示实例化（Explicit instantiation） 2. 类模板实例化 类模板本身不是类型、对象或任何其他实体。仅包含模板定义的
C++ 类和对象详解
叫我小秦就好了的博客
03-26 3309
文章介绍类的基本内容，并对this 指针、默认成员函数、赋值运算符重载、const 成员和 static 成员展开重点讲解。
C++ 类使用
个人技术博客
11-09 9106
一、C++ 类使用 1、类成员的初始化顺序 下面学习下，C++类成员的初始化顺序，例如： class A { private: int n1; int n2; public: A():n2(0),n1(n2+2){} void Print(){ cout << "n1:" << n1 << ", n2: " << n2 <<endl; } }; int main() { A a; a.Print(); // 输出结果
C++类和对象详细总结
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++编程——类模板
professor_tao的博客
05-08 3万+
文章目录1 类模板语法2 类模板与函数模板的区别3 类模板中成员函数创建时机4 类模板对象做函数参数 1 类模板语法 类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表 语法： template<typename T> 类 解释： template声明创建模板 typename表明其后面的符号是一种数据类型，可以用class代替 T是通用的数据类型，名称可以替换，通常为大写字母 示例： //类模板 template<class NameType, cl
c++类的大小计算
热门推荐
rotation博客
06-01 3万+
c++中类所占的大小计算并没有想象中那么简单，因为涉及到虚函数成员，静态成员，虚继承，多继承以及空类等，不同情况有对应的nisan方式，在此对各种情况进行总结。 首先要明确一个概念，平时所声明的类只是一种类型定义，它本身是没有大小可言的。 我们这里指的类的大小，其实指的是类的对象所占的大小。因此，如果用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小。关于类/对象大小的计算 首先，类
C++类的6个默认函数
weixin_42887343的博客
05-28 3648
1 C++类的6个默认函数如下： 缺省构造函数 拷贝构造函数 析构函数 赋值操作符重载 取地址操作符重载 const修饰的取地址操作符重载 对于空类，以上6个函数，编译器不会生成，只会生成1个字节的占位符。有时编译器不会为空类生成默认构造函数等，只有在需要的时候才生成6个默认的成员函数和一个this指针。 2 缺省构造函数 缺省构造函数又称默认构造函数，是C++以及其他的一些面向对象的程序设计语言中，对象的不需要参数即可调用的构造函数。 也就是说，如果构造函数没有参数，或者构造函数的所有参数都有默认值，
NTFS数据恢复的c++类代码
05-06
本篇文章将详细讨论NTFS数据恢复的C++类代码相关知识点，以及如何利用这些代码进行数据恢复。 首先，我们要了解NTFS文件系统的基本结构。NTFS采用的是MFT（Master File Table）主文件表来记录所有文件和目录的信息...
json字符串转换c++类对象
05-09
在C++编程中，将JSON字符串转换为C++类对象是一项常见的任务，特别是在处理网络通信、数据存储或配置文件时。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析...
C++中类使用全局变量
07-07
在C++编程语言中，全局变量是在程序的任何作用域之外声明的变量，可以在程序的多个函数或类中被访问。它们在整个程序的生命周期内都存在，从程序开始执行到结束时保持其值。全局变量的使用有其优点，如共享数据和...
C++学习——类的初始化
zxr916的博客
06-20 1万+
文章目录1.类通过构造函数进行数据成员初始化2.类成员初始化方式？3.什么情况下必须使用列表初始化？4.为什么用列表初始化成员变量会快一些？5.派生类构造函数的执行顺序 1.类通过构造函数进行数据成员初始化 一般来说，类中的数据成员是私有的，不能通过对象共有访问的方式对数据成员赋初始值。一般来说，构造函数就是用来用来在创建对象时初始化对象， 为对象数据成员赋初始值。 构造函数是类的一种特殊成员函数，不需要人为调用，而是在建立对象时自动被执行。 2.类成员初始化方式？ 赋值初始化，通过在函数体内进行赋值初始化
C++之类型转换以及特殊类的设计
最新发布
JYXCZYH的博客
12-13 496
首先让我们来回顾一下C语言中的类型转换。在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。这中转换方式是有一定的缺陷的，转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换，于是C++就引入了四种类型转换：static_cast、reinterpret_cast、const_cast、dynamic_cast，接下来让我们一一认识一下。
C++中的高阶函数：std::function
mj348940862的博客
12-13 847
例如，std::function<void(int)>表示接收一个整数参数，并且不返回任何值的回调函数，std::function<std::string(const std::string&)>表示接收一个字符串参数，并且返回一个字符串的回调函数。std::function是一个通用的、多态的函数封装器，它的实例可以对任何可以调用的目标实体进行存储、复制和调用操作，包括普通函数、Lambda表达式、函数指针和带有operator()的类等。在这个例子中，我们首先使用了一个自由函数作为任务函数。
【C++】重载运算与类型转换（七）：成员访问运算符
YGGP的博客
12-12 225
对 C++ Primer 第五版第十四章第七节的成员访问运算符进行阅读学习和记录。
C++类未声明的标识符
12-21
C++类未声明的标识符是指在使用类的成员变量或成员函数时，编译器无法找到对应的声明或定义。这通常是由于以下几种情况引起的： 1. 忘记包含类的头文件：在使用类之前，需要包含类的头文件，以便编译器知道类的声明...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值