Cpp标准库之 std::regex 类的使用

最新推荐文章于 2024-05-13 04:51:40 发布
最新推荐文章于 2024-05-13 04:51:40 发布
阅读量3.9w 收藏 116
点赞数 25
分类专栏： C++ STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l357630798/article/details/78235307
版权

一、简介：

        本文主要是大致的介绍如何使用 C++ 标准库中 std::regex 相关类库，用来打发下无聊的时间。

        在使用 C++ 标准库正则表达式之前，肯定是要先学习正则表达式语法的，不解释。

        要学习正则表达式语法，你百度一下，可以百度一把大。但是，我个人觉得写的最经典的莫过于这篇文章了 正则表达式30分钟入门教程 ，感谢这篇文章作者 30 秒。我觉得只需要读懂这篇文章的 80%，你将感受到正则表达式处理字符串那毁天灭地的威力。


二、常用 C++ 标准库正则表达式类：

        C++ 标准库中常用正则表达式类主要包含如下 5 组：


        有了以上 5 组模板，基本上可以处理所有的字符串处理需求了。


三、C++ 正则表达式模板的使用：

        std::regex_match: 正则表达式需要匹配整个字符串序列，也就是说正则表达式要与字符串完全匹配。因此，它是单次匹配，否则匹配失败。

        范例代码如下：

void match()
{
	/
	//std::regex_match
	//std::regex_match: 正则表达式需要匹配整个字符串序列, 也就是说正则表达式要与
	//字符串完全匹配, 因此, 它是单次匹配, 否则匹配失败. 
	//此外, 它还可以获取子匹配的组

	std::string text = "Date:2017-10-10";

	//构造正则表达式
	//这里 "()" 用于捕获组, 捕获组的编号是按照 "(" 出现的顺序, 从左到右, 从1开始进行编号的 
	std::string pattern = "Date.(\\d{4})-(\\d{2}-(\\d{2}))";
	std::regex express(pattern);

	//匹配
	std::cout.setf(std::ios_base::boolalpha);
	/*模板函数1-1*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果
	//这里使用的是 std::string::iterator 迭代器, 与 begin()/ end() 返回的迭代器类型(std::string::iterator)要一致
	std::match_results<std::string::iterator> results1;
	if(std::regex_match(text.begin(), text.end(), results1, express))
	{
		std::match_results<std::string::iterator>::const_iterator iter;
		for (iter = results1.begin(); iter != results1.end(); iter++)
		{
			std::cout << iter->length() << ": " << iter->str() << std::endl;
		}
	}
	/*输出
	15: Date:2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/

	/*模板函数1-2*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果
	//std::smatch == std::match_results<std::string::const_iterator>
	std::smatch s_results1;
	if(std::regex_match(text.cbegin(), text.cend(), s_results1, express))
	{
		std::match_results<std::string::const_iterator>::const_iterator iter;
		for (iter = s_results1.begin(); iter != s_results1.end(); iter++)
		{
			std::cout << iter->length() << ": " << iter->str() << std::endl;
		}
	}
	/*输出
	15: Date:2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/

	/*模板函数2*/
	//显示字符串是否符合正则表达式, 用于检测字符串规则
	std::cout << std::regex_match(text.begin(), text.end(), express) << std::endl;

	/*模板函数3*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果
	//std::cmatch == std::match_results<const char*>
	std::cmatch c_results3;
	if(std::regex_match(text.c_str(), c_results3, express))
	{
		for (auto iter = c_results3.begin(); iter != c_results3.end(); iter++)
		{
			std::cout << iter->length() << ": " << iter->str() << std::endl;
		}
	}
	/*输出
	15: Date:2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/

	/*模板函数4*/
	//显示字符串是否符合正则表达式, 用于检测字符串规则
	std::cout << std::regex_match(text.c_str(), express) << std::endl;

	/*模板函数5*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果
	std::match_results<std::string::const_iterator> s_results5;
	if(std::regex_match(text, s_results5, express))
	{
		for (size_t index = 0; index < s_results5.size(); index++)
		{
			//sub_match: 子匹配, match_results里面都存放的是sub_match
			//sub_match 可以理解为 std::pair 的扩展, 它继承了 std::pair,
			//其中 first 实际上存放的是获取的字符串头指针地址, second 为尾指针地址
			std::ssub_match sub = s_results5[index];
			std::cout << sub.length() << ": " << sub.str() << std::endl;
		}
	}
	/*输出
	15: Date:2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/

	/*模板函数6*/
	//显示字符串是否符合正则表达式, 用于检测字符串规则
	std::cout << std::regex_match(text, express) << std::endl;
	/
}

        std::regex_search: 搜素正则表达式参数，但它不要求整个字符序列完全匹配。而且它只进行单次搜索，搜索到即停止继续搜索，不进行重复多次搜索。

        范例代码如下：

void search()
{
	/
	//std::regex_search
	//std::regex_search: 搜素正则表达式参数, 但它不要求整个字符序列完全匹配. 
	//而且它只进行单次搜索, 搜索到即停止继续搜索, 不进行重复多次搜索.

	std::string text = "Date:2017-10-10 ~ 2017-10-15";

	//构造正则表达式
	//这里 "()" 用于捕获组, 捕获组的编号是按照 "(" 出现的顺序, 从左到右, 从1开始进行编号的
	std::string pattern = "(\\d{4})-(\\d{2}-(\\d{2}))";
	std::regex express(pattern);

	//匹配
	std::cout.setf(std::ios_base::boolalpha);

	/*模板函数1*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果, 它不进行重复多次搜索
	std::match_results<std::string::iterator> results1;
	if(std::regex_search(text.begin(), text.end(), results1, express))
	{
		//使用迭代器遍历, 这里的迭代器实际上是指向 std::sub_match 的指针
		std::match_results<std::string::iterator>::const_iterator iter;
		for (iter = results1.begin(); iter != results1.end(); iter++)
		{
			std::cout << iter->length() << ": " << iter->str() << std::endl;
		}
	}
	/*输出
	10: 2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/
	
	/*模板函数2*/
	//显示是否有搜索到符合正则表达式的结果
	std::cout << std::regex_search(text.begin(), text.end(), express) << std::endl;

	/*模板函数3*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果, 它不进行重复多次搜索
	std::cmatch c_results3;
	if(std::regex_search(text.c_str(), c_results3, express))
	{
		for (size_t index = 0; index < c_results3.size(); index++)
		{
			//获取组里面的数据, 注意: 这里使用的是 std::csub_match, 
			//实际上存放在 std::match_results 里面的数据就是一组 std::sub_match
			std::csub_match sub = c_results3[index];

			//先获取长度, 再获取内容
			std::cout << sub.length() << ": " << sub.str() << std::endl; 
		}
	}
	/*输出
	10: 2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/

	/*模板函数4*/
	//显示是否有搜索到符合正则表达式的结果
	std::cout << std::regex_search(text.c_str(), express) << std::endl;

	/*模板函数5*/
	//第0组一般是整个正则表达式匹配结果, 其他依次是捕获组的结果, 它不进行重复多次搜索
	std::smatch s_results5;
	if (std::regex_search(text, s_results5, express))
	{
		for (auto iter = s_results5.begin(); iter != s_results5.end(); iter++)
		{
			std::cout << iter->length() << ": " << iter->str() << std::endl;
		}
	}
	/*输出
	10: 2017-10-10
	4: 2017
	5: 10-10
	2: 10
	*/

	/*模板函数6*/
	//显示是否有搜索到符合正则表达式的结果
	std::cout << std::regex_search(text, express) << std::endl;
}

        std::regex_replace: 多次搜索整个正则表达式(不考虑捕获组)，然后替换正则表达式匹配到的结果。

        范例代码如下：

void replace()
{
	/
	//std::regex_replace
	//std::regex_replace: 

	std::string text = "Date:2017-10-10 ~ 2017-10-15";

	//构造正则表达式
	//这里 "()" 用于捕获组, 捕获组的编号是按照 "(" 出现的顺序, 从左到右, 从1开始进行编号的 
	std::string pattern = "(\\d{4})-(\\d{2}-(\\d{2}))";
	std::regex express(pattern);

	//定义存储结果变量已经替换字符
	std::string result(256, '0');
	std::string substitutes = "2017-10-12";

	/*模板函数1*/
	//多次搜索整个正则表达式(不考虑捕获组), 然后替换正则表达式匹配到的结果 
	//std::regex_replace 模板函数返回值实际上是新的字符串存入变量后尾部的指针位置, 置 0 是为了防止变量数据出错或乱码
	*std::regex_replace(result.begin(), text.begin(), text.end(), express, substitutes) = '\0';
	std::cout << result.c_str() << std::endl;
	/*输出:
	Date:2017-10-12 ~ 2017-10-12
	*/
	
	result.clear();
	result.resize(256, '0');

	/*模板函数2*/
	//多次搜索整个正则表达式(不考虑捕获组), 然后替换正则表达式匹配到的结果 
	//std::regex_replace 模板函数返回值实际上是新的字符串存入变量后尾部的指针位置, 置 0 是为了防止变量数据出错或乱码
	result = std::regex_replace(text, express, substitutes);
	std::cout << result.c_str() << std::endl;
	/*输出:
	Date:2017-10-12 ~ 2017-10-12
	*/
}

        std::regex_iterator: 用于多次重复匹配，不分组，只进行多次匹配整个正则表达式，可获取整个正则表达式的结果。

        范例代码如下：

void iterator()
{
	/
	//std::regex_iterator
	//std::regex_iterator: 用于多次重复匹配, 不分组, 只进行多次匹配整个正则表达式,
	//可获取整个正则表达式的结果

	std::string text = "Date:2017-10-10 ~ 2017-10-15";

	//构造正则表达式
	//这里 "()" 用于捕获组, 捕获组的编号是按照 "(" 出现的顺序, 从左到右, 从1开始进行编号的
	std::string pattern = "(\\d{4})-(\\d{2}-(\\d{2}))";
	std::regex express(pattern);

	std::regex_iterator<std::string::const_iterator> begin(text.cbegin(), text.cend(), express);
	//std::sregex_iterator == std::regex_iterator<std::string::const_iterator>
	for (auto iter = begin; iter != std::sregex_iterator(); iter++)
	{
		std::cout << iter->length() << ": " << iter->str() << std::endl;
	}
	/*输出
	10: 2017-10-10
	10: 2017-10-15
	*/
}

        std::regex_token_iterator: 用于多次匹配正则表达式, 它可以获取整个正则表达式的结果，也可以获取正则表达式的前缀，还可以获取正则表达式的分组子匹配。

        范例代码如下：

void token_iterator()
{
	/
	//std::regex_token_iterator
	//std::regex_token_iterator: 用于多次匹配正则表达式, 它可以获取整个正则表达式
	//的结果, 也可以获取正则表达式的前缀, 还可以获取正则表达式的分组子匹配

	std::string text = "Date:2017-10-10 ~ 2017-10-15";

	//构造正则表达式
	//这里 "()" 用于捕获组, 捕获组的编号是按照 "(" 出现的顺序, 从左到右, 从1开始进行编号的
	std::string pattern = "(\\d{4})-(\\d{2}-(\\d{2}))";
	std::regex express(pattern);

	/*构造函数2-1*/
	//(多次匹配)显示正则表达式匹配, 即参数 4 等于 0
	std::regex_token_iterator<std::string::const_iterator> begin2_1(text.cbegin(), text.cend(), express);
	//std::sregex_token_iterator == std::regex_token_iterator<std::string::const_iterator>
	for (auto iter = begin2_1; iter != std::sregex_token_iterator(); iter++)
	{
		std::cout << iter->length() << ": " << iter->str() << std::endl;
	}
	/*输出
	10: 2017-10-10
	10: 2017-10-15
	*/

	/*构造函数2-2*/
	//(多次匹配)显示正则表达式匹配到的前缀, -1 则表示只显示前缀
	std::regex_token_iterator<std::string::const_iterator> begin2_2(text.cbegin(), text.cend(), express, -1);
	for (auto iter = begin2_2; iter != std::sregex_token_iterator(); iter++)
	{
		std::cout << iter->length() << ": " << iter->str() << std::endl;
	}
	/*输出
	5: Date:
	3:  ~
	*/

	/*构造函数2-3*/
	//(多次匹配)显示正则表达式子匹配, 3 表示第三组子匹配
	std::regex_token_iterator<std::string::const_iterator> begin2_3(text.cbegin(), text.cend(), express, 3);
	for (auto iter = begin2_3; iter != std::sregex_token_iterator(); iter++)
	{
		std::cout << iter->length() << ": " << iter->str() << std::endl;
	}
	/*输出
	2: 10
	2: 15
	*/

	/*构造函数3*/
	//(多次匹配)显示正则表达式匹配到的前缀和子匹配, -1 表示前缀, 2 表示第二个子匹配
	std::vector<int> vec;
	vec.push_back(-1);
	vec.push_back(2);
	std::regex_token_iterator<std::string::iterator> begin3(text.begin(), text.end(), express, vec);
	for (auto iter = begin3; iter != std::regex_token_iterator<std::string::iterator>(); iter++)
	{
		std::cout << iter->length() << ": " << iter->str() << std::endl;
	}
	/*输出
	5: Date:
	5: 10-10
	3:  ~
	5: 10-15
	*/

	/*构造函数4*/
	//(多次匹配)显示正则表达式匹配到的前缀和整个正则表达式匹配, -1 表示前缀, 0 表示匹配整个正则表达式.
	int arr[] = {-1, 0};
	std::regex_token_iterator<std::string::iterator> begin4(text.begin(), text.end(), express, arr);
	for (auto iter = begin4; iter != std::regex_token_iterator<std::string::iterator>(); iter++)
	{
		std::cout << iter->length() << ": " << iter->str() << std::endl;
	}
	/*输出
	5: Date:
	10: 2017-10-10
	3:  ~
	10: 2017-10-15
	*/
}

        主函数： 

int main()
{
	search();

	system("pause");
	return 0;
}

        以上范例及说明基本上已介绍模板的使用方法，其中模板中的 match_flag_type 我没有使用，可以查阅 MSDN 来使用。另，源代码下载地址：std::regex usge demo



l357630798
关注
  • 25
    点赞
  • 踩
  • 116
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
C++ STL 正则表达式用法介绍
06-18 636
【代码】C++ 正则表达式(std::regex_search使用)
RegexPlugin：基于C ++ std :: regex的虚幻引擎4（UE-4.25.0 Win）正则表达式库插件（v0.7.1b）
02-06
RegexPlugin是专为虚幻引擎4（UE-4.25.0 Win）设计的一款插件，它基于C++标准库中的`std::regex`实现，版本为v0.7.1b。这个插件的主要目标是为UE4提供强大的正则表达式处理功能，以帮助开发者在游戏开发过程中进行...
C++标准库中提供的用于处理正则表达式的类std::regex
book_dw5189的博客
03-23 925
`std::regex` 是 C++ 标准库中提供的用于处理正则表达式的类。正则表达式是一种强大的模式匹配工具，它可以用于在字符串中进行复杂的搜索、替换等操作。
2024年C C++最新C++标准库之std regex类的使用，字节跳动资深面试官亲述
2401_84978490的博客
05-13 865
\D | 匹配任意非数字的字符 || \B | 匹配不是单词开头或结束的位置 || [^x] | 匹配除了x以外的任意字符 || [^aeiou] | 匹配除了aeiou这几个字母以外的任意字符 |如：\S+匹配不包含空白符的字符串。]+>匹配用尖括号括起来的以a开头的字符串。
C++标准库之std::regex类的使用
热门推荐
泠山的博客
07-27 1万+
Cpp标准库之 std::regex 类的使用1. 简介2. 正则表达式2.1 概念2.2 入门2.3 元字符2.4 字符转义2.5 重复2.63. 常用 C++ 标准库正则表达式类：4. 正则表达式模板的使用4.1 std::regex_search 1. 简介 在使用C++标准库之前，需优先学习正则表达式语法。 2. 正则表达式 2.1 概念 在编写处理字符串的程序或网页时，经常会有查找付个某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本规则的代码。 很
【C++】标准库 — 正则表达式 std::regex
Loup&卡普的博客
06-25 2785
从 C++11 起，标准库增加了正则表达式 (RegularEx）std::regex，包含在头文件中。描述字符序列的方法，用于字符（串）的模式/模糊匹配。用途查找 （是否包含，找出来）标识释义seqsequence 表示目标序列rregex 表示模式，即正则表达式mmatch 对象，即 std::match_results 匹配到结果数组mftmatch flag type 匹配标识选项位掩码类型 (BitmaskType)替换（替换内容，替换格式）标识释义。
C++中标准库std::string的实现
网络资源是无限的
07-22 8039
以下实现了C++标准模板库中std::string中的部分实现，参考了cplusplus. 关于C++中标准模板库std::string的介绍和用法可以参考： https://blog.csdn.net/fengbingchun/article/details/62417284   实现代码string.hpp如下： #ifndef FBC_STL_STRING_HPP_ #define ...
C++正则表达式regex使用总结
喜欢打篮球的普通人
09-23 2139
正则表达式（regular expression）的C++库regex是一种强大的描述字符序列的工具 ， C++11中也将正则表达式纳入了新标准的一部分。regex库中常用组件介绍在头文件中包含了多个我们使用正则表达式时需要用到的组件，即 #includeregex库组件详细介绍如下regex表示有一个正则表达式类，比如：regex pattern(“(.{3})(.{2})_(\d{4})!”)全文匹配，要求整个字符串符合正则表达式的匹配规则。
C++中标准模板库std::vector的实现
网络资源是无限的
07-25 4727
以下实现了C++标准模板库std::vector的部分实现，参考了 cplusplus. 关于C++中标准模板库std::vector的介绍和用法可以参考 https://blog.csdn.net/fengbingchun/article/details/51510916 实现代码vector.hpp内容如下： #ifndef FBC_STL_VECTOR_HPP_ #define FB...
std::exception自定义异常捕获类
cfl997
05-24 709
在这个例子中，我们定义了一个自定义的异常类 `MyException`，它继承自 `std::exception`。在 `main()` 函数中，我们通过捕获 `std::exception` 引用来捕获任何继承自 `std::exception` 的异常，并打印出异常消息。捕获的类型为 `const std::exception&`，以便可以捕获任何继承自 `std::exception` 的异常。2. 创建自定义异常类 `MyException`，并继承自 `std::exception`。
C++中标准模板库std::pair的实现
网络资源是无限的
07-12 2792
        以下用C++实现了标准模板库中的std::pair实现，参考了 cplusplus 和 vs2013中的utility文件。        关于std::pair的介绍和用法可以参考： https://blog.csdn.net/fengbingchun/article/details/52205149         实现代码pair.hpp如下：#ifndef FBC_STL_...
Unformat：世界上最快的C ++ 14或C ++ 17类型安全的分析库（比std :: regex快300倍）
02-04
在C++编程领域，处理字符串解析和格式化是常见的任务，而`std::regex`库虽然功能强大，但在某些性能密集型应用中，其效率可能无法满足需求。于是，一个名为Unformat的库应运而生，它宣称自己是世界上最快的C++14或...
linux下的C语言POSIX正则表达式头文件和源文件： regex.h regex.cpp
12-13
POSIX正则表达式是符合IEEE Std 1003.1标准的一套规则，它为编程提供了强大的文本模式匹配功能。在本主题中，我们将探讨`regex.h`头文件和`regex.cpp`源文件，以及如何在Visual Studio 2010或2012环境下编译它们。 ...
regex test.zip_regex
09-24
在IT行业中，正则表达式（Regex）是一种强大的文本处理工具，用于匹配、查找、替换或提取特定...如果需要深入学习，建议阅读《Mastering Regular Expressions》等专业书籍，以及C++标准库文档关于`<regex>`部分的内容。
EffectiveModernCpp:有效的现代Cpp
03-28
12. **标准库新功能**： - `std::make_unique` 和 `std::make_shared` 用于创建智能指针，避免了不必要的临时对象。 - `std::unordered_map` 和 `std::unordered_set` 提供了哈希表实现，提供了更快的查找速度。 ...
2024java面试题
07-26
2024年的Java面试题可能涵盖多个方面，包括Java基础知识、面向对象编程、集合框架、多线程与并发编程、JVM与性能优化、设计模式、Spring框架等。以下是一些可能出现在2024年Java面试中的题目及其简要答案： 一、Java基础知识 面向对象的特征有哪些？ 抽象：忽略主题中与当前目标无关的部分，以便更关注与当前目标有关的部分。 继承：允许新类继承现有类的属性和方法，实现代码重用。 封装：将对象的状态信息隐藏在对象内部，不允许外部直接访问，而是通过公共方法进行访问和操作。 多态性：允许不同类的对象对同一消息作出响应，实现接口重用。 作用域public, private, protected, 以及不写时的区别是什么？ public：任何地方都可以访问。 private：只能在本类内部访问。 protected：可以在同一包内及不同包中的子类里访问。 不写（默认，也称为default）：只能在同一包内访问。 int和Integer有什么区别？ int是Java的原始数据类型，存储在栈内存中。 Integer是Java为int提供的封装类，存储在堆内存中，可以表示null。 二、
C课程设计之职工管理系统
最新发布
07-26
C课程设计之职工管理系统 C语言开发，可以使用dev-C++或者其他C编程软件打开编译运行 喜欢的同学，可以拿去使用
PyOpenGL_accelerate-3.1.7-cp39-cp39-win_amd64.whl
07-26
PyOpenGL_accelerate-3.1.7-cp39-cp39-win_amd64.whl
cpp11的std::regex
03-27
std::regex是C++11标准库中新增的正则表达式库。它提供了一种基于正则表达式的字符串匹配和替换方法，可以用于文本处理、搜索和替换等场景。 使用std::regex需要包含头文件<regex>。它定义了一个名为std::regex的类，表示一个正则表达式对象。可以使用如下方式创建一个正则表达式对象： std::regex reg("pattern"); 其中，pattern是正则表达式的字符串表示。创建好正则表达式对象后，可以使用它的成员函数进行匹配和替换操作。 std::regex提供了多种匹配方式，包括： - std::regex_match：完全匹配整个字符串，匹配成功返回true，否则返回false。 - std::regex_search：在字符串中搜索匹配项，匹配成功返回true，否则返回false。 - std::regex_replace：替换字符串中的匹配项。 std::regex的语法和其他正则表达式库基本相同，支持的语法包括元字符、字符集、量词、分组等。例如，可以使用如下正则表达式匹配一个邮箱地址： std::regex reg("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}"); 在实际使用中，std::regex还提供了一些方便的辅助函数，例如std::regex_replace可以接受一个lambda表达式作为替换函数，这样可以更方便地进行复杂的替换操作。 总之，std::regex是一个非常强大的正则表达式库，可以方便地进行字符串匹配和替换操作，是C++11标准库中的重要组成部分。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

l357630798

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值