C++之标准模板库STL

最新推荐文章于 2024-08-20 07:15:00 发布
最新推荐文章于 2024-08-20 07:15:00 发布
阅读量159 收藏
点赞数
分类专栏： c++ 函数 文章标签： STL 标准模板库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43643506/article/details/88398706
版权
函数 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
c++
7 篇文章 0 订阅
订阅专栏

STL概述：可分为容器，迭代器，空间配置器，适配器，算法，仿函数六大组件。
容器：允许我们重复使用利用已有的实现构造自己的特定类型数据结构。通过设置一些模板类，STL容器对最常用的数据结构提供了支持，这些模板参数允许我们的指定的容器中元素的数据类型，可以将工作简化。
容器中部分头文件有：,,,,,,等组成。
vector：向量。 连续存储的元素。
list：列表。 由结点组成的双向链表，每个结点包含一个元素
deque：双队列。 由连续存储的指向不同元素的指针组成的数组
set：集合 由节点组成的红黑树，每个结点都包含一个元素，结点之间以某种作用于元素对的位于排列。
multiset：多重集合 允许存在两个次序相等的元素集合。
stack：栈 后进先出的值的排列
queue：队列。 先进先出的值的排列
priority_queue：优先队列 。 元素次序是作用于所存储的值对上的某种谓语决定的队列
map：映射 由对组成的集合，以某种作用于键对上的谓语排列。
multimap：多重映射。 允许键对有相同的次序映射。

常用的容器：
string：封装了char*
string类的构造函数：
string（）； //默认构造参数
string（const string &str）； //默认拷贝构造函数
string（const char *s）； //使用字符串s初始化
string（int n，char c）； //用n个字符串初始化

string类的遍历：
const char &operator[ ]（int n） const；
const char &at（int n）const；
char &operator[ ]（int n）；
char &at（int n）；
容器类型： ：iterator it；
每个类型容器都会提供begin()和end()来获取一个迭代器。有点类似于指针。
（1）begin（）函数获取的是一个指向容器第一个元素的迭代器
（2）end（）函数获取的是一个指向容器的最后一个元素的迭代器。

string类的查找与替换：
int find（char c，int pos=0） const； //从pos查找字符c在当前字符串的位置
string &replace （int p0，int n0，const char *s，int n）；删除p0开始的的n0个字符，然后在p0处插入字符串s的前几个字符。

string类的插入和删除
string &insert（int p0，const char *s）； //在p0处插入字符串s
string &insert（int p0，const string &s）； //在p0处插入字符串s

iterator erase（iterator first，iterator last） //删除[ first,last)之间的所有字符，返回删除后迭代器的位置
iterator erase（iterator it）； //删除it指向的字符，返回删除后迭代器的位置

#include
#include
#include
#include
#include

using namespace std;

void string_init()
{
string s1; //无参构造函数
string s2(“helloworld”);
string s3(10, ‘a’);
string s4(s3);

cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
cout << s4 << endl;

}

void string_at()
{
string s1(“helloworld”);

//cout << s1[50000000] << endl;  //不安全
try
{
	cout << s1.at(10) << endl;   //运行出错会抛出异常
}
catch(exception &e)
{
	cout << "at 异常" << endl;
	cout << e.what() << endl;
}

}

void string_str()
{
string s(“helloworld”);
const char *ptr = s.c_str();
cout << ptr << endl;
}

void string_copy()
{
string s(“hellworld”);
char buf[32] = {0};
//s.copy(buf, 5, 3);
s.copy(buf, 5);
cout << buf << endl;
}

void string_length()
{
string s(“helloworld”);
cout << s.length() << endl;

if (s.empty())
{
	cout << "empty" << endl;
}
else
{
	cout << "not empty" << endl;
}

}

void string_assign()
{
string s1(“helloworld”);
string s2(“12345”);
string s3;

s3 = s2;
cout << s3 << endl;

s1.assign(s2);
cout << s1 << endl;

s1.assign(10, 'a');
cout << s1 << endl;

s1.assign("1234567890", 7);
cout << s1 << endl;

s1.assign(s2, 1, 3);
cout << s1 << endl;

}

void string_compare()
{
string s(“helloworld”);
string s2(“helloaaaaa”);

if (s.compare(s2) > 0)
{
	cout << "s > s2" << endl;
}
else
{
	cout << "s <= s2" << endl;
}

if (s.compare("aaaaa") > 0)
{
	cout << "s > aaaaa" << endl;
}
else
{
	cout << "s <= aaaaa" << endl;
}

}

void string_substr()
{
string s1(“helloworld”);
string s2;

s2 = s1.substr();
cout << s2 << endl;

s2 = s1.substr(4, 3);
cout << s2 << endl;

}

void string_find()
{
string s1(“helloworld”);
string s2(“owo”);
//int index = s1.find(‘o’);
//int index = s1.find(‘o’, 5);
int index = s1.find(‘o’, 7);
cout << index << endl;

index = s1.find("world", 1);
cout << index << endl;
index = s1.find(s2, 0);
cout << index << endl;

index = s1.rfind('l', 6);
cout << index << endl;

s1.replace(0, 5, "xx");
cout << s1 << endl;

string s3("helloworldhelloworldhelloworldhelloworld");
index = s3.find("hello");
while (index != -1)
{
	s3.replace(index, strlen("hello"), "xx");
	index = s3.find("hello", index + strlen("xx"));
}
cout << s3 << endl;

}

void string_insert()
{
string s1(“helloworld”);
string s2(“abcd”);

s1.insert(1, "aaa");
cout << s1 << endl;

s1.insert(5, s2);
cout << s1 << endl;

s1.insert(1, 10, 'x');
cout << s1 << endl;

s1.erase(1, 20);
cout << s1 << endl;

}

void string_transform()
{
string s1(“aaaaaBBBBBB”);
transform(s1.begin(), s1.end(), s1.begin(), ::toupper);
cout << s1 << endl;
}

int main()
{
//string_init();
//string_at();
//string_str();
//string_copy();
//string_length();
//string_assign();
//string_compare();
//string_substr();
//string_find();
//string_insert();
string_transform();
return 0;
}

vector容器
：将元素置于一个动态数组中加以管理的容器，可以随机存取元素，支持[ ]操作符，或者at（）方法直接存取。
vector的初始化
vector c 产生空的vector
vector c1（c2）产生同类型的c1，并复制c2所有元素
vector c（n）利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector
~vector （）销毁所有元素并释放内存

vector的非变动性操作
c.size()； 返回元素个数
c.empty(); 判断容器是否为空
c.reserve(n) 扩大容量为n

vector容器的赋值
c1 =c2； 将c2的全部元素赋给c1；
c.assign（n，e）将元素e的n个拷贝赋值给c
c1.swap（c2）将c1和c2的值交换

at（idx） 返回索引idx所标记元素的引用，进行越界检查
front（）返回第一个元素的引用，不检查元素是否存在
back（）返回最后一个元素的引用，不检查元素是否存在。

vector的插入与删除
c.insert（pos，e） 在pos位置插入元素e的副本，并返回新元素位置。
c.push_back(e) 在尾部添加一个元素e的副本
c.pop_back() 移除最后一个元素但不返回最后一个元素
c.erase(pos) 删除pos位置的元素，返回下一个元素的位置
c.clear（） 移除所有元素，清空容器
c.resize（num） 将元素数量改为num

代码如下：
#include
#include

using namespace std;

int main()
{
int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
vector v1;
vector v2(10, 10);
vector v3(a, a + 10);

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

for (int i = 0; i < v3.size(); i++)
{
	cout << v3.at(i) << " ";
}
cout << endl;

v1.resize(10);
for (int i = 0; i < v2.size(); i++)
{
	v1[i] = v2[i];
}

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

cout << v1.front() << endl;
cout << v1.back() << endl;

v1.front() = 100;
v1.back() = 100;
for (int i = 0; i < v1.size(); i++)
{
	cout << v1[i] << " ";
}
cout << endl;

v1.assign(a, a + 10);
for (int i = 0; i < v1.size(); i++)
{
	cout << v1[i] << " ";
}
cout << endl;

v1.assign(20, 1);
for (int i = 0; i < v1.size(); i++)
{
	cout << v1[i] << " ";
}
cout << endl;

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

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

//使用迭代器遍历数组  正向迭代器
//begin()指向vector的第一个元素 end()指向vector最后一个元素的后一个位置
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

//反向迭代器
for (vector<int>::reverse_iterator rit = v3.rbegin(); rit != v3.rend(); rit++)
{
	(*rit)++;
	cout << *rit << " ";
}
cout << endl;

//只读迭代器
for (vector<int>::const_iterator cit = v3.begin(); cit != v3.end(); cit++)
{
	//(*cit)++;
	cout << *cit << " ";
}
cout << endl;

v3.insert(v3.begin(), 100);
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

v3.insert(v3.begin(), 10, 20);
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

v3.insert(v3.end(), a, a + 10);
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

v3.erase(v3.begin());
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

v3.erase(v3.begin(), v3.begin() + 5);
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

v3.clear();
for (vector<int>::iterator it = v3.begin(); it != v3.end(); it++)
{
	cout << *it << " ";
}
cout << endl;

return 0;

}

deque容器
：双端数组，也是可以随机存取元素，支持索引值直接存取，可用[ ]操作符和at（）方法。

deque容器的构造拷贝和析构
deque c 产生空的deque
deque c1（c2） 产生同类型的c1，并复制c2的所有元素
deque c（n）利用类型T的默认构造参数和拷贝构造参数生成一个大小为n的deque
~deque （） 销毁所有元素并释放内存

deque的非变动性操作：
c.size()； 返回元素个数
c.empty(); 判断容器是否为空

deque的赋值操作
c1 =c2； 将c2的全部元素赋给c1；
c.assign（n，e）将元素e的n个拷贝赋值给c
c1.swap（c2）将c1和c2的值交换

deque的元素存取：
at（idx） 返回索引idx所标记元素的引用，进行越界检查
front（）返回第一个元素的引用，不检查元素是否存在
back（）返回最后一个元素的引用，不检查元素是否存在。

deque的插入与删除元素：
c.insert（pos，e） 在pos位置插入元素e的副本，并返回新元素位置。
c.push_back(e) 在尾部添加一个元素e的副本
c.pop_(front) 移除第一个元素但不返回最后一个元素
c.erase(pos) 删除pos位置的元素，返回下一个元素的位置
c.clear（） 移除所有元素，清空容器
c.resize（num） 将元素数量改为num

代码如下：
#include
#include

using namespace std;

int main()
{
char ptr[] = “helloworld”;

deque<char> d1;
deque<char> d2(10, 'x');
deque<char> d3(ptr, ptr + strlen(ptr));

for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;

for (deque<char>::iterator it = d3.begin(); it != d3.end(); it++)
{
	cout << *it;
}
cout << endl;

d2.push_back('y');
d2.push_front('y');
for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;

d2.pop_back();
d2.pop_front();
for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;

cout << d3[1] << endl;
cout << d3.at(2) << endl;

d2.insert(d2.begin(), 'Y');
d2.insert(d2.end(), 2, 'Y');
for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;

d2.insert(d2.begin(), ptr, ptr + strlen(ptr));
for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;

deque<char>::iterator it;
it = d2.erase(d2.begin());
for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;
cout << *it << endl;
it = d2.begin();
cout << *it << endl;

it = d2.erase(d2.end() - 5, d2.end());
for (deque<char>::iterator it = d2.begin(); it != d2.end(); it++)
{
	cout << *it;
}
cout << endl;


return 0;

}

list容器：
是一个双向链表容器。可以有效的进行插入删除元素。但是不可以随机存取元素，所以不支持at（pos）函数和[ ]操作符
也不支持迭代器的随机访问

list容器的构造拷贝和析构
list c 产生空的deque
list c1（c2） 产生同类型的c1，并复制c2的所有元素
list c（n）利用类型T的默认构造参数和拷贝构造参数生成一个大小为n的deque
~list （） 销毁所有元素并释放内存

list的非变动性操作：
c.size()； 返回元素个数
c.empty(); 判断容器是否为空

list的非赋值操作
c1 =c2； 将c2的全部元素赋给c1；
c.assign（n，e）将元素e的n个拷贝赋值给c
c1.swap（c2）将c1和c2的值交换

list的元素存取：
at（idx） 返回索引idx所标记元素的引用，进行越界检查
front（）返回第一个元素的引用，不检查元素是否存在
back（）返回最后一个元素的引用，不检查元素是否存在。

list的插入与删除元素：
c.insert（pos，e） 在pos位置插入元素e的副本，并返回新元素位置。
c.push_back(e) 在尾部添加一个元素e的副本
c.pop_(front) 移除第一个元素但不返回最后一个元素
c.erase(pos) 删除pos位置的元素，返回下一个元素的位置
c.clear（） 移除所有元素，清空容器
c.resize（num） 将元素数量改为num

#include
#include

using namespace std;

class Person
{
private:
static int num;
int id;
string name;
string tel;
int age;
public:
Person(string n, string t, int a);
void showinfo() const;
};

int Person::num = 0;

Person::Person(string n, string t, int a)
{
num++;
id = num;
name = n;
tel = t;
age = a;
}

void Person::showinfo() const
{
cout << id << " " << name << " " << tel << " " << age << endl;
}

int main()
{
list l;

Person p1("aaaa", "111111", 20);
Person p2("bbbb", "222222", 20);
Person p3("cccc", "333333", 20);
Person p4("dddd", "444444", 20);
Person p5("eeee", "555555", 20);
Person p6("ffff", "666666", 20);

l.push_back(p1);
l.push_back(p2);
l.push_front(p3);
l.push_front(p4);
l.insert(l.begin(), p5);
l.insert(++l.begin(), p6);

for (list<Person>::iterator it = l.begin(); it != l.end(); it++)
{
	it->showinfo();
}

l.reverse();
for (list<Person>::iterator it = l.begin(); it != l.end(); it++)
{
	it->showinfo();
}

return 0;

}

map容器：
标准的关联式容器，一个map就是一个键值对序列即（key，value）对，提供了基于key的快速检索能力
map容器的构造拷贝和析构
map c 产生空的deque
map c1（c2） 产生同类型的c1，并复制c2的所有元素
~map （） 销毁所有元素并释放内存

map的非变动性操作：
c.size()； 返回元素个数
c.empty(); 判断容器是否为空

map的赋值操作
c1 =c2； 将c2的全部元素赋给c1；
c1.swap（c2）将c1和c2的值交换

map的插入，数据查找与删除元素：
map <int ,string> m,
count(key) //返回值等于key的元素个数
find（key） 返回值等于key的第一个元素，找不到返回end
upper_bound(key) 返回值大于key的第一个元素
equal_bound(key) 返回值等于key的元素区间

c.erase(beg，end) 删除[beg，end]内的元素，无返回值
c.clear（） 移除所有元素，清空容器

stack（栈）的部分代码
#include
#include

using namespace std;

int main()
{
stack s;

for (int i = 0; i < 10; i++)
{
	s.push(i + 1);
}

cout << s.top() << endl;

while (!s.empty())
{
	cout << s.top() << " ";
	s.pop();
}
cout << endl;

return 0;

}

queue（队列）的部分代码：
#include
#include

using namespace std;

int main()
{
queue q;

for (int i = 0; i < 10; i++)
{
	q.push(i + 1);
}

cout << q.front() << endl;
cout << q.back() << endl;

while (!q.empty())
{
	cout << q.front() << " ";
	q.pop();
}
cout << endl;

return 0;

}

如沐与清风
关注
专栏目录
C++ STL 标准模板库介绍与入门
dvlinker的技术专栏
05-14 2万+
C++ STL 标准模板库概述与入门
C++ STL标准模板库-优秀的C++标准库
06-10
STL是Standard Template Library的简称，中文名标准模板库，是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室开发的 ，是一个具有工业强度的，高效的C++库，STL早已是ANSI/ISO C++标准中的一部分。STL...
void display( ) const 中的const是什么意思？
pursue的专栏
02-26 5378
问题：c++：void display( ) const 中的const是什么意思？ 简答： 意思是除了表明了mutable的成员变量以外 该类的其他的成员变量在这个函数内一律不能修改。 详细： 加const表明，该函数只能是只读的，不能修改私有变量的值。加强安全性。 给隐含的this指针加const，表示这个this指向的东西是const的，也就是说这个函数中无法改动数据成员了。
void show()const;
wtml
10-29 2823
第一个const 调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const Time& t，则不能对传递进来的引用对象进行改变，保护了原对象的属性。 第二个const 类成员函数中const的使用 如果一个成员函数的不会修改数据成员，那么最好将其声明为const，因为const成员函数中不允许对数据成员进行修改，如果修改，编译器
C++ const成员函数——学习笔记
襟铭心缘的博客
03-01 185
//Student.h #pragma once class Student { int number; double score; public: Student(); Student(int num, double grade) : number(num), score(grade) {} ~Student(); double Score() const { return sc...
量化交易之C++篇 - const 修饰成员函数（常函数）
04-18 101
#include <iostream> using namespace std; class Person { public: Person(int a, int b) { this->a = a; this->b = b; } void showInfo() const { // 常函数 //this->a++; 报错: 因为没有被mutable 修饰； cout << "this->a: " << this-&g.
C++ 标准模板库STL
热门推荐
kyle的博客
06-11 2万+
C++ STL标准模板库详解
C++：标准模板库（STL）介绍
2301_79959126的博客
07-28 763
本文介绍了C++中标准模板库（STL）的概念，解释了什么是STL中的容器，什么是STL中的迭代器，并介绍了STL中包含的几种常用的容器及对应的迭代器。
【C++】标准模板库（STL）
weixin_53235104的博客
05-06 5866
标准模板库 STL（Standard Template Library），是 C++ 标准库的一部分，不需要单独安装，只需要 #include 头文件。STL 的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL 变得非常通用。例如，由于 STL 的 sort() 函数是完全通用的，你可以用它来操作几乎任何数据集合，包括链表、容器和数组；STL 的另一个重要特性是它不是面向对象的。STL 主要依赖于模板而不是封装、继承和虚函数（多态性）—— OOP的三个要素。
【C++】STL 标准模板库 ① ( STL 简介 | STL 基本概念 | STL 主要内容 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-08 1986
一、STL 简介 1、STL 概念 2、STL 主要内容 二、STL 代码示例
深入理解 C++ 的标准模板库（STL）
最新发布
windowshht的博客
08-20 893
STL 是 C++ 标准库的一部分，提供了一系列模板类和函数，用于实现常见的数据结构（如向量、列表、集合等）和算法（如排序、查找等）。STL 的设计理念是通过模板实现通用性，使得同一套代码可以处理不同类型的数据。STL 的核心优势在于其高效性和灵活性。通过使用 STL，程序员可以减少代码的重复性，提高代码的可读性和可维护性。C++ 的标准模板库（STL）是一个强大而灵活的工具，提供了丰富的数据结构和算法，使得程序员能够高效地解决各种问题。
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
在C++编程中，标准模板库（Standard Template Library，简称STL）是一个极其重要的组成部分，...通过阅读《C++语言 - 标准模板库STL》.txt这份文档，你将能够更深入地了解STL的各个组件，以及它们在实际编程中的应用。
C++_标准模板库(STL) pdf 高清版
04-27
C++标准模板库（STL）是C++编程语言中不可或缺的一部分，它为开发者提供了大量高效、可重用的容器、算法和迭代器。STL的主要目标是提高代码的效率和可读性，通过使用泛型编程（也称为模板编程）来实现。以下是关于...
系统编程之数据库
qq_43643506的博客
01-18 3188
数据查询：SELECT 数据操纵：INSERT、UPDATE、DELETE 数据控制：GRANT、REVOKE、DENY – 创建表 create table if not exists student (id integer, name text, tel text); – 查看表 .tables – 查看表结构 .schema student – 修改表 alter table student...
系统编程学习
qq_43643506的博客
01-12 859
学习内容：系统编程 man操作指令； 了解系统编程的基本概念；知道了系统调用的概念；以及内核空间和用户空间；知道什么叫标准输入，标准输出，标准错误处理的概念。在系统中一般用perror打印比如 if（fd ==-1） { perror（“creat”）; exit(1); }表示输出错误。 关于open:open的函数中含有两个参数的一般表示，打开这个文件，并且文件存在； open函数中有三个参...
C++函数模板和类模板
qq_43643506的博客
03-03 371
函数模板：实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就是函数模板。 C++提供两种模板机制：函数模板，类模板。 函数模板定义形式： template &lt;类型形式参数表&gt; 类型形式参数形式如：typename T1,typename T2,… 函数模板的概念： 部分代码： #include using n...
系统编程学习第二天
qq_43643506的博客
01-13 202
进程控制编程 概念：是进行活动，资源分配的最小单元。与程序的区别：程序是放在磁盘中的可执行文件，进程包括程序，数据，进程控制块。 ps -elf表示打开进程查找。 pid ：进程名 ppid：父进程； 1一般表示祖先进程。一般删不了。ctrl+z表示切到后台。fg：后台切到前台。，命令在前台运行。ps -clf | grep +关键字 是表示查找当前关键字里的进程。 shift+zz...
C++之标准模板库STL续（容器，算法）
qq_43643506的博客
03-13 193
优先队列：priority_queue 实现的头文件 代码如下; #include #include #include using namespace std; int main() { //priority_queue&lt;int, vector &gt; p1; //等价于 默认从大到小排序 //priority_queue&lt;int, vector, less &gt; p...
C++标准模板库STL详解
"C++ PPT第9章 标准模板库STL.ppt" C++标准模板库（STL）是C++编程中一个至关重要的组成部分，它提供了一组高效且可重用的模板类和函数，使得程序员可以便捷地处理数据结构和算法。STL的出现极大地提升了C++的编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值