Cpp || vector学习

最新推荐文章于 2025-07-16 15:38:34 发布
最新推荐文章于 2025-07-16 15:38:34 发布
阅读量789 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Cpp基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jack_wang128801/article/details/94436931
本文详细解析了C++ STL中的vector容器，包括其内存管理策略、迭代器使用、增删改查操作及注意事项。探讨了vector在不同场景下的应用，如数据查找、空间增长策略、迭代器失效处理等，提供了丰富的代码示例。

文章目录

vector 的相关知识

1.vector的概述
  1. vector是表示可变大小数组的序列容器。
  2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
  3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
  4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
  5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
  6. 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在
    末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

vector容器类型，而vector<数据类型> 定义的s是对象类型

vector< int > a;
a为定义的vector< int >类型的对象

string中的数据是以’\0’结束的，而vector中的数据不是以’\0’结束,其按指针来标记

vector中可以管理不同类型的数据

用vector实例化对象
vector<int > v; //vector<int>才是对象v的类型
用vector实例化对象并进行初始化的方式
vector<char> v2(10,'x');
vector<int> v4(10, 2);
//两种方式都是将实例化对象的前10个元素初始化为指定的值
  • 或者是这种形式的使用
string s("hello bit!");
vector<char> v3(s.begin(),s.end());

利用迭代器的方式来初始化实例化的对象v3;

2.关于vector类型迭代器的使用和遍历
2.1:vector iterator 的使用
iterator的使用接口说明
begin()获取第一个数据位置的iterator
end()获取最后一个数据的下一个位置的iterator
rbegin()获取最后一个数据位置的reverse_iterator
rend()获取第一个数据前一个位置的reverse_iterator
cbegin()获取第一个数据位置的const_iterator
cend()获取最后一个数据的下一个位置的const_iterator

在这里插入图片描述
在这里插入图片描述

#include<iostream>
#include<vector>

using namespace std;

int main(){
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
    //以尾插的方式将内容添加到容器中

	for (int i = 0; i < v.size(); i++){
		cout << v[i] << " ";
	}
	cout << endl;

	//普通迭代器方式访问
	//vector<int>::iterator vit = v.begin();
	auto vit = v.begin();
    //使用auto关键字后其自动匹配迭代器类型
	while (vit!=v.end()){
		cout << *vit << " ";
        //需要输出的是迭代器中的内容
		vit++;
	}
	cout << endl;
	//反向迭代器的访问方式
	auto vit1 = v.rbegin();
	while (vit1 != v.rend()){
		cout << *vit1 << " ";
		vit1++;
	}
	cout << endl;
//遍历迭代器中内容的时候不能改变其内容const 迭代器的使用
	vector<int>::const_iterator  cvit = v.begin();
	while (cvit != v.end()){
		cout << "const:" << *cvit<<" ";
		cvit++;
	}
	cout << endl;
	//基于范围的for循环,内部调用迭代器的begin和end;
	for (auto &e : v){
		cout << e << " ";
		//e++;//此处的e匹配的是迭代器中的元素
		//若先++后输出的话就改变了迭代器本来要输出的内容
	}
	cout << endl;
	return 0;
}

该程序中利用不同的方式遍历了整个容器，在定义迭代器的时候除了使用auto关键字自动匹配外，还在使用vector定义迭代器。但是定义时要注明类型:其使用方式为 vector<>的形式

#include<iostream>
#include<vector>

using namespace std;
void printVector(vector<int> &v){
	//对于只是简单打印的可以传引用，进而不进行值拷贝
	//若希望不能修改迭代器中的内容，传参数的时候可以传const修饰的参数
	//形如：const vector<int> &v;
	auto vit1 = v.begin();
	while (vit1 != v.end()){
		cout << *vit1 << " ";
		vit1++;
	}
	cout << endl;
}

int main(){
	vector<int> v(10, 1);
	printVector(v);
	//max_size();显示迭代器中可以存放的最多元素数量
	vector<int> v1;
	vector<char> v2;
	vector<double> v3;
	cout << v1.max_size() << endl;  //1G
    //查看指定对象的最大容量
	cout << v2.max_size() << endl;  //4G
	cout << v3.max_size() << endl;  //0.5G
	return 0;
}
2.1:vector 空间增长问题
容量空间接口说明
size()获取数据个数
capacity()获取容量大小
empty()判断是否为空
void resize (size_type n, value_type val = value_type());改变vector的size
void reserve (size_type n);改变vector放入capacity

  • capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。

  • reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问
    题。

  • resize在开空间的同时还会进行初始化，影响size。

#include<iostream>
#include<vector>

using namespace std;


int main(){
  //vector::capacity()的使用
  vector<int> v(10,5);
  cout<<v.capacity()<<endl;
  
  //vector::reserve()的使用
  v.reserve(20);
  cout<<v.capacity()<<endl;
  
  vector<int>::iterator vt=v.begin();
  while(vt!=v.end()){
    cout<<*vt<<" ";
    vt++;
  }
  cout<<endl;

  v.resize(30,1);
  vector<int>::iterator vt1=v.begin();
  while(vt1!=v.end()){
    cout<<*vt1<<" ";
    vt1++;
  }
  cout<<endl;
  return 0;
}
  • 运行结果

在这里插入图片描述

3.vector 增删改查
vector增删查改接口说明
void push_back (const value_type& val);尾插
void pop_back();尾删
InputIterator find (InputIterator first, InputIterator last, const T& val);查找。（注意这个是算法模块实现,不是vector的成员接口）
iterator insert (iterator position, const value_type& val);在position之前插入val
iterator erase (iterator position);删除position位置的数据
void swap (vector& x);交换两个vector的数据空间
reference operator[] (size_type n);像数组一样访问
3.1.push_back() 和 pop_back() 接口的使用
  • push_back和pop_back()
#include<iostream>
#include<vector>

using namespace std;

void printVector(vector<int> &v){
    //打印函数
	auto vit1 = v.begin();
	while (vit1 != v.end()){
		cout << *vit1 << " ";
		vit1++;
	}
	cout << endl;
}

//insert接口的测试
void testVector(){
	vector<int> v;
	//vector容量初始值为0(不存放内容的时候)
	//之后扩容的时候window按照原来容量的1.5倍进行扩容
	//Linux按照原来的2倍进行扩容
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	v.pop_back();
	
	v.insert(v.begin(), 0);  //头插
	v.insert(v.end(), 6);   //尾插
	//函数的参数不再是位置,而是迭代器
	printVector(v);
	v.insert(++v.begin(),10,20);
	//迭代器可以++;首元素的下一个元素
	printVector(v);
}

//扩容的是否会导致迭代器失效
//相当于一个野指针
int main(){
	testVector();
	return 0;
}
3.2.find/insert/erase接口的使用
  • find/insert/erase
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void printVector(vector<int> &v){
    auto vit1 = v.begin();
    while (vit1 != v.end()){
          cout << *vit1 << " ";
              vit1++;
                
    }
      cout << endl;

}

void Print(vector<int> &v){
  auto vit=v.begin();
  while(vit!=v.end()){
    cout<<*vit<<" ";
    vit++;
  }
  cout<<endl;
}
void Testfind() {

  vector<int> v;
  v.push_back(1);
  v.push_back(2);
  v.push_back(3);
  v.push_back(4);
  v.push_back(5);
  Print(v);
  vector<int>::iterator pos=find(v.begin(),v.end(),9);
  //没有找到的时候,返回的是v.end()的位置
  v.insert(pos,6);
  //指定位置插入内容,将后面的内容往后弄
  Print(v);
}

//erase删除位置的迭代器

void testErase(){
  vector<int> v(10, 2);
  v.erase(v.begin());
  printVector(v);
  v.erase(v.begin(), v.end()-3);
  //迭代器可以进行加减运算
  printVector(v);
}

int main(){
  testErase();
  Testfind();
  return 0;
}

若删除的是一个元素(参数是删除位置的迭代器)

iterator erase(iterator pos);

删除的是连续几个元素的话(参数为两个迭代器)

 iterator erase(iterator first,iterator last);

从迭代器first开始删除到迭代器last;

4.迭代器失效

迭代器失效:迭代器指向的位置无效/越界

4.1.insert(iterator it,T x);

插入可能导致增容，会释放原有的空间，开辟新的空间，拷贝原有的内容
插入之前的迭代器位置可能已经被释放，变成类似为野指针的迭代器
调用完insert接口,重新获取迭代器，防止迭代器失效

4.2.调用erase(iterator it);

访问越界,调用完erase接口,获取erase接口的返回值，防止迭代器失效

#include<iostream>
#include<vector>
using  namespace std;
void printVector(vector<int> &v){
  //打印函数
	auto vit1 = v.begin();
	while (vit1 != v.end()){
		cout << *vit1 << " ";
		vit1++;
	}
	cout << endl;
}

void testErase(){
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	auto vit = v.begin();
	while (vit != v.end()){
		if (*vit % 2 == 0)
			vit=v.erase(vit);
//调用完erase接口,获取erase接口的返回值，防止迭代器失效
//若不用vit去接收这个接口返回值的话，释放一次后程序奔溃
//这样赋值的目的是防止迭代器指向的位置是一个无效的位置。
//拿取erase接口的返回值(返回值为迭代器)
		else
			vit++;
	}
	printVector(v);
}
int main(){
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	testErase();
	//auto vit = v1.begin();
	//v1.insert(vit,10);  
	//在插入的时候进行了扩容操作，该过程中重新开辟了空间
	//导致原来的空间失效(迭代器失效),

	auto vit = v1.begin();
	v1.insert(vit, 10);
	vit = v1.begin();
	//调用完insert接口,重新获取迭代器，防止迭代器失效
	*vit = 20; //本质：野指针(指向已经释放的空间)
	v1.push_back(3);
	v1.push_back(4);
	printVector(v1);
	return 0;
}
5.swap函数的使用
全局函数swap和成员函数swap两个函数本质上没有区别
string类中的swap函数

全局函数：swap(s1,s2)–>{s1.swap(s2)}

本质上内部调用的为string的成员函数

成员函数：swap(s2)–>s1.swap(s2);
全局的swap只是对成员的swap函数进行了封装
通用全局变量:swap(T& s1,T& s2)–>{T temp=s1;s1=s2;s2=temp;} 内部进行了拷贝

vector的swap函数

全局函数：swap(s1,s2)–>{s1.swap(s2)}//本质上内部调用的为vector的成员函数
成员函数：swap(s2)–>s1.swap(s2);
全局的swap只是对成员的swap函数进行了封装

#include<iostream>
#include<veector>
using namespace std;

void printVector(const vector<int> &v){
	for (auto& e : v){
		cout << e << " ";
	}
	cout << endl;
}

int main(){
	vector<int> v1(3, 2);
	vector<int> v2(3, 4);
	printVector(v1);
	printVector(v2);
	//全局的交换函数
	swap(v1, v2);
	cout << "全局函数交换后:" << endl;
	printVector(v1);
	printVector(v2);
	//成员函数
	v1.swap(v2);
	cout << "成员函数交换后:" << endl;
	printVector(v1);
	printVector(v2);
	return 0;
}
6.手动释放vector的空间
1.在一个局部域中定义一个空的vector
2.调用vector swap函数，完成空间的交换
3.出了局部域，编译器自动调用局部域中定义的局部变量的析构函数，完成空间的释放{vector < T > tmp; tmp.swap(v);}
#include<iostream>
#include<vector>
using namespace std;
int main(){
	vector<int> v(90, 1);
	cout << v.capacity() << endl;
	//No1:
	{
		vector<int> v1;
		//定义的时候没有初始化,其内部没有内容容量为0
		v1.swap(v);
	}//加了{}不会将v原来的空间释放掉
	//(加了{}会在出作用域的时候调用析构函数释放局部变量v1)
	cout << "No1:"<<v.capacity() << endl;
	//No2:

	vector<int> v1(90, 1);
	cout << v1.capacity() << endl;
	v1.resize(0);//改变v1的有效字符数
	v1.shrink_to_fit(); //释放空间
	cout << "No2:" << v1.capacity() << endl;
	return 0;
}
OJ中的使用

题目要求:查找一个数组中没有重复项的那个数

class Solution {
public:
 int singleNumber(vector<int>& nums) {
 int value = 0;
 for(size_t i =0 ; i < nums.size(); ++i){
 value ^= nums[i];
 }
 return value;
 }
};
//在c++11中

class Solution {
public:
 int singleNumber(vector<int>& nums) {
 int value = 0;
 for(const auto& e:nums){
 value ^= e;
 }
 return value;
 }
};

//迭代器值的交换接口
v1.swap(v2);
vector源码.cpp
11-30
vector源码.cpp，运用c++实现容器vector的编写
MyVector.cpp
03-25
MyVector.cpp
Vector容器
wfea_lff的博客
08-05 482
vector 功能： vector数据结构和数组非常相似，也称为单端数组 vector与普通数组区别： 不同之处在于数组是静态空间，而vector可以动态扩展 vector容器的迭代器是支持随机访问的迭代器 动态扩展： 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间 vector构造函数 功能描述： 创建vector容器 函数原型 vector<T> v; //采用模板实现类实现，默认构造函数 vector(v
C++:Vector
最新发布
2401_88251472的博客
07-16 1326
vector本质是类模板，可以存储任何类型数据。与数组不同的是数组需要声明的时候加上数据类型，而vector是通过·模板参量设定类型的<>中为模板参数，其中class Alloc=allocator<T>是内存池template<class T,//元素类型class Allocator =std::allocator<T>//内存分配器接口说明。
cpp中的vector
m0_74202684的博客
08-10 526
c语言中的顺序表也就是cpp中的vector，但vector用指针的方式存储数据，同时vector中可以同时存储多个自定义类型例如：vector或者vector来书写对象，现在我将带你了解基本的底层实现。
CPP容器-vector
ivalue的博客
09-18 2232
vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.   相关函数 1.push_back 在数组的最后添加一个数据 2.pop_back 去掉数组的最后一个数据 3.at 得到编号位置的数据 4.begin 得到数组头的指针 5.end 得到数组的最后一个单元...
学习cpp：Codecademy | 学习C ++
02-01
在本课程“学习cpp：Codecademy | 学习C ++”中，您将踏上一个探索C++编程语言的旅程。C++是一种强大的、通用的、面向对象的编程语言，广泛应用于系统软件、游戏开发、嵌入式系统、金融服务等领域。Codecademy作为一...
cpp代码-vector相关示例
07-16
在这个“cpp代码-vector相关示例”中，我们可以通过`main.cpp`和`README.txt`两个文件来学习`vector`的使用方法和常见操作。 首先，`main.cpp`文件通常包含了C++程序的主函数`main()`，在这里可能会演示如何声明、...
cpp代码-C++ STL之vector动态数组
07-16
在C++编程中，STL（Standard Template Library，标准模板库）是不可或缺的一部分，它提供了一系列高效、便捷的容器和算法。...通过学习`std::vector`，开发者可以更有效地管理动态数据结构，提高代码的可读性和效率。
c++ cpp学习资料大全
12-03
此外，C++的标准模板库（STL）也是学习的重要组成部分，包括容器（如vector、list、map等）、迭代器、算法和函数对象等。 随着C++的发展，从C++98、C++03、C++11、C++14到C++17甚至计划中的C++20，每个新版本都增加...
[cpp] Vector
happily code
08-12 424
vector是一种类模板，它表示对象的集合。
【cpp】Vector
weixin_34075551的博客
12-13 103
这vector 很有用 // compile with: /EHsc #include <vector> #include <iostream> int main() { using namespace std; vector<int> v1, v2, v3; ...
cpp的vector类
2401_84018574的博客
10-26 1357
本篇将讲述类中的各种重要和常用函数（begin（）、end（）、rbegin（）、rend（）cbegin（）、cend（） 、crbegin（）、crend（）、size()、resize（）、capacity（）、reserve（）、empty（）、push_back （）、pop_back（）、insert()、erase（）、clear()。
cpp vector
qq_50726065的博客
05-03 1359
vector 动态空间，内部机制会自动扩充空间 维护一个线性、连续的内存空间 vector的数据结构：三个指针[iteratorHead, iteratorElementTail, iteratorTail] iteratorHead 指向当前空间的首地址 iteratorElementTail 指向当前空间最后一个元素的地址 iteratorTail 指向当前空间的结束地址 如，vector = {1,2,3,4,5,6} 如果先开辟4个空间那么第二次double开辟了8空间 因而 itera
Cpp_Vector 类
Mr_hutao_T的博客
06-09 518
C++ vector 类的简单说明
Cpp::STL—vector类的使用与理解(上)(10)
tan180°的博客
10-03 1816
结束了第一关string后，我们将来学习一下vector应该说有了string的经验后，vector设计得就不那么冗余，但是仍有很多有趣的东西值得我们学习来试试吧！vector文档介绍vector是表示可变大小数组的序列容器，底层是动态开辟顺序表就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理当vector需要重新分配大小时，其做法是，
cpp 容器vector
weixin_46104490的博客
08-21 364
vector优秀的cpp stl容器！ 1.vector特性： 动态数组 顺序序列 2.vector功能函数 .size() number of elements .push_back() insert element in the end .pop_back() delete element in the end swap() swap two elements reverse() in a partition vector<int> nums; //增 nums.pu
【cpp---＞vector】
kk1125778230的博客
06-05 1044
/默认构造一个容器为空的对象，没有元素 vector < int > v1;//用n个元素构造一个对象，val默认为T() vector < int > v2(3);//用任意类型的迭代器区间构造一个对象 string s("hello world");//拷贝构造 vector < char > v5(v4);return 0;
C++中的vector
CurryCoder的个人博客
04-10 584
1.Cpp中的vector(可变长的动态数组) vector是顺序容器的一种。vector是可变长的动态数组，支持随机访问迭代器，所有STL算法都能对vector进行操作。要使用vector，需要包含头文件vector。在vector容器中，根据下标随机访问某个元素的时间是常数，在尾部添加一个元素的时间大多数情况下也是常数，总体来说速度很快。在中间插入或删除元素时，因为要移动多个元素，因此速度较...
cpp函数，返回vector
04-03
<think>好的，用户想了解如何在C++中让函数返回一个vector，并且需要示例。首先，我需要回忆C++中关于函数返回vector的知识。记得在C++11之后，返回值优化（RVO）和移动语义使得返回大对象如vector更高效，不用担心性能问题。 接下来，我需要提供一个基础的示例。比如定义一个返回std::vector<int>的函数，里面填充一些元素然后返回。这样用户能直观看到结构。同时要强调直接返回局部vector是可行的，编译器会优化，避免不必要的拷贝。 然后，可能需要展示不同类型的vector，比如返回vector<string>或者vector<double>的情况，这样用户知道可以灵活应用。此外，用户提供的引用[1]中提到返回std::vector<std::tuple>的例子，这也是一个很好的扩展点，可以补充说明如何返回包含复杂数据结构的vector，比如tuple，这样用户了解更复杂的用法。 还要注意用户提到的引用内容，引用[1]中的函数返回vector<tuple>，引用[2]讲的是复制vector的方法，引用[3]关于传递vector到函数。虽然用户的问题是返回vector，但可能需要关联相关知识，比如返回时是否涉及拷贝，这时候可以提到移动语义和编译器优化，减少用户的顾虑。 另外，用户可能需要知道如何访问返回的vector，比如遍历元素，所以示例中应包括调用函数并遍历输出的部分。例如使用范围for循环或者迭代器来访问元素，特别是当vector中包含tuple时，如何解包tuple的各个成员。 还需要注意代码格式的正确性，确保使用```cpp来包裹代码块，语法正确。同时，按照用户的系统级指令，行内公式用$...$，但这里可能不太涉及数学公式，主要关注代码示例。 最后，生成相关问题，比如如何高效返回大vector、修改返回的vector、处理多维vector等，这些能帮助用户进一步探索相关主题。 总结步骤： 1. 给出基础示例，返回int的vector。 2. 展示不同类型的vector返回，如string和double。 3. 引入复杂结构，如vector<tuple>的返回，参考引用[1]。 4. 解释编译器优化，如RVO和移动语义，引用[2]中的复制方法可能相关。 5. 提供调用函数和遍历输出的代码。 6. 生成相关问题，引导深入学习。</think>在C++中返回`std::vector`的函数可以通过直接返回局部变量实现，编译器会通过返回值优化（RVO）避免不必要的拷贝。以下是具体实现方法和示例： ### 基础示例：返回整型vector ```cpp #include <vector> std::vector<int> getIntVector() { std::vector<int> vec = {10, 20, 30, 40}; return vec; // 编译器自动优化，避免拷贝 } int main() { std::vector<int> result = getIntVector(); // 遍历输出：10 20 30 40 } ``` ### 返回复合数据类型 #### 1. 字符串vector示例 ```cpp #include <vector> #include <string> std::vector<std::string> getStringVector() { return {"Apple", "Banana", "Cherry"}; // 直接返回初始化列表 } ``` #### 2. 元组vector示例（引用自[^1]） ```cpp #include <vector> #include <tuple> #include <string> std::vector<std::tuple<int, double, std::string>> queryData() { return { {1, 9.8, "Motion"}, {2, 3.14, "Circle"} }; } // 调用示例 auto data = queryData(); for (const auto& item : data) { int id = std::get<0>(item); double value = std::get<1>(item); std::string label = std::get<2>(item); } ``` ### 性能说明 现代C++编译器支持以下优化： 1. **RVO（返回值优化）**：直接构造返回值到目标内存 2. **移动语义**：C++11后`std::vector`支持移动构造，时间复杂度$O(1)$ 3. 避免深拷贝：与数组不同，vector返回仅复制控制信息（指针+容量大小）[^2] ### 高级用法 #### 返回多维vector ```cpp std::vector<std::vector<double>> getMatrix() { return { {1.1, 2.2}, {3.3, 4.4} }; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值