C++参悟:正则表达式库regex

正则表达式库regex

  • 一、概述
  • 二、快速上手Demo
    • 1. 查找字符串
    • 2. 匹配字符串
    • 3. 替换字符串
  • 三、类关系梳理
    • 1. 主类
      • 1. basic_regex
    • 2. 算法
      • 1. regex_match
      • 2. regex_search
      • 3. regex_replace
    • 3. 迭代器
    • 4. 异常
    • 5. 特征
    • 6. 常量
      • 1. syntax_option_type
      • 2. match_flag_type
      • 3. error_type

一、概述

C++标准库为我们提供了处理字符串的正则表达式库。正则表达式是一种用于在字符串中匹配模式的微型语言。

正则表达式在查询、替换字符串的时候有很多快速的使用场景,是一个经常使用的工具。正则表达式需要使用到正则表达式的语法,这个语法是独立于编程语言外的一个工具。这个可以 在线查看和测试

菜鸟学习教程 :https://www.runoob.com/regexp/regexp-syntax.html
在这里插入图片描述

在线测试工具 :https://stackoverflow.org.cn/regex/
在这里插入图片描述

这个用到的头文件便是:

#include <regex>

二、快速上手Demo

1. 查找字符串

1. 采用迭代器查找

// 待匹配字符串
std::string s = "Some people, when confronted with a problem";

// 正则表达式匹配对象-匹配单词
std::regex word_regex("(\\w+)");

// 获取迭代器
auto words_begin = std::sregex_iterator(s.begin(), s.end(), word_regex);
auto words_end = std::sregex_iterator();

// 总元素个数
int count = std::distance(words_begin, words_end);

// 遍历元素
for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
		//  查询到的匹配对象
        std::smatch match = *i;

		// 输出这个匹配对象的内容
        std::string match_str = match.str();
		std::cout << "  " << match_str << '\n';
}

/* 输出结果
Some 
people
when 
confronted
with
a
problem
*/

2. 使用算法查找

使用 std::regex_search() 查找

//常用
template< class BidirIt,
          class Alloc, class CharT, class Traits >
bool regex_search( BidirIt first, BidirIt last,
                    std::match_results<BidirIt,Alloc>& m,
                    const std::basic_regex<CharT,Traits>& e,
                    std::regex_constants::match_flag_type flags = std::regex_constants::match_default ); 
//常用
template< class CharT, class Alloc, class Traits >
bool regex_search( const CharT* str,
                    std::match_results<const CharT*,Alloc>& m,
                    const std::basic_regex<CharT,Traits>& e,
                    std::regex_constants::match_flag_type flags = std::regex_constants::match_default ); 
//常用
template< class STraits, class SAlloc,
          class Alloc, class CharT, class Traits >
bool regex_search( const std::basic_string<CharT,STraits,SAlloc>& s,
                    std::match_results<
                    typename std::basic_string<CharT,STraits,SAlloc>::const_iterator, Alloc>& m,
                    const std::basic_regex<CharT, Traits>& e,
                    std::regex_constants::match_flag_type flags = std::regex_constants::match_default ); 

template< class BidirIt
          class CharT, class Traits >
bool regex_search( BidirIt first, BidirIt last,
                    const std::basic_regex<CharT,Traits>& e,
                    std::regex_constants::match_flag_type flags = std::regex_constants::match_default );

template< class CharT, class Traits >
bool regex_search( const CharT* str,
                    const std::basic_regex<CharT,Traits>& e,
                    std::regex_constants::match_flag_type flags = std::regex_constants::match_default ); 

template< class STraits, class SAlloc,
          class CharT, class Traits >
bool regex_search( const std::basic_string<CharT,STraits,SAlloc>& s,
                    const std::basic_regex<CharT,Traits>& e,
                    std::regex_constants::match_flag_type flags =std::regex_constants::match_default );

template< class STraits, class SAlloc,
          class Alloc, class CharT, class Traits >
bool regex_search( const std::basic_string<CharT,STraits,SAlloc>&&,
                    std::match_results<typename std::basic_string<CharT,STraits,SAlloc>::const_iterator, Alloc>&,
                    const std::basic_regex<CharT, Traits>&,
                    std::regex_constants::match_flag_type flags = std::regex_constants::match_default ) = delete; 

这个函数的部分参数说明

  • 待匹配字符串(三种输入)
    1. first, last - 标识目标字符序列的范围
    2. str - 指向空终止字符序列的指针
    3. s - 标识目标字符序列的指针
  • e - 应当应用到目标字符序列的 std::regex :其实就是正则匹配对象
  • m - 匹配结果 :用的是 match_results 对象描述
  • flags - 掌管搜索行为的 std::regex_constants::match_flag_type
// 待匹配字符串
std::string lines[] = {"Roses are #ff0000",
                           "violets are #0000ff",
                           "all of my base are belong to you"};
// 正则表达式对象
std::regex color_regex("#([a-f0-9]{2})"
                           "([a-f0-9]{2})"
                           "([a-f0-9]{2})");
// 匹配结果
std::vector<std::smatch> matchs;

// 简单匹配
for (const auto &line : lines) {
	std::smatch m;
	std::cout << line << ": " << std::boolalpha
		<< std::regex_search(line, m, color_regex) << "\n";
	matchs.push_back(m);
}
    
// 输出结果
for(auto m: matchs){
	if(m.ready() && !m.empty())
		std::cout << "Useful Color: " << m.str() << "\n";
}
/* 输出结果
Roses are #ff0000: true
violets are #0000ff: true
all of my base are belong to you: false
Useful Color: #ff0000
Useful Color: #0000ff
*/

2. 匹配字符串

有两个方法都可以去匹配字符串。可以用 regex_match 或者 regex_search

因为 regex_match 只考虑完全匹配,故同一 regex 可能在 regex_match 和 std::regex_search 间给出不同的匹配

// 构造正则表达式对象
std::regex re("Get|GetValue");
std::cmatch m;

// regex_search 方法
std::regex_search("GetValue", m, re);  // 返回 true ,且 m[0] 含 "Get"
std::regex_search("GetValues", m, re); // 返回 true ,且 m[0] 含 "Get"

// regex_match 方法
std::regex_match ("GetValue", m, re);  // 返回 true ,且 m[0] 含 "GetValue"
std::regex_match ("GetValues", m, re); // 返回 false

3. 替换字符串

#include <iostream>
#include <iterator>
#include <regex>
#include <string>
 
int main()
{
   std::string text = "Quick brown fox";
   std::regex vowel_re("a|e|i|o|u");
 
   // 写结果到输出迭代器
   std::regex_replace(std::ostreambuf_iterator<char>(std::cout),
                      text.begin(), text.end(), vowel_re, "*");
 	// 等价于下面的
 	// std::cout << '\n' << std::regex_replace(text, vowel_re, "*");
 
   // 构造保有结果的字符串
   std::cout << '\n' << std::regex_replace(text, vowel_re, "[$&]") << '\n';
}

// 输出
Q**ck br*wn f*x
Q[u][i]ck br[o]wn f[o]x

三、类关系梳理

1. 主类

这些类封装正则表达式和在字符的目标序列中匹配正则表达式的结果。

1. basic_regex

basic_regex :正则表达式对象

在源代码里面看到那个 std::regex 对象就是用这个 basic_regex 定义的

/** @brief Standard regular expressions. */
typedef basic_regex<char>    regex;

sub_match :标识子表达式所匹配的字符序列

match_results:标识一个正则表达式匹配,包含所有子表达式匹配

2. 算法

这些算法将封装于 regex 的正则表达式应用到字符的目标序列。

1. regex_match

regex_match:尝试匹配一个正则表达式到整个字符序列

2. regex_search

regex_search:尝试匹配一个正则表达式到字符序列的任何部分

3. regex_replace

regex_replace:以格式化的替换文本来替换正则表达式匹配的出现位置

3. 迭代器

regex_iterator:用于遍历在序列中找到的匹配正则表达式的整个集合。

regex_iterator :迭代一个字符序列中的所有正则表达式匹配

regex_token_iterator:迭代给定字符串中的所有正则表达式匹配中的指定子表达式,或迭代未匹配的子字符串

4. 异常

此类定义作为异常抛出以报告来自正则表达式库错误的类型。

regex_error :报告正则表达式库生成的错误信息

在这里插入图片描述

使用这个也是非常简单的

#include <regex>
#include <iostream>
 
int main()
{
    try {
        std::regex re("[a-b][a");
    }
    catch (const std::regex_error& e) {
        std::cout << "regex_error caught: " << e.what() << '\n';
        
        // 这个错误码定义在 6.常量.error_type 中
        if (e.code() == std::regex_constants::error_brack) {
            std::cout << "The code was error_brack\n";
        }
    }
}

// 输出
regex_error caught: The expression contained mismatched [ and ].
The code was error_brack

5. 特征

regex_traits 类用于封装 regex 的本地化方面。

regex_traits:提供正则表达式库所需的关于字符类型的元信息

6. 常量

定义于命名空间 std::regex_constants

1. syntax_option_type

syntax_option_type: 控制正则表达式行为的通用选项,这个参数是放在 regex 对象构造函数中去设置匹配的

就像这种

 std::regex re2(".*(a|xayy)", std::regex::extended);
constexpr syntax_option_type icase = /*unspecified*/;
 
constexpr syntax_option_type nosubs = /*unspecified*/;
constexpr syntax_option_type optimize = /*unspecified*/;
constexpr syntax_option_type collate = /*unspecified*/;
constexpr syntax_option_type ECMAScript = /*unspecified*/;
constexpr syntax_option_type basic = /*unspecified*/;
constexpr syntax_option_type extended = /*unspecified*/;
constexpr syntax_option_type awk = /*unspecified*/;
constexpr syntax_option_type grep = /*unspecified*/;
constexpr syntax_option_type egrep = /*unspecified*/;

解释

效果
icase应当以不考虑大小写进行字符匹配。
nosubs进行匹配时,将所有被标记的子表达式 (expr) 当做非标记的子表达式 (?:expr) 。不将匹配存储于提供的 std::regex_match 结构中,且 mark_count() 为零
optimize指示正则表达式引擎进行更快的匹配,带有令构造变慢的潜在开销。例如这可能表示将非确定 FSA 转换为确定 FSA 。
collate形如 “[a-b]” 的字符范围将对本地环境敏感。
multiline(C++17) 若选择 ECMAScript 引擎,则指定 ^ 应该匹配行首,而 $ 应该匹配行尾。
ECMAScript使用改 ECMAScript 正则表达式文法
basic使用基本 POSIX 正则表达式文法(文法文档)。
extended使用扩展 POSIX 正则表达式文法(文法文档)。
awk使用 POSIX 中 awk 工具所用的正则表达式文法(文法文档)。
grep使用 POSIX 中 grep 工具所用的正则表达式文法。这等效于 basic 选项附带作为另一种分隔符的换行符 ‘\n’ 。
egrep使用 POSIX 中 grep 工具带 -E 选项所用的正则表达式文法。这等效于 extended 附带 ’

ECMAScript, basic, extended, awk, grep, egrep 必须选取至多一个文法选项。若不选取文法选项,则设定为选取 ECMAScript 。其他选项作为修饰符工作,从而 std::regex(“meow”, std::regex::icase) 等价于 std::regex(“meow”, std::regex::ECMAScript|std::regex::icase)

注意
因为 POSIX 使用“最左最长”匹配规则(最长的匹配子序列得到匹配,且若存在数个这种子序列,则匹配最左者),故它不适用的例子之一是剖析标签语言:如 “<tag[^>]>.” 这种 POSIX 正则表达式会匹配从首个 “<tag” 到最末 “” 的任何内容,包含中间的每个 “” 和 “” 。另一方面, ECMAScript 支持非贪心匹配,且 ECMAScript 正则表达式 “<tag[^>]>.?” 会只匹配到首个闭标签。

下面描述 ECMA 和 POSIX 匹配的区别

#include <iostream>
#include <string>
#include <regex>
 
int main()
{
    std::string str = "zzxayyzz";
    std::regex re1(".*(a|xayy)"); // ECMA
    std::regex re2(".*(a|xayy)", std::regex::extended); // POSIX
 
    std::cout << "Searching for .*(a|xayy) in zzxayyzz:\n";
    std::smatch m;
    std::regex_search(str, m, re1);
    std::cout << " ECMA (depth first search) match: " << m[0] << '\n';
    std::regex_search(str, m, re2);
    std::cout << " POSIX (leftmost longest)  match: " << m[0] << '\n';
}

// 输出
Searching for .*(a|xayy) in zzxayyzz:
ECMA (depth first search) match: zzxa
POSIX (leftmost longest)  match: zzxayy

2. match_flag_type

match_flag_type:特定于匹配的选项,这个是用在 regex_match、regex_search、regex_replace 三个算法函数中的一个参数。

就像下面的 regex_match 函数的 flags 是给的默认值

template< class BidirIt,
          class CharT, class Traits >
bool regex_match( BidirIt first, BidirIt last,
                   const std::basic_regex<CharT,Traits>& e,
                   std::regex_constants::match_flag_type flags =
                      std::regex_constants::match_default );
constexpr match_flag_type match_default = {};
 
constexpr match_flag_type match_not_bol = /*unspecified*/;
constexpr match_flag_type match_not_eol = /*unspecified*/;
constexpr match_flag_type match_not_bow = /*unspecified*/;
constexpr match_flag_type match_not_eow = /*unspecified*/;
constexpr match_flag_type match_any = /*unspecified*/;
constexpr match_flag_type match_not_null = /*unspecified*/;
constexpr match_flag_type match_continuous = /*unspecified*/;
constexpr match_flag_type match_prev_avail = /*unspecified*/;
constexpr match_flag_type format_default = {};
constexpr match_flag_type format_sed = /*unspecified*/;
constexpr match_flag_type format_no_copy = /*unspecified*/;

注意: [first, last) 指代要匹配的字符序列。

常量解释
match_not_bol[first,last) 中的首个字符将被处理成如同它不在行首(即 ^ 将不匹配 [first,first) )
match_not_eol[first,last) 中的最末字符将被处理成如同它不在行尾(即 $ 将不匹配 [last,last) )
match_not_bow“\b” 将不匹配 [first,first)
match_not_eow“\b” 将不匹配 [last,last)
match_any若多于一个匹配可行,则任何匹配都是可接受的结果
match_not_null不匹配空字符序列
match_continuous仅匹配始于 first 的子串
match_prev_avail–first 是合法的迭代位置。设置时导致 match_not_bol 和 match_not_bow 被忽略
format_default使用 ECMAScript 规则于 std::regex_replace 构造字符串(语法文档)
format_sed 于std::regex_replace 使用 POSIX sed 工具规则。(语法文档)
format_no_copy不复制不匹配的字符串到 std::regex_replace 中的输出
format_first_only仅替换 std::regex_replace 中的首个匹配

match_defaultformat_default 以外的所有常量都是位掩码元素。 match_defaultformat_default 常量是空位掩码。

3. error_type

error_type:描述不同类型的匹配错误,可以用 try catch 捕获

constexpr error_type error_collate = /*unspecified*/;
constexpr error_type error_ctype = /*unspecified*/;
constexpr error_type error_escape = /*unspecified*/;
constexpr error_type error_backref = /*unspecified*/;
constexpr error_type error_brack = /*unspecified*/;
constexpr error_type error_paren = /*unspecified*/;
constexpr error_type error_brace = /*unspecified*/;
constexpr error_type error_badbrace = /*unspecified*/;
constexpr error_type error_range = /*unspecified*/;
constexpr error_type error_space = /*unspecified*/;
constexpr error_type error_badrepeat = /*unspecified*/;
constexpr error_type error_complexity = /*unspecified*/;
constexpr error_type error_stack = /*unspecified*/;

名词解释如下:

常量解释
error_collate表达式含有非法对照字符名
error_ctype表达式含有非法字符类名
error_escape表达式含有非法转义字符或尾随转义
error_backref表达式含有非法回溯引用
error_brack表达式含有不匹配的方括号对( ‘[’ 与 ‘]’ )
error_paren表达式含有不匹配的括号对( ‘(’ 与 ‘)’ )
error_brace表达式含有不匹配的花括号对( ‘{’ 与 ‘}’ )
error_badbrace表达式在 {} 表达式中含有非法范围
error_range表达式含有非法字符范围(例如 [b-a] )
error_space没有将表达式转换成有限状态机的足够内存
error_badrepeat*?+{ 之一不后继一个合法正则表达式
error_complexity尝试的匹配的复杂度超过了预定义的等级
error_stack没有进行匹配的足够内存

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/337783.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【Linux】第三十站:进程间通信

文章目录 一、是什么二、为什么三、怎么办四、管道1.什么是管道2.管道的原理3.接口4.编码实现5.管道的特征6.管道的四种情况 一、是什么 两个或者多个进程实现数据层面的交互 因为进程独立性的存在&#xff0c;导致进程通信的成本比较高 通信是有成本的&#xff0c;体现在要打破…

集美大学“第15届蓝桥杯大赛(软件类)“校内选拔赛 D矩阵选数

经典的状态压缩DP int dp[15][(1<<14)10]; int a[15][15]; void solve() {//dp[i][st]考虑到了第i行 并且当前考虑完第i行以后的选择状态是st的所有方案中的最大值for(int i1;i<13;i)for(int j1;j<13;j)cin>>a[i][j];for(int i1;i<13;i){for(int j0;j<…

conda修改默认环境安装位置

conda修改默认环境安装位置 文章目录 conda修改默认环境安装位置查看conda配置信息创建.condarc&#xff08;conda runtime controlling)配置文件没有.condarc怎么办 即使创建正确放置了.condarc创建环境时还是默认指定C盘目录写权限目录修改权限 查看conda配置信息 conda con…

Flutter 页面嵌入 Android原生 View

前言 文章主要讲解Flutter页面如何使用Android原生View&#xff0c;但用到了Flutter 和 Android原生 相互通信知识&#xff0c;建议先看完这篇讲解通信的文章 Flutter 与 Android原生 相互通信&#xff1a;BasicMessageChannel、MethodChannel、EventChannel-CSDN博客 数据观…

1027 打印沙漏 (20)

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”&#xff0c;要求按下列格式打印 ************ *****所谓“沙漏形状”&#xff0c;是指每行输出奇数个符号&#xff1b;各行符号中心对齐&#xff1b;相邻两行符号数差2&#xff1b;符号数先从大到小顺序递…

数据结构:顺序表 模拟实现及详解

目录 一、线性表 二、顺序表 2.1顺序表的概念及结构 2.1.1静态顺序表 2.2.2动态顺序表 2.2动态顺序表接口实现 一、线性表 线性表&#xff08; linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见…

如何使用iPhone或iPad上的二维码共享Wi-Fi密码?这里有详细步骤

你有没有想过在不泄露网络密码的情况下与客人共享你的家庭或工作Wi-Fi?你肯定不是第一个这样想的人,我们很高兴地通知你,多亏了以下这个的变通方法,你现在可以使用iPhone或iPad做到这一点。 通常,如果你想让其他人访问网络,你需要共享你的Wi-Fi密码。苹果通过引入与任何…

Jetpack Compose -> 分包 自定义Composable

前言 上一章我们讲解了 Compose 基础UI 和 Modifier 关键字&#xff0c;本章主要讲解 Compose 分包以及自定义 Composable&#xff1b; Compose 如何分包 我们在使用 Button 控件的时候&#xff0c;发现如果我们想给按钮设置文本的时候&#xff0c;Button 函数并没有直接提供…

读书笔记-《数据结构与算法》-摘要8[桶排序]

桶排序和归并排序有那么点点类似&#xff0c;也使用了归并的思想。大致步骤如下&#xff1a; 设置一个定量的数组当作空桶。Divide - 从待排序数组中取出元素&#xff0c;将元素按照一定的规则塞进对应的桶子去。对每个非空桶进行排序&#xff0c;通常可在塞元素入桶时进行插入…

C#中ArrayList运行机制及其涉及的装箱拆箱

C#中ArrayList运行机制及其涉及的装箱拆箱 1.1 基本用法1.1.1 属性1.1.2 方法 1.2 内部实现1.3 装箱1.4 拆箱1.5 object对象的相等性比较1.6 总结1.7 其他简单结构类 1.1 基本用法 命名空间&#xff1a; using System.Collections; 1.1.1 属性 Capacity&#xff1a;获取或设…

【代码随想录10】20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值

目录 20. 有效的括号题目描述参考代码 1047. 删除字符串中的所有相邻重复项题目描述参考代码 150. 逆波兰表达式求值题目描述参考代码 20. 有效的括号 题目描述 给定一个只包括 (&#xff0c;)&#xff0c;{&#xff0c;}&#xff0c;[&#xff0c;] 的字符串 s &#xff0c;…

语音模块学习——LSYT201B模组(深圳雷龙科技)

目录 引子 处理器 外设 音频 蓝牙 模组展示 引子 关注我的老粉们应该知道我之前用过语音模块做东西&#xff0c;那个比较贵要50多。 今天这个淘宝20元左右比那个便宜&#xff0c;之前那个内核是51的&#xff0c;一个8位机。 后面我做东西的时候语音模块可能会换成这个&…

【51单片机】动态数码管

0、前言 参考&#xff1a; 普中51单片机开发攻略–A2.pdf 1、数码管介绍 上一章我们主要是介绍一位数码管的内部结构及控制原理。下面我们再来介 绍下多位数码管及动态显示原理的相关知识。 1.1 多位数码管简介 2、74HC245 和 74HC138 芯片介绍 2.1 74HC245 芯片简介 2.2 7…

Flink入门教程

使用flink时需要提前准备好scala环境 一、创建maven项目 二、添加pom依赖 <properties><scala.version>2.11.12</scala.version></properties><dependency><groupId>org.scala-lang</groupId><artifactId>scala-library<…

探索指针的奇妙世界,程序中的魔法箭头(上)

目录 一.指针是什么二.指针和指针类型1.指针加减整数2.指针的解引用 三.野指针1.野指针形成的原因&#xff08;1&#xff09;指针未初始化指针越界访问 2.如何规避野指针&#xff08;1&#xff09;指针初始化&#xff08;2&#xff09;小心指针越界&#xff08;3&#xff09;指…

用Python实现Excel中的Vlookup功能

目录 一、引言 二、准备工作 三、实现Vlookup功能 1、导入pandas库 2、准备数据 3、实现Vlookup功能 4、处理结果 5、保存结果 四、完整代码示例 五、注意事项 六、总结 一、引言 在Excel中&#xff0c;Vlookup是一个非常实用的函数&#xff0c;它可以帮助我们在表…

014-信息打点-JS架构框架识别泄漏提取API接口枚举FUZZ爬虫插件项目

014-信息打点-JS架构&框架识别&泄漏提取&API接口枚举&FUZZ爬虫&插件项目 #知识点&#xff1a; 1、JS前端架构-识别&分析 2、JS前端架构-开发框架分析 3、JS前端架构-打包器分析 4、JS前端架构-提取&FUZZ 解决&#xff1a; 1、如何从表现中的JS提取…

1.11马原

同一性是事物存在和发展的前提&#xff0c;一方的发展以另一方的发展为条件 同一性使矛盾双方相互吸收有利于自身的因素&#xff0c;在相互作用中各自得到发展 是事物发展根本规律&#xff0c;唯物辩证法的实质和核心 揭示了事物普遍联系的根本内容和变化发展的内在动力 是贯…

VIM工程的编译 / VI的快捷键记录

文章目录 VIM工程的编译 / VI的快捷键记录概述笔记工程的编译工程的编译 - 命令行vim工程的编译 - GUI版vim备注VIM的帮助文件位置VIM官方教程vim 常用快捷键启动vi时, 指定要编辑哪个文件正常模式光标的移动退出不保存 退出保存只保存不退出另存到指定文件移动到行首移动到行尾…

Java面试汇总——jvm篇

目录 JVM的组成&#xff1a; 1、JVM 概述(⭐⭐⭐⭐) 1.1 JVM是什么&#xff1f; 1.2 JVM由哪些部分组成&#xff0c;运行流程是什么&#xff1f; 2、什么是程序计数器&#xff1f;(⭐⭐⭐⭐) 3、介绍一下Java的堆(⭐⭐⭐⭐) 4、虚拟机栈(⭐⭐⭐⭐) 4.1 什么是虚拟机栈&…