006 《Boost.Regex 权威指南（Boost.Regex: The Definitive Guide）》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 走进正则表达式（Introduction to Regular Expressions）
▮▮▮▮▮▮▮ 1.1 什么是正则表达式？（What are Regular Expressions?）
▮▮▮▮▮▮▮ 1.2 正则表达式的应用场景（Applications of Regular Expressions）
▮▮▮▮▮▮▮ 1.3 正则表达式的基本语法元素（Basic Syntax Elements of Regular Expressions）
▮▮▮▮▮▮▮ 1.4 Boost.Regex 库简介（Introduction to Boost.Regex Library）
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 Boost 库的安装与配置（Installation and Configuration of Boost Library）
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 Boost.Regex 的优势与特点（Advantages and Features of Boost.Regex）
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 第一个 Boost.Regex 程序（Your First Boost.Regex Program）
▮▮▮▮ 2. chapter 2： Boost.Regex 基础：匹配与查找（Boost.Regex Basics: Matching and Searching）
▮▮▮▮▮▮▮ 2.1 regex 类：正则表达式对象（The regex Class: Regular Expression Object）
▮▮▮▮▮▮▮ 2.2 smatch 类：匹配结果容器（The smatch Class: Match Result Container）
▮▮▮▮▮▮▮ 2.3 regex_match 函数：完全匹配（The regex_match Function: Full Match）
▮▮▮▮▮▮▮ 2.4 regex_search 函数：搜索匹配（The regex_search Function: Search Match）
▮▮▮▮▮▮▮ 2.5 使用字面量和原始字符串（Using Literal and Raw Strings）
▮▮▮▮ 3. chapter 3： 正则表达式语法详解（Detailed Regular Expression Syntax）
▮▮▮▮▮▮▮ 3.1 字符匹配（Character Matching）
▮▮▮▮▮▮▮▮▮▮▮ 3.1.1 普通字符与元字符（Ordinary Characters and Metacharacters）
▮▮▮▮▮▮▮▮▮▮▮ 3.1.2 字符类（Character Classes）
▮▮▮▮▮▮▮▮▮▮▮ 3.1.3 预定义字符类（Predefined Character Classes）
▮▮▮▮▮▮▮ 3.2 量词（Quantifiers）
▮▮▮▮▮▮▮▮▮▮▮ 3.2.1 贪婪量词、懒惰量词和占有量词（Greedy, Lazy, and Possessive Quantifiers）
▮▮▮▮▮▮▮ 3.3 锚点（Anchors）
▮▮▮▮▮▮▮▮▮▮▮ 3.3.1 行起始符和行结束符（Start and End of Line Anchors）
▮▮▮▮▮▮▮▮▮▮▮ 3.3.2 单词边界（Word Boundaries）
▮▮▮▮▮▮▮ 3.4 分组与捕获（Grouping and Capturing）
▮▮▮▮▮▮▮▮▮▮▮ 3.4.1 捕获组与非捕获组（Capturing and Non-capturing Groups）
▮▮▮▮▮▮▮▮▮▮▮ 3.4.2 反向引用（Backreferences）
▮▮▮▮ 4. chapter 4： Boost.Regex 进阶：替换与迭代（Boost.Regex Advanced: Substitution and Iteration）
▮▮▮▮▮▮▮ 4.1 regex_replace 函数：替换操作（The regex_replace Function: Substitution）
▮▮▮▮▮▮▮▮▮▮▮ 4.1.1 替换格式字符串（Substitution Format Strings）
▮▮▮▮▮▮▮▮▮▮▮ 4.1.2 使用 smatch 对象进行替换（Substitution with smatch Objects）
▮▮▮▮▮▮▮ 4.2 regex_iterator 和 regex_token_iterator：迭代匹配（regex_iterator and regex_token_iterator: Iterative Matching）
▮▮▮▮▮▮▮▮▮▮▮ 4.2.1 regex_iterator 的使用（Using regex_iterator）
▮▮▮▮▮▮▮▮▮▮▮ 4.2.2 regex_token_iterator 的使用（Using regex_token_iterator）
▮▮▮▮ 5. chapter 5： 错误处理与异常（Error Handling and Exceptions）
▮▮▮▮▮▮▮ 5.1 regex_error 类：正则表达式异常（The regex_error Class: Regular Expression Exception）
▮▮▮▮▮▮▮ 5.2 正则表达式编译错误（Regular Expression Compilation Errors）
▮▮▮▮▮▮▮ 5.3 运行时匹配错误（Runtime Matching Errors）
▮▮▮▮ 6. chapter 6： 性能优化与高级主题（Performance Optimization and Advanced Topics）
▮▮▮▮▮▮▮ 6.1 正则表达式性能考量（Regular Expression Performance Considerations）
▮▮▮▮▮▮▮▮▮▮▮ 6.1.1 回溯与性能陷阱（Backtracking and Performance Pitfalls）
▮▮▮▮▮▮▮▮▮▮▮ 6.1.2 优化正则表达式的技巧（Techniques for Optimizing Regular Expressions）
▮▮▮▮▮▮▮ 6.2 Unicode 支持（Unicode Support）
▮▮▮▮▮▮▮▮▮▮▮ 6.2.1 Unicode 字符类和属性（Unicode Character Classes and Properties）
▮▮▮▮▮▮▮▮▮▮▮ 6.2.2 处理不同编码的字符串（Handling Strings with Different Encodings）
▮▮▮▮▮▮▮ 6.3 自定义 Locale（Custom Locales）
▮▮▮▮▮▮▮ 6.4 正则表达式选项（Regex Options）
▮▮▮▮▮▮▮▮▮▮▮ 6.4.1 regex_constants::syntax_option_type：语法选项（Syntax Options）
▮▮▮▮▮▮▮▮▮▮▮ 6.4.2 regex_constants::match_flag_type：匹配选项（Match Options）
▮▮▮▮ 7. chapter 7： Boost.Regex API 参考详解（Boost.Regex API Reference and Detailed Explanation）
▮▮▮▮▮▮▮ 7.1 regex 类详解（Detailed Explanation of regex Class）
▮▮▮▮▮▮▮ 7.2 smatch 类详解（Detailed Explanation of smatch Class）
▮▮▮▮▮▮▮ 7.3 regex_match 函数详解（Detailed Explanation of regex_match Function）
▮▮▮▮▮▮▮ 7.4 regex_search 函数详解（Detailed Explanation of regex_search Function）
▮▮▮▮▮▮▮ 7.5 regex_replace 函数详解（Detailed Explanation of regex_replace Function）
▮▮▮▮▮▮▮ 7.6 迭代器详解：regex_iterator 和 regex_token_iterator（Detailed Explanation of Iterators: regex_iterator and regex_token_iterator）
▮▮▮▮ 8. chapter 8： 实战案例分析（Practical Case Studies）
▮▮▮▮▮▮▮ 8.1 数据验证：邮箱、URL、电话号码验证（Data Validation: Email, URL, Phone Number Validation）
▮▮▮▮▮▮▮ 8.2 日志文件分析与处理（Log File Analysis and Processing）
▮▮▮▮▮▮▮ 8.3 文本编辑器中的查找与替换功能实现（Implementing Find and Replace Functionality in a Text Editor）
▮▮▮▮▮▮▮ 8.4 网络爬虫中的信息提取（Information Extraction in Web Crawlers）
▮▮▮▮ 9. chapter 9： Boost.Regex 与其他 Boost 库的集成（Integration of Boost.Regex with Other Boost Libraries）
▮▮▮▮▮▮▮ 9.1 Boost.Asio 与 Boost.Regex：网络编程中的应用（Boost.Asio and Boost.Regex: Applications in Network Programming）
▮▮▮▮▮▮▮ 9.2 Boost.Filesystem 与 Boost.Regex：文件系统操作中的应用（Boost.Filesystem and Boost.Regex: Applications in File System Operations）
▮▮▮▮▮▮▮ 9.3 Boost.Spirit 与 Boost.Regex：更复杂的文本解析（Boost.Spirit and Boost.Regex: More Complex Text Parsing）
▮▮▮▮ 10. chapter 10： 未来展望与发展趋势（Future Trends and Development）
▮▮▮▮▮▮▮ 10.1 C++ 标准库正则表达式的比较与展望（Comparison with C++ Standard Library Regex and Future Prospects）
▮▮▮▮▮▮▮ 10.2 Boost.Regex 的未来发展方向（Future Development Directions of Boost.Regex）
1. chapter 1： 走进正则表达式（Introduction to Regular Expressions）
1.1 什么是正则表达式？（What are Regular Expressions?）
正则表达式（Regular Expression，常简写为 regex、regexp 或 RE）是一种强大的文本处理工具，它使用预定义的特殊字符和普通字符组合成“模式（pattern）”，用于描述和匹配字符串中的文本模式。可以将正则表达式视为一种“文本的描述语言”，它能够简洁、灵活地表达复杂的字符串匹配规则。
从本质上讲，正则表达式不仅仅是一门独立的编程语言，更是一种通用的模式匹配技术，广泛应用于各种编程语言、文本编辑器、数据库和操作系统中。掌握正则表达式，能够极大地提升文本处理效率和代码的简洁性。
⚝ 定义: 正则表达式是一种用于描述、匹配和操作文本的模式。
⚝ 核心思想: 使用特殊字符和普通字符组合成模式，来匹配符合特定规则的字符串。
⚝ 应用领域: 文本搜索、数据验证、文本替换、日志分析、网络爬虫等。
例如，我们想要在一个文本中查找所有符合电子邮件地址格式的字符串，如果手动编写代码来判断，将会非常繁琐且容易出错。但是，使用正则表达式，只需要一个简单的模式 \b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b 就可以轻松实现。
1
#include <iostream>
2
#include <string>
3
#include <regex>
4
5
int main() {
6
std::string text = "我的邮箱是 example@example.com， 另一个邮箱是 test.user@sub.domain.org。";
7
std::regex email_regex(R"(\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b)"); // 原始字符串字面量，避免转义
8
std::smatch match;
9
10
std::cout << "文本: " << text << std::endl;
11
std::cout << "邮箱地址: " << std::endl;
12
13
std::string::const_iterator search_start(text.cbegin());
14
while (std::regex_search(search_start, text.cend(), match, email_regex)) {
15
std::cout << " " << match[0] << std::endl;
16
search_start = match.suffix().first; // 从上一次匹配的末尾继续搜索
17
}
18
19
return 0;
20
}
代码解释:
⚝ #include <regex>: 引入 C++ 标准库的正则表达式头文件（Boost.Regex 库的用法类似，后续章节会详细介绍）。
⚝ std::regex email_regex(R"(\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b)"): 定义一个正则表达式对象 email_regex，模式使用原始字符串字面量 R"(...)，避免了反斜杠的转义问题，使模式更易读。
▮▮▮▮⚝ \b: 单词边界，确保匹配的是完整的单词。
▮▮▮▮⚝ [a-zA-Z0-9._%+-]+: 匹配邮箱用户名部分，允许字母、数字、点、下划线、百分号、加号、减号，+ 表示至少出现一次。
▮▮▮▮⚝ @: 匹配 @ 符号。
▮▮▮▮⚝ [a-zA-Z0-9.-]+: 匹配域名部分，允许字母、数字、点、减号，+ 表示至少出现一次。
▮▮▮▮⚝ \.: 匹配点号 .，需要转义，因为 . 在正则表达式中是元字符，匹配任意字符。
▮▮▮▮⚝ [a-zA-Z]{2,}: 匹配顶级域名部分，允许字母，{2,} 表示至少出现两次。
▮▮▮▮⚝ \b: 单词边界，确保匹配的是完整的单词。
⚝ std::regex_search: 在文本中搜索匹配正则表达式的子串。
⚝ match[0]: smatch 对象 match 的第一个元素 match[0] 存储了整个匹配的字符串。
⚝ match.suffix().first: 获取匹配子串之后的起始位置，用于下一次搜索。
这段代码展示了正则表达式的强大之处，仅用几行代码就实现了复杂的邮箱地址查找功能。在后续章节中，我们将深入学习正则表达式的语法和 Boost.Regex 库的使用，掌握更高级的文本处理技巧。
1.2 正则表达式的应用场景（Applications of Regular Expressions）
正则表达式的应用场景非常广泛，几乎所有涉及文本处理的领域都能看到它的身影。掌握正则表达式，可以极大地提高工作效率，并为解决复杂文本处理问题提供强大的工具。
① 数据验证（Data Validation）:
正则表达式常用于验证用户输入的数据格式是否正确，例如：
⚝ 邮箱地址验证
⚝ 手机号码验证
⚝ 身份证号码验证
⚝ URL 验证
⚝ 日期格式验证
⚝ 密码强度验证
通过在前端和后端同时使用正则表达式进行数据验证，可以有效地防止非法数据进入系统，提高系统的安全性和稳定性。
② 文本搜索与查找（Text Searching and Finding）:
这是正则表达式最常见的应用场景之一。无论是简单的文本编辑器，还是复杂的集成开发环境（IDE），都提供了基于正则表达式的搜索功能。
⚝ 在大量代码文件中查找特定模式的代码
⚝ 在日志文件中快速定位错误信息
⚝ 在网页内容中提取关键信息
正则表达式比简单的关键词搜索更加灵活和强大，可以根据复杂的模式来查找文本。
③ 文本替换（Text Substitution）:
正则表达式不仅可以查找文本，还可以进行强大的文本替换操作。
⚝ 批量替换代码中的变量名
⚝ 格式化文本文件
⚝ 清理 HTML 代码中的冗余标签
文本替换功能可以极大地提高文本编辑效率，尤其是在处理大量文本时。
④ 日志分析（Log Analysis）:
日志文件通常包含大量的文本信息，结构化程度较低，使用正则表达式可以方便地从日志中提取关键信息，进行分析和监控。
⚝ 提取特定类型的日志条目（例如，错误日志、警告日志）
⚝ 统计特定事件发生的次数
⚝ 从日志中提取性能指标
日志分析是运维和开发工作中非常重要的一环，正则表达式在其中扮演着关键角色。
⑤ 网络爬虫（Web Crawling）:
网络爬虫需要从 HTML 或 XML 文档中提取有用的信息，正则表达式是信息提取的重要工具。
⚝ 提取网页中的链接
⚝ 提取文章标题和内容
⚝ 提取商品价格和描述
结合 HTML/XML 解析库和正则表达式，可以构建强大的网络爬虫系统。
⑥ 自然语言处理（Natural Language Processing, NLP）:
在自然语言处理领域，正则表达式也常用于文本预处理和特征提取。
⚝ 分词（Tokenization）
⚝ 词性标注（Part-of-Speech Tagging）
⚝ 命名实体识别（Named Entity Recognition）
虽然深度学习在 NLP 领域占据主导地位，但正则表达式仍然是一些简单文本处理任务的有效工具。
⑦ 代码生成与重构（Code Generation and Refactoring）:
正则表达式可以用于代码的自动生成和重构。
⚝ 根据模板生成代码框架
⚝ 自动重构代码结构
⚝ 代码风格检查和规范化
在软件开发工具中，正则表达式可以辅助完成一些代码自动化任务。
总而言之，正则表达式的应用场景非常广泛，涵盖了文本处理的各个方面。无论是开发者、运维工程师、数据分析师还是科研人员，掌握正则表达式都能受益匪浅。在接下来的章节中，我们将深入学习正则表达式的语法和 Boost.Regex 库的使用，以便更好地应用正则表达式解决实际问题。
1.3 正则表达式的基本语法元素（Basic Syntax Elements of Regular Expressions）
正则表达式的强大之处在于其丰富的语法元素，通过组合这些元素，可以构建出各种复杂的模式。本节将介绍正则表达式中最基本、最常用的语法元素，为后续深入学习打下基础。
① 字面字符（Literal Characters）:
最简单的正则表达式由字面字符组成，例如，abc 匹配的就是字符串 "abc"。字面字符包括字母、数字、空格和大多数标点符号。
② 元字符（Metacharacters）:
元字符是正则表达式中具有特殊含义的字符，它们不代表字面意义，而是用于表示一些特殊的模式。常见的元字符包括：
. ^ $ * + ? {} [] \ | ()
如果想要匹配元字符本身，需要使用反斜杠 \ 进行转义，例如，\. 匹配的就是点号 .，\* 匹配的就是星号 *。
③ 字符类（Character Classes）:
字符类用于匹配一组字符中的任意一个字符。
⚝ [abc]: 匹配字符 a、b 或 c 中的任意一个。
⚝ [a-z]: 匹配小写字母 a 到 z 中的任意一个。
⚝ [0-9]: 匹配数字 0 到 9 中的任意一个。
⚝ [^abc]: 匹配除了字符 a、b、c 之外的任意一个字符（脱字符 ^ 在字符类中表示否定）。
预定义的字符类可以简化正则表达式的编写，例如：
⚝ \d: 匹配任意数字，等价于 [0-9]。
⚝ \D: 匹配任意非数字字符，等价于 [^0-9]。
⚝ \w: 匹配任意字母、数字或下划线，等价于 [a-zA-Z0-9_]。
⚝ \W: 匹配任意非字母、数字或下划线字符，等价于 [^a-zA-Z0-9_]。
⚝ \s: 匹配任意空白字符，包括空格、制表符、换行符等。
⚝ \S: 匹配任意非空白字符。
④ 量词（Quantifiers）:
量词用于指定模式出现的次数。
⚝ *: 匹配前一个元素零次或多次。
⚝ +: 匹配前一个元素一次或多次。
⚝ ?: 匹配前一个元素零次或一次。
⚝ {n}: 匹配前一个元素恰好 n 次。
⚝ {n,}: 匹配前一个元素至少 n 次。
⚝ {n,m}: 匹配前一个元素至少 n 次，至多 m 次。
量词默认是贪婪的（Greedy），即尽可能多地匹配。在量词后面加上 ? 可以使其变为懒惰的（Lazy），即尽可能少地匹配。例如，.* 是贪婪匹配，.*? 是懒惰匹配。
⑤ 锚点（Anchors）:
锚点用于指定匹配的位置。
⚝ ^: 匹配字符串的开头。
⚝ $: 匹配字符串的结尾。
⚝ \b: 匹配单词边界。
⚝ \B: 匹配非单词边界。
锚点可以用于限定匹配的位置，例如，^abc$ 只匹配以 "abc" 开头和结尾的字符串，即只匹配字符串 "abc" 本身。
⑥ 分组与捕获（Grouping and Capturing）:
使用括号 () 可以将正则表达式的一部分进行分组，分组可以用于：
⚝ 捕获组（Capturing Group）: 括号内的子表达式匹配到的内容会被捕获，可以用于后续的反向引用或提取。
⚝ 非捕获组（Non-capturing Group）: 使用 (?:...) 可以创建非捕获组，只用于分组，不进行捕获，可以提高性能。
⚝ 应用量词: 可以将量词应用于整个分组，例如，(abc)+ 匹配 "abc"、"abcabc"、"abcabcabc" 等。
⚝ 或操作: 使用 | 可以在分组内进行或操作，例如，(cat|dog) 匹配 "cat" 或 "dog"。
⑦ 反向引用（Backreferences）:
反向引用用于引用之前捕获组匹配到的文本。例如，\1 引用第一个捕获组，\2 引用第二个捕获组，以此类推。反向引用常用于匹配重复出现的模式。例如，(\w+)\s+\1 可以匹配重复的单词，如 "go go"。
⑧ 选择（Alternation）:
使用竖线 | 可以表示或关系，匹配多个模式中的任意一个。例如，cat|dog|fish 匹配 "cat"、"dog" 或 "fish"。
以上是正则表达式最基本、最常用的语法元素。掌握这些元素，就可以构建出各种简单的正则表达式来解决实际问题。在后续章节中，我们将学习更高级的语法和 Boost.Regex 库的使用，进一步提升正则表达式的应用能力。
1.4 Boost.Regex 库简介（Introduction to Boost.Regex Library）
Boost.Regex 是 Boost 库中用于正则表达式处理的组件，它提供了强大而灵活的正则表达式功能，并且是 C++ 标准库 <regex> 的设计蓝本。Boost.Regex 库在功能、性能和跨平台性方面都表现出色，是 C++ 正则表达式处理的首选库之一。
1.4.1 Boost 库的安装与配置（Installation and Configuration of Boost Library）
要使用 Boost.Regex 库，首先需要安装和配置 Boost 库。Boost 库是一个庞大的 C++ 库集合，包含了大量的实用工具和组件。Boost 库的安装和配置相对简单，通常可以分为以下几个步骤：
① 下载 Boost 库:
访问 Boost 官网 www.boost.org 下载最新版本的 Boost 库。通常提供压缩包形式的下载，例如 .zip 或 .tar.gz 文件。
② 解压 Boost 库:
将下载的 Boost 库压缩包解压到本地目录，例如 C:\boost (Windows) 或 /usr/local/boost (Linux/macOS)。解压后的目录结构应该包含 boost 子目录，其中包含了所有的 Boost 头文件。
③ 编译 Boost 库（可选）:
Boost 库的大部分组件是 header-only 的，即只需要包含头文件即可使用，无需编译。Boost.Regex 库也是 header-only 的，因此通常情况下不需要编译。
但是，如果需要使用 Boost 库的某些需要编译的组件（例如 Boost.Filesystem、Boost.Thread 等），或者为了提高性能，也可以选择编译 Boost 库。编译 Boost 库通常需要使用 Boost.Build 工具（b2 或 bjam）。
编译 Boost.Regex 库的步骤（以 Linux 为例）：
1
cd boost_解压目录
2
./bootstrap.sh
3
./b2 install --with-regex --prefix=/usr/local
▮▮▮▮⚝ --with-regex: 指定编译 regex 组件。
▮▮▮▮⚝ --prefix=/usr/local: 指定安装路径为 /usr/local。
Windows 下的编译步骤类似，具体可以参考 Boost 官方文档。
④ 配置编译环境:
在 C++ 项目中使用 Boost.Regex 库，需要在编译环境中配置 Boost 库的头文件和库文件路径。
▮▮▮▮⚝ 头文件路径: 需要将 Boost 库的根目录（例如 C:\boost 或 /usr/local/boost）添加到编译器的头文件搜索路径中。
▮▮▮▮⚝ 库文件路径: 如果编译了 Boost 库，需要将 Boost 库的库文件目录（例如 /usr/local/lib）添加到链接器的库文件搜索路径中。对于 header-only 的 Boost.Regex 库，通常不需要配置库文件路径。
在不同的集成开发环境（IDE）和构建系统（例如 CMake、Makefile）中，配置编译环境的方式有所不同，具体可以参考相应的文档。
⑤ 验证安装:
编写一个简单的程序，包含 Boost.Regex 库的头文件，并编译运行，验证 Boost.Regex 库是否安装成功。例如：
1
#include <iostream>
2
#include <boost/regex.hpp>
3
4
int main() {
5
boost::regex re("(\\w+)");
6
std::cout << "Boost.Regex is working!" << std::endl;
7
return 0;
8
}
如果程序能够成功编译和运行，并输出 "Boost.Regex is working!"，则说明 Boost.Regex 库已经成功安装和配置。
1.4.2 Boost.Regex 的优势与特点（Advantages and Features of Boost.Regex）
Boost.Regex 库作为优秀的 C++ 正则表达式库，具有以下显著的优势和特点：
① 功能强大:
Boost.Regex 库支持 Perl 兼容的正则表达式语法（Perl Compatible Regular Expressions, PCRE），提供了丰富的正则表达式语法元素，包括：
⚝ 各种字符类、量词、锚点、分组、反向引用等。
⚝ 零宽断言（Zero-width Assertions，例如 (?=...)、(?!...)、(?<=...)、(?<!...)）。
⚝ 条件表达式（Conditional Expressions，例如 (?(condition)yes-pattern|no-pattern)）。
⚝ 递归正则表达式（Recursive Regular Expressions）。
这些高级特性使得 Boost.Regex 能够处理非常复杂的文本匹配和处理任务。
② 性能优秀:
Boost.Regex 库在性能方面做了大量的优化，匹配速度快，资源消耗低。尤其是在处理大规模文本数据时，Boost.Regex 仍然能够保持高效的性能。
③ 跨平台性:
Boost 库本身具有良好的跨平台性，Boost.Regex 库也继承了这一特点。它可以在 Windows、Linux、macOS 等多种操作系统平台上编译和运行，保证了代码的可移植性。
④ 与 C++ 标准库的良好兼容性:
Boost.Regex 库的设计对 C++ 标准库 <regex> 产生了深远的影响，C++11 标准库的 <regex> 组件在很大程度上借鉴了 Boost.Regex 的设计思想和 API 接口。因此，学习 Boost.Regex 库可以更好地理解和使用 C++ 标准库的正则表达式功能。
⑤ 易用性:
Boost.Regex 库提供了简洁易用的 API 接口，主要包括：
⚝ boost::regex 类：表示正则表达式对象。
⚝ boost::smatch 类：用于存储匹配结果。
⚝ boost::regex_match 函数：用于完全匹配。
⚝ boost::regex_search 函数：用于搜索匹配。
⚝ boost::regex_replace 函数：用于替换操作。
⚝ boost::regex_iterator 和 boost::regex_token_iterator 类：用于迭代匹配。
这些 API 接口设计清晰，文档完善，易于学习和使用。
⑥ 活跃的社区支持:
Boost 社区非常活跃，提供了及时的技术支持和 bug 修复。Boost.Regex 库也在不断更新和完善，保持了与时俱进。
总而言之，Boost.Regex 库是一个功能强大、性能优秀、跨平台、易用且具有良好社区支持的 C++ 正则表达式库，是进行 C++ 文本处理的理想选择。
1.4.3 第一个 Boost.Regex 程序（Your First Boost.Regex Program）
为了快速入门 Boost.Regex 库，我们编写一个简单的程序，演示如何使用 Boost.Regex 进行正则表达式匹配。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Hello, Boost.Regex!";
7
boost::regex pattern("Boost\\.Regex"); // 匹配 "Boost.Regex"，注意点号需要转义
8
bool matched = boost::regex_search(text, pattern);
9
10
if (matched) {
11
std::cout << "Text: \"" << text << "\" matches the pattern \"" << pattern << "\"" << std::endl;
12
} else {
13
std::cout << "Text: \"" << text << "\" does not match the pattern \"" << pattern << "\"" << std::endl;
14
}
15
16
return 0;
17
}
代码解释:
⚝ #include <boost/regex.hpp>: 引入 Boost.Regex 库的头文件。
⚝ boost::regex pattern("Boost\\.Regex"): 创建一个 boost::regex 对象 pattern，表示正则表达式模式 "Boost.Regex"。注意，由于点号 . 在正则表达式中是元字符，需要使用反斜杠 \ 进行转义，才能匹配字面意义的点号。在 C++ 字符串字面量中，反斜杠本身也需要转义，因此写成 \\.。或者，可以使用原始字符串字面量 R"(Boost\.Regex)"，避免反斜杠转义的麻烦。
⚝ boost::regex_search(text, pattern): 使用 boost::regex_search 函数在字符串 text 中搜索匹配 pattern 的子串。如果找到匹配的子串，函数返回 true，否则返回 false。
⚝ 根据 boost::regex_search 函数的返回值，输出相应的匹配结果。
编译并运行这段代码，如果 Boost.Regex 库配置正确，应该输出：
1
Text: "Hello, Boost.Regex!" matches the pattern "Boost\.Regex"
这个简单的例子演示了 Boost.Regex 库的基本用法：创建 boost::regex 对象表示正则表达式模式，使用 boost::regex_search 函数进行匹配。在接下来的章节中，我们将深入学习 Boost.Regex 库的更多功能和用法，掌握更高级的正则表达式处理技巧。
END_OF_CHAPTER
2. chapter 2： Boost.Regex 基础：匹配与查找（Boost.Regex Basics: Matching and Searching）
2.1 regex 类：正则表达式对象（The regex Class: Regular Expression Object）
在 Boost.Regex 库中，regex 类是核心组件，它代表一个正则表达式对象（regular expression object）。你可以将正则表达式模式（pattern）编译成 regex 对象，然后使用这个对象进行各种匹配、查找和替换操作。regex 类的设计使得正则表达式的处理既高效又灵活。
主要功能：
⚝ 存储正则表达式模式：regex 对象内部存储了编译后的正则表达式模式，这个模式可以是字符串形式。
⚝ 正则表达式编译：当你创建一个 regex 对象时，Boost.Regex 库会对你提供的正则表达式字符串进行编译，将其转换为一种内部表示，以便后续的匹配操作可以快速执行。
⚝ 选项配置：regex 类允许你在编译正则表达式时设置各种选项，例如忽略大小写、使用扩展语法等，这些选项会影响正则表达式的匹配行为。
⚝ 异常处理：如果提供的正则表达式字符串不符合语法规则，regex 类的构造函数会抛出 regex_error 类型的异常，你需要妥善处理这些异常。
如何创建 regex 对象：
创建 regex 对象非常简单，你只需要包含 <boost/regex.hpp> 头文件，并使用 regex 类的构造函数即可。
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
// 创建一个 regex 对象，模式为 "hello"
7
boost::regex reg("hello");
8
9
// 创建一个 regex 对象，模式为 "world"，并忽略大小写
10
boost::regex reg_icase("world", boost::regex::icase);
11
12
// 使用原始字符串字面量创建 regex 对象，模式为 "\d+" (匹配一个或多个数字)
13
boost::regex reg_raw(R"(\d+)");
14
15
std::cout << "Regex objects created successfully!" << std::endl;
16
return 0;
17
}
代码解释：
⚝ boost::regex reg("hello");：这行代码创建了一个 regex 对象 reg，并将正则表达式模式 "hello" 编译到这个对象中。默认情况下，正则表达式的语法是 ECMAScript，并且区分大小写。
⚝ boost::regex reg_icase("world", boost::regex::icase);：这行代码创建了另一个 regex 对象 reg_icase，模式为 "world"，但是通过第二个参数 boost::regex::icase，我们指定了匹配时忽略大小写（ignore case）。boost::regex::icase 是 regex_constants::syntax_option_type 枚举类型的一个值，用于设置正则表达式的语法选项。
⚝ boost::regex reg_raw(R"(\d+)");：这行代码使用了 原始字符串字面量（raw string literal） R"(\d+)" 来定义正则表达式模式。使用原始字符串字面量的好处是可以避免反斜杠 \ 的转义，使得正则表达式模式更加清晰易读，尤其是在正则表达式中包含大量反斜杠时，例如表示数字的 \d。
常用的 regex 构造函数选项：
regex 类的构造函数可以接受第二个参数，用于指定正则表达式的语法选项。常用的选项包括：
⚝ boost::regex::icase：忽略大小写（case-insensitive）。
⚝ boost::regex::extended：使用扩展的正则表达式语法（extended syntax），例如支持 (?#comment) 形式的注释和空白字符的忽略。
⚝ boost::regex::basic：使用基本的正则表达式语法（basic syntax），通常与 extended 互斥。
⚝ boost::regex::nosubs：禁止子表达式捕获（no sub-expressions），可以提高性能，如果你不需要使用捕获组。
⚝ boost::regex::optimize：优化正则表达式的匹配速度，可能会增加编译时间。
⚝ boost::regex::collate：使用当前区域设置（locale）进行比较。
你可以使用 按位或运算符 | 组合多个选项。例如，要同时忽略大小写并使用扩展语法，可以这样写：
1
boost::regex reg_options("pattern", boost::regex::icase | boost::regex::extended);
总结：
regex 类是 Boost.Regex 库的基石，理解 regex 类的作用和用法是学习 Boost.Regex 的第一步。通过 regex 类，你可以将正则表达式模式编译成对象，并配置各种选项，为后续的匹配和查找操作做好准备。在实际应用中，根据不同的需求选择合适的正则表达式语法和选项，可以提高代码的效率和可读性。
2.2 smatch 类：匹配结果容器（The smatch Class: Match Result Container）
smatch 类在 Boost.Regex 中扮演着匹配结果容器（match result container）的角色。当我们使用 regex_match 或 regex_search 函数进行正则表达式匹配时，匹配的结果，包括整个匹配的字符串以及任何捕获的子表达式，都会被存储在一个 smatch 对象中。smatch 提供了一种结构化的方式来访问和处理这些匹配结果。
主要功能：
⚝ 存储匹配结果：smatch 对象存储了正则表达式匹配操作的结果。
⚝ 访问整个匹配：可以访问整个正则表达式匹配到的字符串。
⚝ 访问捕获组：如果正则表达式中使用了捕获组（capturing groups），smatch 对象可以存储并允许你访问每个捕获组匹配到的子字符串。
⚝ 检查匹配状态：可以检查匹配是否成功。
⚝ 迭代访问捕获组：smatch 对象可以像数组一样访问，索引 0 代表整个匹配，索引 1, 2, 3, ... 代表第一个、第二个、第三个捕获组。
smatch 的基本用法：
通常，smatch 对象会作为参数传递给 regex_match 或 regex_search 函数，用于接收匹配结果。
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
std::string text = "My email is user@example.com";
7
boost::regex reg(R"(([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,}))"); // 匹配邮箱的正则表达式，包含两个捕获组
8
boost::smatch match; // 声明一个 smatch 对象
9
10
if (boost::regex_search(text, match, reg)) { // 使用 regex_search 进行搜索匹配，并将结果存储在 match 中
11
std::cout << "匹配成功！" << std::endl;
12
std::cout << "整个匹配: " << match[0] << std::endl; // 访问整个匹配
13
std::cout << "用户名 (捕获组 1): " << match[1] << std::endl; // 访问第一个捕获组
14
std::cout << "域名 (捕获组 2): " << match[2] << std::endl; // 访问第二个捕获组
15
} else {
16
std::cout << "匹配失败！" << std::endl;
17
}
18
19
return 0;
20
}
代码解释：
⚝ boost::smatch match;：这行代码声明了一个 smatch 类型的对象 match。
⚝ if (boost::regex_search(text, match, reg))：regex_search 函数尝试在字符串 text 中搜索匹配正则表达式 reg 的部分。如果找到匹配，函数返回 true，并将匹配结果存储在 match 对象中。
⚝ match[0]：表示整个正则表达式匹配到的字符串。
⚝ match[1]：表示正则表达式中第一个捕获组匹配到的子字符串。在本例中，第一个捕获组是 ([a-zA-Z0-9._%+-]+)，用于捕获邮箱地址的用户名部分。
⚝ match[2]：表示正则表达式中第二个捕获组匹配到的子字符串。在本例中，第二个捕获组是 ([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})，用于捕获邮箱地址的域名部分。
smatch 的常用成员函数和操作：
⚝ match.size()：返回匹配结果的数量，包括整个匹配和所有捕获组。如果匹配失败，则返回 0。
⚝ match.empty()：检查 smatch 对象是否为空，如果为空，表示匹配失败。
⚝ match.prefix()：返回匹配字符串之前的子字符串的 ssub_match 对象。
⚝ match.suffix()：返回匹配字符串之后的子字符串的 ssub_match 对象。
⚝ match[n]：访问索引为 n 的 ssub_match 对象，其中 n=0 表示整个匹配，n>0 表示第 n 个捕获组。
⚝ match.begin() 和 match.end()：返回迭代器，可以遍历所有的 ssub_match 对象。
ssub_match 类：
smatch 对象实际上是一个 ssub_match 对象的容器。ssub_match 类代表一个子匹配（sub-match），它可以是整个匹配，也可以是某个捕获组的匹配。ssub_match 对象主要包含以下信息：
⚝ 匹配的字符串：可以通过 ssub_match 对象转换为 std::string 来获取匹配的字符串。
⚝ 匹配是否成功：ssub_match 对象可以指示对应的子表达式是否参与了匹配。
⚝ 匹配字符串的起始和结束位置：可以获取匹配字符串在原始字符串中的起始和结束位置。
总结：
smatch 类是 Boost.Regex 库中用于存储和访问正则表达式匹配结果的关键类。通过 smatch 对象，你可以方便地获取整个匹配的字符串以及各个捕获组匹配的子字符串，并进行进一步的处理。理解 smatch 类的结构和用法，对于有效地使用 Boost.Regex 进行文本处理至关重要。
2.3 regex_match 函数：完全匹配（The regex_match Function: Full Match）
regex_match 函数是 Boost.Regex 库中用于执行完全匹配（full match）操作的函数。完全匹配意味着正则表达式必须与整个输入序列完全匹配，才能算作成功。如果正则表达式只能匹配输入序列的一部分，regex_match 将返回失败。
函数签名：
regex_match 函数有多个重载版本，最常用的形式如下：
1
namespace boost {
2
namespace regex_match_ns {
3
bool regex_match(const charT* str, match_results<BidirectionalIterator<charT> >& m, const basic_regex<charT, traits>& e, match_flag_type flags = match_default);
4
5
template <class BidirectionalIterator, class Allocator, class charT, class traits, class match_flags>
6
bool regex_match(BidirectionalIterator first, BidirectionalIterator last, match_results<BidirectionalIterator>& m, const basic_regex<charT, traits>& e, match_flags flags = match_default);
7
8
template <class charT, class Allocator, class traits, class match_flags>
9
bool regex_match(const charT* str, match_results<const charT*>& m, const basic_regex<charT, traits>& e, match_flags flags = match_default);
10
11
template <class string_type, class Allocator, class traits, class match_flags>
12
bool regex_match(const string_type& s, match_results<typename string_type::const_iterator>& m, const basic_regex<typename string_type::char_type, traits>& e, match_flags flags = match_default);
13
}}
常用参数解释：
⚝ str 或 first, last：输入序列，可以是 C 风格字符串 const char*，也可以是 std::string 对象，或者是一对迭代器 first 和 last，用于指定输入序列的范围。
⚝ m：match_results 对象，用于存储匹配结果，通常使用 smatch 类型。匹配成功后，结果会存储在 m 中。
⚝ e：basic_regex 对象，即正则表达式对象，通常使用 regex 类型。
⚝ flags：匹配选项，match_flag_type 类型，例如 boost::regex_constants::match_flag_type::match_default (默认选项) 或其他选项，用于控制匹配行为，例如是否考虑换行符、是否锚定匹配等。
使用示例：
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
std::string text1 = "hello world";
7
std::string text2 = "hello world extra";
8
boost::regex reg("hello world"); // 正则表达式模式为 "hello world"
9
boost::smatch match;
10
11
// 示例 1：完全匹配 text1
12
if (boost::regex_match(text1, match, reg)) {
13
std::cout << "\"" << text1 << "\" 完全匹配正则表达式 \"" << reg << "\"" << std::endl;
14
} else {
15
std::cout << "\"" << text1 << "\" 不完全匹配正则表达式 \"" << reg << "\"" << std::endl;
16
}
17
18
// 示例 2：尝试完全匹配 text2
19
if (boost::regex_match(text2, match, reg)) {
20
std::cout << "\"" << text2 << "\" 完全匹配正则表达式 \"" << reg << "\"" << std::endl;
21
} else {
22
std::cout << "\"" << text2 << "\" 不完全匹配正则表达式 \"" << reg << "\"" << std::endl;
23
}
24
25
return 0;
26
}
代码输出：
1
"hello world" 完全匹配正则表达式 "hello world"
2
"hello world extra" 不完全匹配正则表达式 "hello world"
代码解释：
⚝ 在示例 1 中，text1 的内容 "hello world" 与正则表达式 "hello world" 完全一致，因此 regex_match 返回 true，表示完全匹配成功。
⚝ 在示例 2 中，text2 的内容 "hello world extra" 虽然包含正则表达式 "hello world"，但由于 text2 的末尾还有 " extra"，导致整个字符串与正则表达式不完全匹配，因此 regex_match 返回 false。
应用场景：
regex_match 函数适用于需要严格验证输入的场景，例如：
⚝ 验证用户输入的格式：例如，验证用户输入的邮政编码、身份证号码、日期格式等是否符合预定义的格式。
⚝ 协议解析：在网络协议或文件格式解析中，需要确保整个数据包或数据行符合特定的结构。
⚝ 命令解析：解析用户输入的命令，确保命令的语法和格式完全正确。
与 regex_search 的区别：
regex_match 和 regex_search 是 Boost.Regex 中两个核心的匹配函数，它们的主要区别在于：
⚝ regex_match (完全匹配)：要求正则表达式必须匹配整个输入序列。
⚝ regex_search (搜索匹配)：只需要正则表达式匹配输入序列的任何部分即可。
选择使用 regex_match 还是 regex_search 取决于你的需求。如果你需要验证整个输入是否符合某个模式，应该使用 regex_match。如果你需要在输入中查找符合某个模式的子串，应该使用 regex_search。
总结：
regex_match 函数是 Boost.Regex 库中用于执行完全匹配的关键函数。它要求正则表达式必须与整个输入序列完全匹配，常用于严格的输入验证和协议解析等场景。理解 regex_match 的完全匹配特性，并区分它与 regex_search 的区别，可以帮助你更准确地选择合适的匹配函数，解决实际问题。
2.4 regex_search 函数：搜索匹配（The regex_search Function: Search Match）
regex_search 函数是 Boost.Regex 库中用于执行搜索匹配（search match）操作的函数。搜索匹配意味着 regex_search 会在输入序列中查找与正则表达式匹配的任何子序列。只要在输入序列中找到至少一个匹配的子序列，regex_search 就返回成功。
函数签名：
regex_search 函数也具有多个重载版本，常用的形式与 regex_match 类似：
1
namespace boost {
2
namespace regex_match_ns { // 注意这里仍然在 regex_match_ns 命名空间，实际上 regex_search 和 regex_match 在同一个命名空间下
3
bool regex_search(const charT* str, match_results<BidirectionalIterator<charT> >& m, const basic_regex<charT, traits>& e, match_flag_type flags = match_default);
4
5
template <class BidirectionalIterator, class Allocator, class charT, class traits, class match_flags>
6
bool regex_search(BidirectionalIterator first, BidirectionalIterator last, match_results<BidirectionalIterator>& m, const basic_regex<charT, traits>& e, match_flags flags = match_default);
7
8
template <class charT, class Allocator, class traits, class match_flags>
9
bool regex_search(const charT* str, match_results<const charT*>& m, const basic_regex<charT, traits>& e, match_flags flags = match_default);
10
11
template <class string_type, class Allocator, class traits, class match_flags>
12
bool regex_search(const string_type& s, match_results<typename string_type::const_iterator>& m, const basic_regex<typename string_type::char_type, traits>& e, match_flags flags = match_default);
13
}}
常用参数解释：
regex_search 函数的参数与 regex_match 函数的参数基本相同，含义也一致：
⚝ str 或 first, last：输入序列。
⚝ m：match_results 对象，用于存储匹配结果，通常使用 smatch 类型。
⚝ e：basic_regex 对象，即正则表达式对象，通常使用 regex 类型。
⚝ flags：匹配选项，match_flag_type 类型。
使用示例：
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
std::string text1 = "This is a test string with number 123.";
7
std::string text2 = "No numbers here.";
8
boost::regex reg("\\d+"); // 正则表达式模式为 "\\d+"，匹配一个或多个数字
9
boost::smatch match;
10
11
// 示例 1：在 text1 中搜索数字
12
if (boost::regex_search(text1, match, reg)) {
13
std::cout << "在 \"" << text1 << "\" 中找到匹配: \"" << match[0] << "\"" << std::endl;
14
} else {
15
std::cout << "在 \"" << text1 << "\" 中未找到匹配" << std::endl;
16
}
17
18
// 示例 2：在 text2 中搜索数字
19
if (boost::regex_search(text2, match, reg)) {
20
std::cout << "在 \"" << text2 << "\" 中找到匹配: \"" << match[0] << "\"" << std::endl;
21
} else {
22
std::cout << "在 \"" << text2 << "\" 中未找到匹配" << std::endl;
23
}
24
25
return 0;
26
}
代码输出：
1
在 "This is a test string with number 123." 中找到匹配: "123"
2
在 "No numbers here." 中未找到匹配
代码解释：
⚝ 在示例 1 中，text1 包含子字符串 "123"，它与正则表达式 "\\d+" 匹配。regex_search 在 text1 中找到了这个匹配，因此返回 true，并将匹配结果 "123" 存储在 match[0] 中。
⚝ 在示例 2 中，text2 不包含任何数字，因此 regex_search 在 text2 中找不到与正则表达式 "\\d+" 匹配的子序列，返回 false。
应用场景：
regex_search 函数适用于需要在文本中查找特定模式的场景，例如：
⚝ 日志分析：在日志文件中搜索特定的错误信息、警告信息或关键词。
⚝ 文本提取：从网页、文档或其他文本数据中提取特定的信息，例如邮箱地址、URL、电话号码等。
⚝ 数据挖掘：在大量文本数据中发现符合特定模式的数据。
⚝ 文本编辑器中的查找功能：实现文本编辑器中的查找功能，用户可以输入正则表达式来查找文本。
迭代搜索：
regex_search 默认只查找第一个匹配项。如果需要查找所有匹配项，可以使用循环结合 regex_search 和 smatch 对象的 suffix() 方法。每次找到匹配后，将 smatch.suffix() 返回的后缀字符串作为下一次 regex_search 的输入，直到找不到更多匹配为止。
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
std::string text = "Find all numbers: 123, 456, 789.";
7
boost::regex reg("\\d+");
8
boost::smatch match;
9
std::string::const_iterator start = text.cbegin();
10
std::string::const_iterator end = text.cend();
11
12
std::cout << "找到的数字: ";
13
while (boost::regex_search(start, end, match, reg)) {
14
std::cout << match[0] << " ";
15
start = match.suffix().first; // 更新搜索起始位置为上一次匹配的末尾
16
}
17
std::cout << std::endl;
18
19
return 0;
20
}
代码输出：
1
找到的数字: 123 456 789
代码解释：
⚝ start = match.suffix().first;：这行代码是迭代搜索的关键。match.suffix() 返回一个 ssub_match 对象，表示匹配字符串之后的后缀部分。match.suffix().first 返回后缀字符串的起始迭代器，将其赋值给 start，使得下一次 regex_search 从上一次匹配的结束位置之后开始搜索，从而找到所有匹配项。
总结：
regex_search 函数是 Boost.Regex 库中用于执行搜索匹配的核心函数。它在输入序列中查找与正则表达式匹配的任何子序列，适用于各种文本处理场景，例如日志分析、文本提取和数据挖掘等。通过结合循环和 smatch.suffix() 方法，可以实现迭代搜索，查找所有匹配项。理解 regex_search 的搜索匹配特性和迭代搜索方法，可以让你更灵活地使用 Boost.Regex 处理复杂的文本搜索任务。
2.5 使用字面量和原始字符串（Using Literal and Raw Strings）
在 Boost.Regex 中，正则表达式模式通常以字符串的形式提供给 regex 类的构造函数以及 regex_match 和 regex_search 等函数。C++ 提供了两种主要的字符串字面量形式：普通字符串字面量（literal string literal） 和 原始字符串字面量（raw string literal）。理解它们的区别以及在正则表达式中的应用场景，可以帮助你更有效地编写和维护正则表达式代码。
普通字符串字面量：
普通字符串字面量是最常见的字符串表示形式，使用双引号 " 包围。在普通字符串字面量中，反斜杠 \ 被用作转义字符（escape character），用于表示特殊字符，例如：
⚝ \n：换行符（newline）
⚝ \t：制表符（tab）
⚝ \\：反斜杠字符本身
⚝ \"：双引号字符
问题：反斜杠的冲突
在正则表达式中，反斜杠 \ 也被广泛用作元字符（metacharacter）的起始符号，用于表示特殊的字符类、锚点、量词等，例如：
⚝ \d：匹配数字
⚝ \w：匹配单词字符
⚝ \s：匹配空白字符
⚝ \b：单词边界
当正则表达式模式写在普通字符串字面量中时，就会出现反斜杠冲突。例如，如果你想在正则表达式中表示 \d (匹配数字)，你需要双重转义反斜杠，写成 "\\d"。
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
std::string text = "Number: 123";
7
boost::regex reg_literal("\\d+"); // 使用普通字符串字面量，需要双重转义反斜杠
8
boost::smatch match;
9
10
if (boost::regex_search(text, match, reg_literal)) {
11
std::cout << "使用普通字符串字面量找到数字: " << match[0] << std::endl;
12
}
13
14
return 0;
15
}
原始字符串字面量：
为了解决普通字符串字面量中反斜杠转义带来的问题，C++11 引入了原始字符串字面量。原始字符串字面量使用 R"(...)" 的形式表示，其中 (...) 内的字符不会被转义，反斜杠 \ 就表示普通的反斜杠字符本身。
优点：避免反斜杠转义
使用原始字符串字面量可以避免正则表达式中的反斜杠被错误地解释为转义字符，使得正则表达式模式更加清晰易读，尤其是在正则表达式中包含大量反斜杠时，例如文件路径、复杂的模式匹配等。
1
#include <boost/regex.hpp>
2
#include <iostream>
3
#include <string>
4
5
int main() {
6
std::string text = "Number: 123";
7
boost::regex reg_raw(R"(\d+)"); // 使用原始字符串字面量，无需转义反斜杠
8
boost::smatch match;
9
10
if (boost::regex_search(text, match, reg_raw)) {
11
std::cout << "使用原始字符串字面量找到数字: " << match[0] << std::endl;
12
}
13
14
return 0;
15
}
代码对比：
对比上面的两个代码示例，可以看到：
⚝ 使用普通字符串字面量时，正则表达式 "\\d+" 中的反斜杠需要双重转义，写成 "\\\\d+" 才能正确表示 \d。
⚝ 使用原始字符串字面量时，正则表达式 R"(\d+)" 中的反斜杠无需转义，直接写成 \d 即可，更加直观。
选择使用哪种字面量？
⚝ 简单正则表达式：如果正则表达式模式比较简单，不包含大量的反斜杠，可以使用普通字符串字面量，但需要注意反斜杠的转义。
⚝ 复杂正则表达式：如果正则表达式模式比较复杂，包含大量的反斜杠，或者需要表示文件路径、网络路径等，强烈建议使用原始字符串字面量，以避免反斜杠转义带来的混乱和错误。
示例：匹配 Windows 文件路径
假设我们需要匹配 Windows 文件路径，例如 C:\Program Files\Example\file.txt。使用普通字符串字面量和原始字符串字面量分别表示正则表达式：
⚝ 普通字符串字面量："C:\\\\Program Files\\\\Example\\\\file\\.txt" (需要四个反斜杠表示一个普通反斜杠)
⚝ 原始字符串字面量：R"(C:\Program Files\Example\file\.txt)" (一个反斜杠就表示一个普通反斜杠)
可以看到，使用原始字符串字面量表示文件路径正则表达式，代码更加简洁易懂，也更不容易出错。
总结：
理解普通字符串字面量和原始字符串字面量的区别，并根据正则表达式的复杂程度和反斜杠的使用情况，选择合适的字符串字面量形式，可以提高正则表达式代码的可读性和可维护性。对于包含大量反斜杠的复杂正则表达式，原始字符串字面量是更佳的选择。
END_OF_CHAPTER
3. chapter 3： 正则表达式语法详解（Detailed Regular Expression Syntax）
3.1 字符匹配（Character Matching）
正则表达式的核心功能之一是字符匹配，它允许我们精确或模糊地指定要查找的字符模式。理解字符匹配是掌握正则表达式的基础。
3.1.1 普通字符与元字符（Ordinary Characters and Metacharacters）
在正则表达式中，字符被分为两种基本类型：普通字符（Ordinary Characters） 和 元字符（Metacharacters）。
① 普通字符（Ordinary Characters）
普通字符是最常见的字符，包括所有字母（a-z, A-Z）、数字（0-9）以及下划线(_)。当一个普通字符出现在正则表达式中时，它就精确匹配文本中与之相同的字符。
例如，正则表达式 abc 会精确匹配文本中的 "abc" 字符串。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a test string abc.";
7
boost::regex pattern("abc");
8
bool found = boost::regex_search(text, pattern);
9
if (found) {
10
std::cout << "找到匹配项" << std::endl; // 输出：找到匹配项
11
} else {
12
std::cout << "未找到匹配项" << std::endl;
13
}
14
return 0;
15
}
② 元字符（Metacharacters）
元字符是正则表达式中具有特殊含义的字符。它们不代表字面意义上的字符本身，而是用于控制匹配模式、指定匹配位置或重复次数等。正是元字符赋予了正则表达式强大的灵活性和表达能力。
常见的元字符包括：
⚝ . 点号
⚝ ^ 脱字符
⚝ $ 美元符号
⚝ * 星号
⚝ + 加号
⚝ ? 问号
⚝ \ 反斜杠
⚝ [] 方括号
⚝ () 圆括号
⚝ {} 花括号
⚝ | 竖线
如果要在正则表达式中匹配元字符本身（例如，你想查找文本中的点号 . 而不是任意字符），需要使用反斜杠 \ 进行转义。
例如，要匹配文本中的 . 字符，正则表达式应写成 \.。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a test string with a dot.";
7
boost::regex pattern("\\."); // 注意：C++ 字符串中 \ 也需要转义，所以是 \\.
8
boost::smatch match;
9
bool found = boost::regex_search(text, match, pattern);
10
if (found) {
11
std::cout << "找到匹配项: " << match.str() << std::endl; // 输出：找到匹配项: .
12
} else {
13
std::cout << "未找到匹配项" << std::endl;
14
}
15
return 0;
16
}
理解普通字符和元字符的区别是编写正则表达式的第一步。掌握元字符的含义和用法，才能构建复杂的匹配模式。在后续章节中，我们将详细介绍各种元字符的功能和应用。
3.1.2 字符类（Character Classes）
字符类（Character Classes），也称为字符集（Character Sets） 或 方括号表达式（Bracket Expressions），允许你定义一个字符集合，正则表达式将匹配该集合中的任意一个字符。字符类使用方括号 [] 来定义。
① 基本字符类
在方括号 [] 中列出的字符构成一个字符类。例如：
⚝ [abc]：匹配字符 'a'、'b' 或 'c' 中的任意一个。
⚝ [0123456789]：匹配任意一个数字字符。
⚝ [aeiou]：匹配任意一个英文元音字母。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Match a, b, or c here: a b d c";
7
boost::regex pattern("[abc]");
8
boost::smatch match;
9
std::cout << "匹配到的字符: ";
10
std::string::const_iterator start = text.begin();
11
std::string::const_iterator end = text.end();
12
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << " "; // 输出：匹配到的字符: a b c
15
start = match[0].second; // 从上一个匹配项之后继续搜索
16
}
17
std::cout << std::endl;
18
return 0;
19
}
② 字符范围
对于连续的字符序列（如字母或数字），可以使用连字符 - 来表示范围，从而简化字符类的定义。
⚝ [a-z]：匹配任意一个小写字母（从 'a' 到 'z'）。
⚝ [A-Z]：匹配任意一个大写字母（从 'A' 到 'Z'）。
⚝ [0-9]：匹配任意一个数字（从 '0' 到 '9'），等价于 \d 预定义字符类。
⚝ [a-zA-Z0-9]：匹配任意一个字母或数字。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Numbers and letters: 1 2 a B 3 c D 4";
7
boost::regex pattern("[a-zA-Z0-9]");
8
boost::smatch match;
9
std::cout << "匹配到的字符: ";
10
std::string::const_iterator start = text.begin();
11
std::string::const_iterator end = text.end();
12
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << " "; // 输出：匹配到的字符: 1 2 a B 3 c D 4
15
start = match[0].second;
16
}
17
std::cout << std::endl;
18
return 0;
19
}
③ 排除型字符类
在字符类的方括号 [ 后紧跟一个脱字符 ^，可以创建一个排除型字符类（Negated Character Class）。排除型字符类匹配不在方括号内列出的任何字符。
⚝ [^abc]：匹配除了 'a'、'b' 和 'c' 之外的任意字符。
⚝ [^0-9]：匹配任意一个非数字字符，等价于 \D 预定义字符类。
⚝ [^aeiouAEIOU]：匹配任意一个非元音字母字符。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Non-digits: 1 a 2 b 3 c";
7
boost::regex pattern("[^0-9]"); // 匹配非数字字符
8
boost::smatch match;
9
std::cout << "匹配到的非数字字符: ";
10
std::string::const_iterator start = text.begin();
11
std::string::const_iterator end = text.end();
12
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << " "; // 输出：匹配到的非数字字符: a b c
15
start = match[0].second;
16
}
17
std::cout << std::endl;
18
return 0;
19
}
④ 字符类中的元字符
在字符类 [] 内部，一些元字符会失去其特殊含义，而被当作普通字符处理。例如：
⚝ [.]：在字符类中，. 就是字面意义的点号，而不是任意字符的通配符。
⚝ [-]：除非 - 出现在字符类的开头或结尾，或者被转义，否则它表示字符范围。例如 [a-z] 中的 - 表示范围，而 [abc-] 或 [-abc] 中的 - 则表示字面意义的连字符。
⚝ [^]：只有当 ^ 出现在字符类的开头时，才表示排除型字符类。在字符类中的其他位置，^ 仅代表字面意义的脱字符。
⚝ [\\]：反斜杠 \ 在字符类中仍然是转义字符。要匹配字面意义的反斜杠，需要写成 [\\]。
⚝ [] 和 \ 在字符类内部仍然需要转义，例如要匹配 [ 需要写成 \[`，匹配 `]` 需要写成 `\]。
理解字符类的用法，可以更灵活地定义匹配模式，匹配特定集合内的字符，或排除特定集合外的字符。
3.1.3 预定义字符类（Predefined Character Classes）
为了方便常用字符类的使用，正则表达式提供了一些预定义字符类（Predefined Character Classes），也称为简写字符类（Shorthand Character Classes）。这些预定义字符类使用反斜杠 \ 开头，后跟一个特定字符来表示一类字符。
① 数字字符：\d 和 \D
⚝ \d（digit）：匹配任意一个数字字符，等价于字符类 [0-9]。
⚝ \D（non-digit）：匹配任意一个非数字字符，等价于排除型字符类 [^0-9]。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Digits: 123, Non-digits: abc";
7
boost::regex digit_pattern("\\d");
8
boost::regex non_digit_pattern("\\D");
9
boost::smatch match;
10
11
std::cout << "数字字符: ";
12
std::string::const_iterator start = text.begin();
13
std::string::const_iterator end = text.end();
14
while (boost::regex_search(start, end, match, digit_pattern)) {
15
std::cout << match.str() << " "; // 输出：数字字符: 1 2 3
16
start = match[0].second;
17
}
18
std::cout << std::endl;
19
20
std::cout << "非数字字符: ";
21
start = text.begin();
22
while (boost::regex_search(start, end, match, non_digit_pattern)) {
23
std::cout << match.str() << " "; // 输出：非数字字符: : , N o n - d i g i t s : a b c
24
start = match[0].second;
25
}
26
std::cout << std::endl;
27
28
return 0;
29
}
② 单词字符：\w 和 \W
⚝ \w（word character）：匹配任意一个单词字符，包括字母、数字和下划线，等价于字符类 [a-zA-Z0-9_]。
⚝ \W（non-word character）：匹配任意一个非单词字符，等价于排除型字符类 [^a-zA-Z0-9_]。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Word characters: abc_123, Non-word: !@#$";
7
boost::regex word_pattern("\\w");
8
boost::regex non_word_pattern("\\W");
9
boost::smatch match;
10
11
std::cout << "单词字符: ";
12
std::string::const_iterator start = text.begin();
13
std::string::const_iterator end = text.end();
14
while (boost::regex_search(start, end, match, word_pattern)) {
15
std::cout << match.str() << " "; // 输出：单词字符: W o r d c h a r a c t e r s : a b c _ 1 2 3
16
start = match[0].second;
17
}
18
std::cout << std::endl;
19
20
std::cout << "非单词字符: ";
21
start = text.begin();
22
while (boost::regex_search(start, end, match, non_word_pattern)) {
23
std::cout << match.str() << " "; // 输出：非单词字符: : , N o n - w o r d : ! @ # $
24
start = match[0].second;
25
}
26
std::cout << std::endl;
27
28
return 0;
29
}
③ 空白字符：\s 和 \S
⚝ \s（whitespace character）：匹配任意一个空白字符，包括空格符、制表符、换行符、回车符等。具体包含哪些空白字符可能因正则表达式引擎和 locale 设置而异，但通常包括 [ \t\n\r\f\v]。
⚝ \S（non-whitespace character）：匹配任意一个非空白字符，等价于排除型字符类 [^ \t\n\r\f\v]。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Whitespace: \t\n , Non-whitespace: abc";
7
boost::regex whitespace_pattern("\\s");
8
boost::regex non_whitespace_pattern("\\S");
9
boost::smatch match;
10
11
std::cout << "空白字符: ";
12
std::string::const_iterator start = text.begin();
13
std::string::const_iterator end = text.end();
14
while (boost::regex_search(start, end, match, whitespace_pattern)) {
15
std::cout << match.str() << " "; // 输出：空白字符: \t \n
16
start = match[0].second;
17
}
18
std::cout << std::endl;
19
20
std::cout << "非空白字符: ";
21
start = text.begin();
22
while (boost::regex_search(start, end, match, non_whitespace_pattern)) {
23
std::cout << match.str() << " "; // 输出：非空白字符: W h i t e s p a c e : , N o n - w h i t e s p a c e : a b c
24
start = match[0].second;
25
}
26
std::cout << std::endl;
27
28
return 0;
29
}
④ 其他预定义字符类
⚝ \t：制表符（Tab）。
⚝ \n：换行符（Newline）。
⚝ \r：回车符（Carriage Return）。
⚝ \f：换页符（Form Feed）。
⚝ \v：垂直制表符（Vertical Tab）。
⚝ \xhh：匹配 ASCII 码为十六进制数 hh 的字符。例如，\x41 匹配字符 'A'。
⚝ \uhhhh：匹配 Unicode 码为十六进制数 hhhh 的字符。例如，\u0041 匹配字符 'A'。
⚝ \ooo：匹配 ASCII 码为八进制数 ooo 的字符。例如，\101 匹配字符 'A'。
预定义字符类简化了正则表达式的编写，提高了可读性，并能更方便地匹配常见的字符类别。在实际应用中，应根据需求灵活选择使用字符类、预定义字符类或它们的组合。
3.2 量词（Quantifiers）
量词（Quantifiers） 用于指定正则表达式中某个元素（可以是字符、字符类、分组等）可以重复出现的次数。量词控制着匹配的数量，使得正则表达式能够匹配长度不固定的文本模式。
3.2.1 贪婪量词、懒惰量词和占有量词（Greedy, Lazy, and Possessive Quantifiers）
正则表达式的量词主要分为三种类型：贪婪量词（Greedy Quantifiers）、懒惰量词（Lazy Quantifiers） 和 占有量词（Possessive Quantifiers）。它们在匹配策略上有所不同，理解这些差异对于编写精确且高效的正则表达式至关重要。
① 贪婪量词（Greedy Quantifiers）
贪婪量词会尽可能多地匹配字符，直到匹配失败才回溯。这是正则表达式量词的默认行为。
常见的贪婪量词包括：
⚝ *：匹配零次或多次。
⚝ +：匹配一次或多次。
⚝ ?：匹配零次或一次。
⚝ {n}：匹配恰好 n 次。
⚝ {n,}：匹配至少 n 次。
⚝ {n,m}：匹配至少 n 次，至多 m 次。
例如，对于文本 "abbc"，正则表达式 ab*c 使用贪婪量词 * 匹配 'b' 零次或多次。它会尽可能多地匹配 'b'，因此会匹配到 "abbc" 中的 "abb" 部分，因为再多一个 'b' 就不能匹配后面的 'c' 了。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "abbc";
7
boost::regex pattern("ab*c"); // 贪婪量词 *
8
boost::smatch match;
9
bool found = boost::regex_search(text, match, pattern);
10
if (found) {
11
std::cout << "匹配到的字符串: " << match.str() << std::endl; // 输出：匹配到的字符串: abbc
12
} else {
13
std::cout << "未找到匹配项" << std::endl;
14
}
15
return 0;
16
}
② 懒惰量词（Lazy Quantifiers）
懒惰量词会尽可能少地匹配字符，一旦找到匹配就停止。懒惰量词通过在贪婪量词后面加上一个问号 ? 来构成。
对应的懒惰量词包括：
⚝ *?：懒惰匹配零次或多次。
⚝ +?：懒惰匹配一次或多次。
⚝ ??：懒惰匹配零次或一次。
⚝ {n}?：懒惰匹配恰好 n 次。
⚝ {n,}?：懒惰匹配至少 n 次。
⚝ {n,m}?：懒惰匹配至少 n 次，至多 m 次。
例如，对于文本 "abbc"，正则表达式 ab*?c 使用懒惰量词 *? 匹配 'b' 零次或多次。它会尽可能少地匹配 'b'，因此会匹配到 "abbc" 中的 "abc" 部分，虽然 "abbc" 也能匹配，但懒惰模式下，只要找到一个最短的匹配 "abc" 就停止了。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "abbc";
7
boost::regex pattern("ab*?c"); // 懒惰量词 *?
8
boost::smatch match;
9
bool found = boost::regex_search(text, match, pattern);
10
if (found) {
11
std::cout << "匹配到的字符串: " << match.str() << std::endl; // 输出：匹配到的字符串: abc
12
} else {
13
std::cout << "未找到匹配项" << std::endl;
14
}
15
return 0;
16
}
贪婪与懒惰模式的区别示例
考虑使用正则表达式 <.*> 匹配 HTML 标签。对于文本 <p>This is a paragraph.</p>：
⚝ 贪婪模式 (<.*>)：会尽可能多地匹配，从第一个 < 开始，一直匹配到最后一个 >，结果是 <p>This is a paragraph.</p>，这通常不是我们期望的，我们可能只想匹配单个标签。
⚝ 懒惰模式 (<.*?>)：会尽可能少地匹配，从第一个 < 开始，匹配到第一个 > 就停止，结果是 </p>，然后继续匹配，会找到 </p>。这样可以正确地匹配一对 HTML 标签。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "<p>This is a paragraph.</p>";
7
8
// 贪婪模式
9
boost::regex greedy_pattern("<.*>");
10
boost::smatch greedy_match;
11
boost::regex_search(text, greedy_match, greedy_pattern);
12
std::cout << "贪婪模式匹配: " << greedy_match.str() << std::endl; // 输出：贪婪模式匹配: <p>This is a paragraph.</p>
13
14
// 懒惰模式
15
boost::regex lazy_pattern("<.*?>");
16
boost::smatch lazy_match;
17
std::string::const_iterator start = text.begin();
18
std::string::const_iterator end = text.end();
19
std::cout << "懒惰模式匹配: ";
20
while (boost::regex_search(start, end, lazy_match, lazy_pattern)) {
21
std::cout << lazy_match.str() << " "; // 输出：懒惰模式匹配: <p> </p>
22
start = lazy_match[0].second;
23
}
24
std::cout << std::endl;
25
26
return 0;
27
}
③ 占有量词（Possessive Quantifiers）
占有量词类似于贪婪量词，也会尽可能多地匹配。但关键区别在于，占有量词不会回溯。一旦占有量词匹配了一部分文本，即使后续的正则表达式部分匹配失败，它也不会退回已匹配的部分重新尝试，而是直接导致整个匹配失败。占有量词通过在贪婪量词后面加上一个加号 + 来构成。
对应的占有量词包括：
⚝ *+：占有匹配零次或多次。
⚝ ++：占有匹配一次或多次。
⚝ ?+：占有匹配零次或一次。
⚝ {n}+：占有匹配恰好 n 次。
⚝ {n,}+：占有匹配至少 n 次。
⚝ {n,m}+：占有匹配至少 n 次，至多 m 次。
占有量词在性能优化方面有一定作用，因为它们避免了回溯，可以更快地报告匹配失败。但在功能上，占有量词不如贪婪和懒惰量词常用。Boost.Regex 库支持占有量词。
占有量词示例
考虑正则表达式 a*+bc 和文本 "abc"。
⚝ a*+ 会尽可能多地匹配 'a'，直到字符串末尾，即匹配了 "a"。
⚝ 此时，正则表达式剩余部分是 bc，但文本剩余部分是 "bc"。
⚝ 由于占有量词 a*+ 不会回溯，即使后续的 bc 无法匹配，a*+ 也不会退回已匹配的 "a" 重新尝试。
⚝ 因此，整个正则表达式 a*+bc 对文本 "abc" 的匹配会失败。
如果使用贪婪量词 a*bc，则会成功匹配 "abc"。因为贪婪量词 a* 匹配 "a" 后，如果后续的 bc 匹配失败，a* 会回溯，尝试匹配零个 'a'，然后 abc 就能成功匹配 "abc"。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "abc";
7
8
// 占有量词
9
boost::regex possessive_pattern("a*+bc");
10
boost::smatch possessive_match;
11
bool possessive_found = boost::regex_search(text, possessive_match, possessive_pattern);
12
if (possessive_found) {
13
std::cout << "占有量词匹配成功: " << possessive_match.str() << std::endl;
14
} else {
15
std::cout << "占有量词匹配失败" << std::endl; // 输出：占有量词匹配失败
16
}
17
18
// 贪婪量词
19
boost::regex greedy_pattern("a*bc");
20
boost::smatch greedy_match;
21
bool greedy_found = boost::regex_search(text, greedy_match, greedy_pattern);
22
if (greedy_found) {
23
std::cout << "贪婪量词匹配成功: " << greedy_match.str() << std::endl; // 输出：贪婪量词匹配成功: abc
24
} else {
25
std::cout << "贪婪量词匹配失败" << std::endl;
26
}
27
28
return 0;
29
}
理解贪婪、懒惰和占有量词的区别，可以更精确地控制正则表达式的匹配行为，并根据具体需求选择合适的量词类型。在大多数情况下，贪婪量词已能满足需求，但对于需要精确控制匹配长度或优化性能的场景，懒惰和占有量词也提供了有力的工具。
3.3 锚点（Anchors）
锚点（Anchors） 在正则表达式中用于匹配文本中的特定位置，而不是具体的字符。锚点本身不匹配任何字符，而是断言当前匹配位置是否符合某个条件。常用的锚点包括行起始符、行结束符和单词边界。
3.3.1 行起始符和行结束符（Start and End of Line Anchors）
行起始符 ^ 和行结束符 $ 是用于定位行首和行尾的锚点。
① 行起始符 ^
^ 锚点匹配一行的开始位置。在多行模式下，它匹配每一行的开始位置；在单行模式下，它只匹配整个输入文本的开始位置。默认情况下，Boost.Regex 使用单行模式。
例如，正则表达式 ^abc 匹配以 "abc" 开头的行。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "abc def\nabc ghi";
7
boost::regex pattern("^abc"); // 匹配行首的 "abc"
8
boost::smatch match;
9
10
std::cout << "匹配到的行首 'abc':" << std::endl;
11
std::string::const_iterator start = text.begin();
12
std::string::const_iterator end = text.end();
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << std::endl; // 输出：匹配到的行首 'abc': abc abc
15
start = match[0].second;
16
}
17
18
return 0;
19
}
② 行结束符 $
$ 锚点匹配一行的结束位置。类似于 ^，在多行模式下，它匹配每一行的结束位置；在单行模式下，它只匹配整个输入文本的结束位置。
例如，正则表达式 def$ 匹配以 "def" 结尾的行。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "abc def\nghi def";
7
boost::regex pattern("def$"); // 匹配行尾的 "def"
8
boost::smatch match;
9
10
std::cout << "匹配到的行尾 'def':" << std::endl;
11
std::string::const_iterator start = text.begin();
12
std::string::const_iterator end = text.end();
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << std::endl; // 输出：匹配到的行尾 'def': def def
15
start = match[0].second;
16
}
17
18
return 0;
19
}
多行模式
默认情况下，^ 和 $ 锚点匹配整个输入文本的开始和结束。如果需要让 ^ 和 $ 匹配每一行的开始和结束位置，需要启用多行模式（Multiline Mode）。在 Boost.Regex 中，可以通过 boost::regex::multiline 选项来启用多行模式。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "line1\nline2\nline3";
7
boost::regex pattern("^line\\d+$", boost::regex::multiline); // 多行模式，匹配以 "line" 开头，数字结尾的行
8
boost::smatch match;
9
10
std::cout << "多行模式匹配:" << std::endl;
11
std::string::const_iterator start = text.begin();
12
std::string::const_iterator end = text.end();
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << std::endl; // 输出：多行模式匹配: line1 line2 line3
15
start = match[0].second;
16
}
17
18
return 0;
19
}
3.3.2 单词边界（Word Boundaries）
单词边界 \b 和 非单词边界 \B 是用于定位单词边界的锚点。单词边界是指单词字符（\w）和非单词字符（\W）之间的位置，或者单词字符与行首/行尾之间的位置。
① 单词边界 \b
\b 锚点匹配单词边界。它断言当前位置是单词字符和非单词字符之间的边界。
例如，正则表达式 \bword\b 匹配完整单词 "word"，而不是 "keyword" 或 "wordy" 中的 "word" 部分。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a word boundary example. keyword wordy word.";
7
boost::regex pattern("\\bword\\b"); // 匹配完整单词 "word"
8
boost::smatch match;
9
10
std::cout << "匹配到的完整单词 'word':" << std::endl;
11
std::string::const_iterator start = text.begin();
12
std::string::const_iterator end = text.end();
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << std::endl; // 输出：匹配到的完整单词 'word': word word
15
start = match[0].second;
16
}
17
18
return 0;
19
}
② 非单词边界 \B
\B 锚点匹配非单词边界。它断言当前位置不是单词字符和非单词字符之间的边界。
例如，正则表达式 \Bword\B 匹配单词内部的 "word" 部分，例如 "keyword" 中的 "word"，但不匹配完整单词 "word" 或 "wordy" 中的 "word"。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a keyword example. word wordy.";
7
boost::regex pattern("\\Bword\\B"); // 匹配非单词边界的 "word"
8
boost::smatch match;
9
10
std::cout << "匹配到的非单词边界 'word':" << std::endl;
11
std::string::const_iterator start = text.begin();
12
std::string::const_iterator end = text.end();
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << std::endl; // 输出：匹配到的非单词边界 'word': word
15
start = match[0].second;
16
}
17
18
return 0;
19
}
锚点在正则表达式中起着至关重要的定位作用，可以精确地匹配文本的特定位置，例如行首、行尾、单词边界等。合理使用锚点可以提高正则表达式的精确性和效率。
3.4 分组与捕获（Grouping and Capturing）
分组（Grouping） 和 捕获（Capturing） 是正则表达式中强大的功能，它们允许将正则表达式的一部分组合成一个单元，并对这个单元进行操作，例如重复、引用等。分组和捕获使用圆括号 () 来实现。
3.4.1 捕获组与非捕获组（Capturing and Non-capturing Groups）
圆括号 () 在正则表达式中主要有两种用途：创建捕获组（Capturing Groups） 和 创建非捕获组（Non-capturing Groups）。
① 捕获组（Capturing Groups）
默认情况下，圆括号 () 创建的是捕获组。捕获组会将括号内子表达式匹配的文本保存起来，以便后续引用或提取。捕获组会按照它们在正则表达式中出现的顺序编号，从 1 开始。第 0 组代表整个正则表达式的匹配结果。
例如，正则表达式 (ab)+ 使用捕获组 (ab) 匹配 "ab" 一次或多次。匹配结果中，第 1 组会保存每次匹配到的 "ab"。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "ababab";
7
boost::regex pattern("(ab)+"); // 捕获组 (ab)
8
boost::smatch match;
9
bool found = boost::regex_match(text, match, pattern); // 使用 regex_match 进行完全匹配
10
if (found) {
11
std::cout << "完整匹配: " << match.str() << std::endl; // 输出：完整匹配: ababab
12
std::cout << "捕获组 1: " << match[1].str() << std::endl; // 输出：捕获组 1: ab (最后一次捕获的 "ab")
13
} else {
14
std::cout << "未找到匹配项" << std::endl;
15
}
16
return 0;
17
}
在 boost::smatch 对象中，match[0] 存储整个正则表达式的匹配结果，match[1]、match[2] 等存储各个捕获组的匹配结果。如果一个捕获组被量词修饰而重复匹配多次，match[n] 只会保存最后一次匹配的结果。
② 非捕获组（Non-capturing Groups）
非捕获组 使用 (?:...) 语法创建。非捕获组只用于分组，不会将括号内子表达式匹配的文本保存起来。使用非捕获组可以提高正则表达式的性能，并减少内存消耗，尤其是在正则表达式包含大量分组，但只需要部分分组的捕获结果时。
例如，正则表达式 (?:ab)+ 使用非捕获组 (?:ab) 匹配 "ab" 一次或多次。虽然也进行了分组，但不会保存匹配的 "ab"。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "ababab";
7
boost::regex pattern("(?:ab)+"); // 非捕获组 (?:ab)
8
boost::smatch match;
9
bool found = boost::regex_match(text, match, pattern);
10
if (found) {
11
std::cout << "完整匹配: " << match.str() << std::endl; // 输出：完整匹配: ababab
12
std::cout << "捕获组数量: " << match.size() << std::endl; // 输出：捕获组数量: 1 (只有第 0 组，即完整匹配)
13
// std::cout << "捕获组 1: " << match[1].str() << std::endl; // 错误：访问越界，因为没有捕获组 1
14
} else {
15
std::cout << "未找到匹配项" << std::endl;
16
}
17
return 0;
18
}
非捕获组 (?:...) 主要用于：
⚝ 逻辑分组：将子表达式组合成一个单元，以便应用量词或其他操作。
⚝ 提高性能：避免不必要的捕获操作，减少资源消耗。
⚝ 增强可读性：在复杂的正则表达式中，使用非捕获组可以更清晰地表达分组结构，同时避免捕获组编号混乱。
3.4.2 反向引用（Backreferences）
反向引用（Backreferences） 允许在正则表达式的后部分引用之前捕获组匹配的文本。反向引用使用反斜杠 \ 后跟捕获组的编号来表示。例如，\1 引用第 1 个捕获组，\2 引用第 2 个捕获组，以此类推。
反向引用常用于匹配重复出现的模式，例如，查找连续重复的单词。
例如，正则表达式 \b(\w+)\b\s+\1\b 匹配连续重复的单词。
⚝ (\w+)：第 1 个捕获组，匹配一个或多个单词字符，即一个单词。
⚝ \b\s+：匹配单词边界和至少一个空白字符。
⚝ \1：反向引用第 1 个捕获组，要求此处匹配的文本与第 1 个捕获组匹配的文本完全相同。
⚝ \b：匹配单词边界。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "hello hello world world test test test";
7
boost::regex pattern("\\b(\\w+)\\b\\s+\\1\\b"); // 反向引用 \1
8
boost::smatch match;
9
10
std::cout << "匹配到的重复单词:" << std::endl;
11
std::string::const_iterator start = text.begin();
12
std::string::const_iterator end = text.end();
13
while (boost::regex_search(start, end, match, pattern)) {
14
std::cout << match.str() << std::endl; // 输出：匹配到的重复单词: hello hello world world test test
15
start = match[0].second;
16
}
17
18
return 0;
19
}
反向引用在以下场景中非常有用：
⚝ 数据验证：例如，验证 HTML 或 XML 标签是否成对出现，如 <tag>...</tag>。
⚝ 文本规范化：例如，去除文本中连续重复的单词或字符。
⚝ 代码分析：例如，查找代码中重复定义的变量名。
注意：反向引用引用的是之前捕获组匹配的文本内容，而不是之前的正则表达式模式。
分组和捕获是正则表达式中高级且强大的功能，它们不仅可以实现更复杂的匹配逻辑，还可以提取和重用匹配的文本片段。合理利用分组和捕获，可以编写出更灵活、更高效的正则表达式。
END_OF_CHAPTER
4. chapter 4： Boost.Regex 进阶：替换与迭代（Boost.Regex Advanced: Substitution and Iteration）
4.1 regex_replace 函数：替换操作（The regex_replace Function: Substitution）
regex_replace 函数是 Boost.Regex 库中一个非常强大的工具，它允许我们使用正则表达式来查找文本中的模式，并将匹配到的部分替换为指定的格式。这种替换操作不仅限于简单的字符串替换，还可以根据正则表达式的匹配结果动态生成替换内容，极大地增强了文本处理的灵活性和效率。
regex_replace 函数提供了多种重载形式，以适应不同的使用场景。最常用的形式通常接受以下参数：
① 输入序列（Input sequence）：这是要进行查找和替换操作的文本，可以是字符串、字符数组或迭代器范围。
② 正则表达式（Regular expression）：一个 regex 对象，定义了要查找的模式。
③ 替换格式字符串（Replacement format string）：一个字符串，定义了如何替换匹配到的文本。
④ 匹配标志（Match flags，可选）：用于控制匹配过程的选项，例如是否区分大小写、是否处理多行文本等。
regex_replace 函数的返回值是一个新的字符串，其中所有匹配到的模式都被替换成了指定的格式。原始的输入序列不会被修改。
4.1.1 替换格式字符串（Substitution Format Strings）
替换格式字符串是 regex_replace 函数的核心组成部分，它决定了如何将正则表达式匹配到的内容替换成新的文本。除了普通的文本字符外，替换格式字符串还可以包含特殊的转义序列（escape sequence），用于引用匹配结果的不同部分，从而实现更复杂的替换逻辑。
常用的替换格式字符串转义序列包括：
① $& 或 $0：表示整个正则表达式匹配到的文本。
② $``：表示匹配到的文本之前的文本。
③ $' 或 $\``：表示匹配到的文本**之后**的文本。
④$+：表示最后一个捕获组匹配到的文本。
⑤$_：表示整个输入序列。
⑥$n或${n}(n 是一个正整数)：表示第 n 个捕获组匹配到的文本。例如，$1表示第一个捕获组，$2表示第二个捕获组，以此类推。${10}表示第十个捕获组，用于区分两位数以上的捕获组编号。
⑦$$：表示插入一个字面量$` 字符。
代码示例 4-1：基本替换格式字符串的使用
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Hello, Boost Regex!";
7
boost::regex pattern("Boost");
8
std::string replacement = "Powerful";
9
std::string result = boost::regex_replace(text, pattern, replacement);
10
std::cout << "Original text: " << text << std::endl;
11
std::cout << "Replaced text: " << result << std::endl;
12
return 0;
13
}
输出结果：
1
Original text: Hello, Boost Regex!
2
Replaced text: Hello, Powerful Regex!
在这个例子中，我们将字符串 "Boost" 替换成了 "Powerful"。这是一个最基本的替换操作，替换格式字符串就是简单的字面量字符串。
代码示例 4-2：使用 $& 引用整个匹配
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Number: 123, Another number: 456";
7
boost::regex pattern("\\d+"); // 匹配一个或多个数字
8
std::string replacement = "[$&]"; // 使用 [$&] 包围匹配到的数字
9
std::string result = boost::regex_replace(text, pattern, replacement);
10
std::cout << "Original text: " << text << std::endl;
11
std::cout << "Replaced text: " << result << std::endl;
12
return 0;
13
}
输出结果：
1
Original text: Number: 123, Another number: 456
2
Replaced text: Number: [123], Another number: [456]
在这个例子中，我们使用 $& 将匹配到的数字用方括号 [] 包围起来。$& 代表了每次正则表达式 \d+ 匹配到的完整文本。
代码示例 4-3：使用捕获组和 $n 引用
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Name: John Doe, Age: 30";
7
boost::regex pattern("Name: (\\w+) (\\w+), Age: (\\d+)"); // 三个捕获组
8
std::string replacement = "Person: $2 $1, $3 years old"; // 交换姓名顺序，并添加 "years old"
9
std::string result = boost::regex_replace(text, pattern, replacement);
10
std::cout << "Original text: " << text << std::endl;
11
std::cout << "Replaced text: " << result << std::endl;
12
return 0;
13
}
输出结果：
1
Original text: Name: John Doe, Age: 30
2
Replaced text: Person: Doe John, 30 years old
在这个例子中，我们使用了捕获组 () 来提取姓名和年龄信息。$1 代表第一个捕获组 (\\w+) 匹配到的 "John"，$2 代表第二个捕获组 (\\w+) 匹配到的 "Doe"，$3 代表第三个捕获组 (\\d+) 匹配到的 "30"。通过 $1、$2、$3，我们可以在替换格式字符串中引用这些捕获组的内容，并重新组织文本的结构。
4.1.2 使用 smatch 对象进行替换（Substitution with smatch Objects）
除了使用简单的替换格式字符串外，regex_replace 函数还可以接受一个格式化函数（format function）或 格式化对象（format object）作为参数，来实现更高级的替换逻辑。这种方式允许我们在替换过程中访问 smatch 对象，从而获取更详细的匹配信息，并根据这些信息动态生成替换内容。
格式化函数需要符合特定的函数签名，通常接受一个 smatch 对象作为参数，并返回一个字符串作为替换结果。
代码示例 4-4：使用格式化函数进行替换
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
std::string format_name(const boost::smatch& match) {
6
std::string first_name = match[1]; // 第一个捕获组
7
std::string last_name = match[2]; // 第二个捕获组
8
return last_name + ", " + first_name; // 姓在前，名在后
9
}
10
11
int main() {
12
std::string text = "Names: John Doe, Jane Smith";
13
boost::regex pattern("(\\w+) (\\w+)"); // 匹配姓名，两个捕获组
14
std::string result = boost::regex_replace(text, pattern, format_name);
15
std::cout << "Original text: " << text << std::endl;
16
std::cout << "Replaced text: " << result << std::endl;
17
return 0;
18
}
输出结果：
1
Original text: Names: John Doe, Jane Smith
2
Replaced text: Names: Doe, John, Smith, Jane
在这个例子中，我们定义了一个名为 format_name 的格式化函数。这个函数接受一个 smatch 对象 match，并通过 match[1] 和 match[2] 访问了第一个和第二个捕获组的内容（即姓名）。函数返回一个重新格式化后的姓名字符串，姓在前，名在后。regex_replace 函数在每次匹配到姓名时，都会调用 format_name 函数，并将匹配结果 smatch 对象传递给它，从而实现动态的替换。
使用格式化函数或格式化对象进行替换，可以实现更复杂的替换逻辑，例如：
⚝ 根据匹配到的内容进行条件判断，选择不同的替换方式。
⚝ 从 smatch 对象中获取更详细的匹配信息，例如匹配位置、捕获组的偏移量等。
⚝ 调用外部函数或库，进行更复杂的文本处理操作。
4.2 regex_iterator 和 regex_token_iterator：迭代匹配（regex_iterator and regex_token_iterator: Iterative Matching）
regex_iterator 和 regex_token_iterator 是 Boost.Regex 库提供的两种迭代器，用于在文本中进行迭代匹配（iterative matching）。与 regex_match 和 regex_search 函数一次性返回所有匹配结果不同，迭代器允许我们逐个访问文本中所有匹配的子序列，或者根据正则表达式分割文本。
4.2.1 regex_iterator 的使用（Using regex_iterator）
regex_iterator 用于迭代访问文本中所有与正则表达式匹配的子序列。它类似于一个普通的迭代器，可以用于遍历一个范围。每次迭代，迭代器都会指向下一个匹配的子序列。
regex_iterator 的构造函数通常接受两个迭代器，表示要搜索的文本范围的起始和结束位置，以及一个 regex 对象，表示要匹配的正则表达式。
代码示例 4-5：使用 regex_iterator 遍历所有匹配
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Numbers: 12, 345, 6, 7890";
7
boost::regex pattern("\\d+"); // 匹配一个或多个数字
8
9
boost::regex_iterator<std::string::iterator> begin(text.begin(), text.end(), pattern);
10
boost::regex_iterator<std::string::iterator> end; // 默认构造函数表示结束迭代器
11
12
std::cout << "Matched numbers:" << std::endl;
13
for (boost::regex_iterator<std::string::iterator> it = begin; it != end; ++it) {
14
boost::smatch match = *it; // 解引用迭代器获取 smatch 对象
15
std::cout << match.str() << std::endl; // 输出匹配到的字符串
16
}
17
return 0;
18
}
输出结果：
1
Matched numbers:
2
12
3
345
4
6
5
7890
在这个例子中，我们创建了一个 regex_iterator 对象 begin，它从 text.begin() 开始，到 text.end() 结束，使用正则表达式 \d+ 进行匹配。end 是一个默认构造的结束迭代器。我们使用一个 for 循环遍历从 begin 到 end 的范围。在循环内部，*it 解引用迭代器，得到一个 smatch 对象 match，它包含了当前匹配的结果。match.str() 返回匹配到的字符串，我们将其输出到控制台。这样，我们就遍历输出了文本中所有匹配到的数字。
4.2.2 regex_token_iterator 的使用（Using regex_token_iterator）
regex_token_iterator 提供了更灵活的迭代匹配方式。它可以用于：
① 迭代访问文本中所有与正则表达式匹配的子序列（类似于 regex_iterator）。
② 迭代访问文本中所有与正则表达式不匹配的子序列（即分割后的 token）。
③ 迭代访问指定的捕获组匹配到的子序列。
regex_token_iterator 的构造函数比 regex_iterator 更加灵活，可以接受额外的参数来控制迭代行为。其中一个重要的参数是 子匹配索引（submatch index），它可以是一个整数或一个整数数组。
⚝ 当子匹配索引为 0 或 -1 时，regex_token_iterator 的行为类似于 regex_iterator，迭代访问所有匹配的子序列。
⚝ 当子匹配索引为一个正整数 n 时，regex_token_iterator 迭代访问第 n 个捕获组匹配到的子序列。
⚝ 当子匹配索引为 -1 时，regex_token_iterator 迭代访问所有不匹配的子序列，即使用正则表达式作为分隔符分割文本。
代码示例 4-6：使用 regex_token_iterator 分割字符串
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
#include <vector>
5
6
int main() {
7
std::string text = "apple,banana,orange,grape";
8
boost::regex delimiter(","); // 逗号作为分隔符
9
10
boost::regex_token_iterator<std::string::iterator> begin(text.begin(), text.end(), delimiter, -1);
11
boost::regex_token_iterator<std::string::iterator> end;
12
13
std::cout << "Tokens:" << std::endl;
14
std::vector<std::string> tokens;
15
for (boost::regex_token_iterator<std::string::iterator> it = begin; it != end; ++it) {
16
tokens.push_back(*it); // 将 token 添加到 vector
17
std::cout << *it << std::endl; // 输出 token
18
}
19
20
std::cout << "\nToken count: " << tokens.size() << std::endl;
21
return 0;
22
}
输出结果：
1
Tokens:
2
apple
3
banana
4
orange
5
grape
6
7
Token count: 4
在这个例子中，我们将子匹配索引设置为 -1，使得 regex_token_iterator 将逗号 , 作为分隔符，迭代访问文本中所有不匹配逗号的子序列，也就是被逗号分割的 token。我们遍历迭代器，并将每个 token 输出到控制台，并统计了 token 的数量。
代码示例 4-7：使用 regex_token_iterator 提取捕获组
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Data: name=Alice;age=25, name=Bob;age=30";
7
boost::regex pattern("name=(\\w+);age=(\\d+),?"); // 匹配 name=value;age=value 格式的数据
8
9
// 提取第一个捕获组 (name)
10
boost::regex_token_iterator<std::string::iterator> name_begin(text.begin(), text.end(), pattern, 1);
11
boost::regex_token_iterator<std::string::iterator> name_end;
12
13
// 提取第二个捕获组 (age)
14
boost::regex_token_iterator<std::string::iterator> age_begin(text.begin(), text.end(), pattern, 2);
15
boost::regex_token_iterator<std::string::iterator> age_end;
16
17
std::cout << "Names:" << std::endl;
18
for (boost::regex_token_iterator<std::string::iterator> it = name_begin; it != name_end; ++it) {
19
std::cout << *it << std::endl;
20
}
21
22
std::cout << "\nAges:" << std::endl;
23
for (boost::regex_token_iterator<std::string::iterator> it = age_begin; it != age_end; ++it) {
24
std::cout << *it << std::endl;
25
}
26
27
return 0;
28
}
输出结果：
1
Names:
2
Alice
3
Bob
4
5
Ages:
6
25
7
30
在这个例子中，我们使用 regex_token_iterator 分别提取了正则表达式 pattern 中第一个捕获组（name）和第二个捕获组（age）的内容。通过将子匹配索引设置为 1 和 2，我们分别创建了两个迭代器范围，用于遍历提取姓名和年龄信息。
regex_iterator 和 regex_token_iterator 为我们提供了强大的迭代匹配能力，可以灵活地处理文本中的多个匹配项，或者根据正则表达式分割和提取文本内容，是 Boost.Regex 库中非常重要的工具。
END_OF_CHAPTER
5. chapter 5： 错误处理与异常（Error Handling and Exceptions）
5.1 regex_error 类：正则表达式异常（The regex_error Class: Regular Expression Exception）
在 Boost.Regex 库中，错误处理是一个至关重要的方面，它确保了程序在面对各种不期望的情况时，依然能够稳定运行。regex_error 类是 Boost.Regex 库专门用于表示正则表达式相关的异常的类。当正则表达式的编译或匹配过程中发生错误时，Boost.Regex 会抛出 regex_error 类型的异常。理解和正确处理这些异常，是编写健壮的正则表达式程序的关键。
regex_error 类继承自 std::runtime_error，这意味着它属于 C++ 标准库的运行时错误异常体系。它提供了标准异常类的一些基本接口，并针对正则表达式错误增加了特定的错误代码，以便更详细地了解错误的性质。
regex_error 类的主要特点和功能：
① 异常类型：regex_error 是一个异常类，用于表示正则表达式操作期间发生的错误。当 Boost.Regex 检测到错误时，会抛出此类型的异常，允许程序通过 try-catch 块来捕获和处理这些错误。
② 错误代码：regex_error 对象包含一个整数类型的错误代码，可以通过 code() 成员函数访问。这个错误代码对应于 std::regex_constants::error_type 枚举中定义的值，详细说明了错误的具体类型。例如，error_syntax 表示正则表达式语法错误，error_brack 表示括号不匹配等。
③ 错误描述：regex_error 继承了 std::runtime_error 的 what() 成员函数，可以返回一个描述错误信息的字符串。这个字符串通常包含了对错误的简要说明，有助于开发者快速定位问题。
④ 构造函数：regex_error 类的构造函数接受一个 std::regex_constants::error_type 枚举值作为参数，用于初始化错误代码。
regex_error 类的常用成员函数：
⚝ code()：返回一个 std::regex_constants::error_type 枚举值，表示具体的错误代码。
⚝ what()：返回一个 const char* 类型的字符串，描述了发生的错误。这是从 std::exception 继承而来的标准方法。
示例代码：捕获和处理 regex_error 异常
以下代码示例展示了如何使用 try-catch 块来捕获 regex_error 异常，并获取错误代码和错误描述信息：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string pattern = "[a-z+"; // 错误的正则表达式，缺少闭合方括号
7
std::string text = "abcdefg";
8
9
try {
10
boost::regex re(pattern); // 尝试编译正则表达式，可能会抛出 regex_error
11
boost::smatch match;
12
if (boost::regex_search(text, match, re)) {
13
std::cout << "Match found: " << match.str() << std::endl;
14
} else {
15
std::cout << "No match found." << std::endl;
16
}
17
} catch (const boost::regex_error& e) {
18
std::cerr << "Regex error caught: " << e.what() << std::endl;
19
std::cerr << "Error code: " << e.code() << std::endl;
20
if (e.code() == boost::regex_constants::error_syntax) {
21
std::cerr << "It's a syntax error in the regular expression." << std::endl;
22
}
23
return 1; // 表示程序出错退出
24
}
25
26
return 0;
27
}
代码解释：
- 包含头文件：包含了
<iostream>用于输入输出，<string>用于字符串操作，以及<boost/regex.hpp>引入 Boost.Regex 库。 - 定义错误的正则表达式：
std::string pattern = "[a-z+";定义了一个包含语法错误的正则表达式，缺少闭合的方括号]。 try-catch块：使用try块包围了可能抛出regex_error异常的代码。这包括boost::regex re(pattern);正则表达式对象的构造，因为编译错误会在构造时抛出异常。- 捕获
regex_error异常：catch (const boost::regex_error& e)捕获regex_error类型的异常对象e。 - 处理异常：在
catch块中，我们：
▮▮▮▮⚝ 使用e.what()输出错误描述信息到标准错误输出std::cerr。
▮▮▮▮⚝ 使用e.code()获取错误代码，并输出到std::cerr。
▮▮▮▮⚝ 通过判断e.code()的值是否等于boost::regex_constants::error_syntax，来判断是否是语法错误，并输出更具体的错误信息。
▮▮▮▮⚝ 返回1，表示程序因为错误而退出。
运行结果 （取决于具体的 Boost.Regex 版本和编译器，但错误信息类似）：
1
Regex error caught: regex_error(error_syntax): Unexpected character in bracket expression.
2
Error code: 1
3
It's a syntax error in the regular expression.
总结：
regex_error 类是 Boost.Regex 库中处理正则表达式错误的关键机制。通过捕获和分析 regex_error 异常，开发者可以有效地诊断和处理正则表达式编译和匹配过程中出现的各种问题，从而提高程序的健壮性和可靠性。在编写涉及正则表达式的代码时，始终应该考虑错误处理，并使用 try-catch 块来妥善处理 regex_error 异常。
5.2 正则表达式编译错误（Regular Expression Compilation Errors）
正则表达式编译错误发生在 boost::regex 对象构造时，即当你尝试将一个字符串编译成正则表达式对象的过程中。如果提供的正则表达式字符串不符合正则表达式的语法规则，Boost.Regex 库将无法正确解析它，从而抛出 regex_error 异常。这类错误通常是由于正则表达式模式本身存在语法错误造成的。
常见的正则表达式编译错误原因：
① 语法错误（Syntax Errors）：这是最常见的编译错误。正则表达式语法非常严格，任何不符合规范的字符或结构都可能导致编译失败。例如：
▮▮▮▮⚝ 括号不匹配：例如 (abc 缺少闭合括号 )，或者 [abc 缺少闭合方括号 ]。
▮▮▮▮⚝ 无效的元字符使用：例如在不应该出现元字符的地方使用了元字符，或者元字符使用方式错误，如 a** (连续两个 *) 在某些上下文中可能被视为错误。
▮▮▮▮⚝ 字符类错误：例如 [a-z 缺少闭合方括号，或者字符类内部使用了无效的字符范围。
▮▮▮▮⚝ 反斜杠转义错误：例如反斜杠 \ 后跟随的字符不是合法的转义序列。
② 资源限制（Resource Limits）：虽然不常见，但在某些极端情况下，非常复杂或嵌套层次过深的正则表达式可能超出 Boost.Regex 库的编译资源限制，导致编译错误。这通常发生在尝试编译极其庞大或病态的正则表达式时。
③ 选项冲突（Option Conflicts）：当使用的正则表达式选项之间存在冲突时，也可能导致编译错误。例如，某些选项组合在逻辑上是互斥的。
std::regex_constants::error_type 枚举中的常见编译错误代码：
std::regex_constants::error_type 枚举定义了各种正则表达式错误代码，以下是一些常见的与编译错误相关的代码：
⚝ error_badregex 或 error_syntax：通用的正则表达式语法错误。
⚝ error_brack：括号 [] 不匹配或格式错误。
⚝ error_paren：圆括号 () 不匹配或格式错误。
⚝ error_brace：花括号 {} 不匹配或格式错误。
⚝ error_badescape：无效的转义序列。
⚝ error_badrepeat：重复操作符（如 *, +, ?, {}) 使用错误，例如出现在开头或连续出现。
⚝ error_complexity：正则表达式过于复杂，超出了库的限制。
⚝ error_stack：编译正则表达式时栈溢出（通常由于递归嵌套过深）。
示例代码：捕获不同的编译错误
以下代码示例展示了如何捕获不同类型的正则表达式编译错误，并根据错误代码输出相应的错误信息：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
#include <boost/regex/constants.hpp> // 需要包含 constants.hpp 获取错误代码枚举
5
6
void test_regex_compilation(const std::string& pattern) {
7
try {
8
boost::regex re(pattern);
9
std::cout << "Regular expression '" << pattern << "' compiled successfully." << std::endl;
10
} catch (const boost::regex_error& e) {
11
std::cerr << "Compilation error for pattern '" << pattern << "': " << e.what() << std::endl;
12
std::cerr << "Error code: " << e.code() << std::endl;
13
switch (e.code()) {
14
case boost::regex_constants::error_syntax:
15
case boost::regex_constants::error_badregex:
16
std::cerr << " Syntax error in regex." << std::endl;
17
break;
18
case boost::regex_constants::error_brack:
19
std::cerr << " Bracket error (e.g., unclosed [])." << std::endl;
20
break;
21
case boost::regex_constants::error_paren:
22
std::cerr << " Parenthesis error (e.g., unclosed ())." << std::endl;
23
break;
24
case boost::regex_constants::error_brace:
25
std::cerr << " Brace error (e.g., unclosed {})." << std::endl;
26
break;
27
case boost::regex_constants::error_badescape:
28
std::cerr << " Bad escape sequence." << std::endl;
29
break;
30
case boost::regex_constants::error_badrepeat:
31
std::cerr << " Bad repetition operator (e.g., **)." << std::endl;
32
break;
33
// 可以添加更多 case 分支来处理其他类型的错误
34
default:
35
std::cerr << " Unknown compilation error." << std::endl;
36
break;
37
}
38
}
39
}
40
41
int main() {
42
test_regex_compilation("[a-z"); // 缺少闭合方括号
43
test_regex_compilation("(abc"); // 缺少闭合圆括号
44
test_regex_compilation("a{1,"); // 缺少花括号的闭合部分
45
test_regex_compilation("abc\\"); // 反斜杠后缺少字符
46
test_regex_compilation("a**b"); // 重复操作符连续出现
47
test_regex_compilation("valid regex"); // 有效的正则表达式
48
49
return 0;
50
}
代码解释：
test_regex_compilation函数：这个函数接受一个正则表达式模式字符串作为参数，尝试编译它，并捕获可能抛出的regex_error异常。switch语句处理错误代码：在catch块中，使用switch语句根据e.code()返回的错误代码，输出更具体的错误类型信息。- 测试用例：
main函数中调用test_regex_compilation函数，传入不同的正则表达式模式，包括各种错误模式和一个有效的模式，来演示错误处理。
运行结果 （输出会根据具体的 Boost.Regex 版本和错误信息略有不同，但核心信息一致）：
1
Compilation error for pattern '[a-z': regex_error(error_brack): Unmatched '[' or '{'.
2
Error code: 2
3
Bracket error (e.g., unclosed []).
4
Compilation error for pattern '(abc': regex_error(error_paren): Unmatched '('.
5
Error code: 3
6
Parenthesis error (e.g., unclosed ()).
7
Compilation error for pattern 'a{1,': regex_error(error_brace): Unmatched '{'.
8
Error code: 4
9
Brace error (e.g., unclosed {}).
10
Compilation error for pattern 'abc\': regex_error(error_badescape): Invalid escape sequence.
11
Error code: 8
12
Bad escape sequence.
13
Compilation error for pattern 'a**b': regex_error(error_badrepeat): The repeat specifier is not valid in this context.
14
Error code: 9
15
Bad repetition operator (e.g., **).
16
Regular expression 'valid regex' compiled successfully.
总结：
正则表达式编译错误是开发过程中常见的错误类型，尤其是在编写和调试复杂正则表达式时。通过理解常见的编译错误原因，以及 std::regex_constants::error_type 枚举中定义的错误代码，开发者可以更有效地诊断和修复正则表达式语法错误。在实际开发中，应该始终进行充分的测试，并使用 try-catch 块来处理 regex_error 异常，确保程序在遇到无效正则表达式时能够优雅地处理错误，而不是崩溃或产生不可预测的行为。
5.3 运行时匹配错误（Runtime Matching Errors）
运行时匹配错误指的是在正则表达式编译成功后，在执行匹配操作（例如 regex_match, regex_search, regex_replace 等函数）时可能发生的错误。与编译错误不同，运行时匹配错误不是由正则表达式模式的语法错误引起的，而是由其他因素导致的，例如资源耗尽、匹配过程中的复杂性超出限制等。
常见的运行时匹配错误原因及场景：
① 资源耗尽（Resource Exhaustion）：
▮▮▮▮⚝ 回溯失控（Backtracking Explosion）：某些正则表达式在应用于特定输入文本时，可能会导致回溯次数急剧增加，消耗大量计算资源，甚至导致程序长时间无响应或崩溃。这种情况通常发生在正则表达式中存在嵌套的重复结构，并且这些结构可以以多种方式匹配输入文本时。例如，形如 (a+)*b 的正则表达式在匹配 "aaaa...aaaa" 类型的字符串时，就可能发生回溯失控。
▮▮▮▮⚝ 内存耗尽：在极少数情况下，如果正则表达式匹配过程需要存储大量的中间状态或匹配结果，可能会导致内存耗尽。
② 栈溢出（Stack Overflow）：
▮▮▮▮⚝ 深度递归：某些复杂的正则表达式，特别是包含大量嵌套分组或递归结构的正则表达式，在匹配过程中可能导致函数调用栈深度过大，从而引发栈溢出错误。这通常发生在正则表达式引擎的实现依赖于递归的情况下。
③ 超出匹配限制（Matching Limits Exceeded）：
▮▮▮▮⚝ 匹配时间限制 或 匹配步数限制：为了防止恶意或错误的正则表达式导致程序无限期运行，某些正则表达式引擎可能会设置匹配时间或匹配步数的限制。当匹配过程超出这些限制时，可能会被中断并报告错误。但 Boost.Regex 默认情况下不强制实施此类硬性限制，更多依赖于资源耗尽的自然限制。
运行时错误与 regex_error 异常：
在 Boost.Regex 中，运行时匹配错误通常也通过抛出 regex_error 异常来报告。虽然 regex_error 主要用于编译错误，但它也可以用于指示运行时错误。通过检查 regex_error 对象的 code() 方法返回的错误代码，可以区分不同类型的错误。
std::regex_constants::error_type 枚举中与运行时错误相关的代码 (虽然运行时错误不总是显式映射到特定的 error_type，但某些情况下可能使用通用错误代码)：
⚝ error_complexity：可能在某些情况下用于指示正则表达式匹配过程过于复杂，导致资源消耗过大。
⚝ error_stack：可能用于指示匹配过程中栈溢出。
⚝ error_unknown：在无法明确归类到其他错误类型时，可能会使用通用未知错误代码。
需要注意的是，运行时匹配错误不像编译错误那样容易预测和捕获。 回溯失控等问题通常表现为程序性能急剧下降或无响应，而不是立即抛出异常。栈溢出可能会导致程序崩溃，但也可能被操作系统捕获为更底层的错误信号。
示例代码：尝试捕获运行时可能出现的 regex_error 异常 (注意：运行时错误的捕获可能不如编译错误那样直接和可靠，下面的例子更多是演示错误处理框架，实际运行时错误的行为可能更复杂)：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
#include <chrono> // 用于测量时间
5
6
int main() {
7
std::string pattern = "(a+)*b"; // 可能导致回溯失控的正则表达式
8
std::string text = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac"; // 长 "a" 序列，故意不匹配 'b'
9
10
try {
11
boost::regex re(pattern);
12
boost::smatch match;
13
14
auto start_time = std::chrono::high_resolution_clock::now();
15
bool found_match = boost::regex_search(text, match, re); // 执行搜索匹配，可能耗时很长或抛出异常
16
auto end_time = std::chrono::high_resolution_clock::now();
17
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
18
19
if (found_match) {
20
std::cout << "Match found: " << match.str() << std::endl;
21
} else {
22
std::cout << "No match found in " << duration.count() << " milliseconds." << std::endl;
23
}
24
25
} catch (const boost::regex_error& e) {
26
std::cerr << "Runtime regex error caught: " << e.what() << std::endl;
27
std::cerr << "Error code: " << e.code() << std::endl;
28
// 可以根据 e.code() 判断具体的运行时错误类型 (如果 Boost.Regex 明确区分运行时错误代码)
29
return 1;
30
} catch (const std::exception& ex) {
31
std::cerr << "Other exception caught during regex processing: " << ex.what() << std::endl;
32
return 1;
33
} catch (...) {
34
std::cerr << "Unknown exception caught during regex processing." << std::endl;
35
return 1;
36
}
37
38
return 0;
39
}
代码解释：
- 回溯失控的正则表达式：
std::string pattern = "(a+)*b";使用了一个可能导致回溯失控的正则表达式。 - 长输入文本：
std::string text = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac";构造了一个长字符串，其中包含很多 'a'，但故意不以 'b' 结尾，以触发回溯。 - 时间测量：使用
<chrono>库测量regex_search函数的执行时间，以便观察性能影响。 - 多重
catch块：除了捕获boost::regex_error，还捕获了std::exception和...，以更全面地处理可能出现的各种异常情况，包括 Boost.Regex 抛出的异常以及其他潜在的运行时错误。
运行结果：
在某些情况下，上述代码可能会运行很长时间，最终输出 "No match found"，并显示一个较长的执行时间，表明回溯失控导致性能下降。在极端情况下，如果回溯非常严重，可能会导致程序无响应或崩溃，但 不一定会明确抛出 regex_error 异常。Boost.Regex 的行为可能取决于具体的实现和系统资源限制。
总结与最佳实践：
运行时匹配错误，特别是回溯失控，是正则表达式使用中更隐蔽和难以处理的问题。为了避免运行时错误，并提高正则表达式的性能和可靠性，建议采取以下最佳实践：
⚝ 设计高效的正则表达式：避免使用可能导致回溯失控的模式，例如嵌套的、无限制的重复结构，特别是当这些结构可以以多种方式匹配时。
⚝ 限制回溯 (如果 Boost.Regex 库提供相关选项，某些正则表达式引擎允许设置回溯限制，但 Boost.Regex 本身可能没有直接提供此类选项，需要依赖于优化正则表达式模式本身)。
⚝ 输入验证和预处理：在将用户输入或外部数据用于正则表达式匹配之前，进行必要的验证和预处理，限制输入数据的长度和复杂性，减少正则表达式需要处理的数据量。
⚝ 性能测试和监控：对于关键的正则表达式操作，进行性能测试，监控执行时间，及时发现潜在的性能问题和运行时风险。
⚝ 考虑使用更高效的算法或工具：对于某些复杂的文本处理任务，正则表达式可能不是最合适的工具。在性能要求极高或需要处理非常复杂的模式时，可以考虑使用专门的解析器生成器（如 Boost.Spirit，在 Chapter 9 中会介绍）或其他更高效的文本处理算法。
⚝ 错误日志和监控：在生产环境中，记录正则表达式相关的错误和异常信息，以便及时发现和解决运行时问题。
虽然 Boost.Regex 提供了 regex_error 类来处理错误，但运行时匹配错误的处理更侧重于预防和优化。理解正则表达式引擎的工作原理，特别是回溯机制，以及掌握正则表达式优化的技巧，是避免运行时错误和提高程序健壮性的关键。
END_OF_CHAPTER
6. chapter 6： 性能优化与高级主题（Performance Optimization and Advanced Topics）
6.1 正则表达式性能考量（Regular Expression Performance Considerations）
正则表达式的强大功能背后，隐藏着性能方面的考量。不合理的正则表达式可能会导致程序执行效率低下，甚至出现拒绝服务攻击（Denial of Service, DoS）。理解正则表达式的性能特性，并掌握优化技巧，对于编写高效、健壮的程序至关重要。
6.1.1 回溯与性能陷阱（Backtracking and Performance Pitfalls）
正则表达式引擎在进行匹配时，通常采用回溯（Backtracking）算法。当正则表达式存在多种匹配可能时，引擎会尝试不同的路径，如果某条路径匹配失败，则会回溯到之前的状态，尝试其他路径。
回溯机制虽然保证了正则表达式的灵活性和表达能力，但也可能成为性能瓶颈。特别是当正则表达式写得不够严谨，或者目标字符串结构复杂时，回溯次数会急剧增加，导致所谓的“灾难性回溯”（Catastrophic Backtracking），使匹配时间呈指数级增长。
以下是一些容易引发回溯的常见模式：
① 过度使用通配符 .：. 可以匹配任意字符，当与量词结合使用，如 .* 或 .+ 时，容易产生大量的回溯。例如，正则表达式 .*a 匹配字符串 "aaaaaaaaab" 时，.* 会首先匹配整个字符串，然后为了匹配最后的 a，不得不回溯，尝试更短的匹配，直到找到最后一个 a。
② 嵌套量词：形如 (x+)* 或 (a|b)+ 的嵌套量词结构，会显著增加回溯的可能性。例如，正则表达式 (a+)+b 匹配字符串 "aaaaaaaaab" 时，外层的 + 和内层的 + 都会进行多次尝试，导致回溯次数爆炸式增长。
③ 分支过多且存在公共前缀：例如，正则表达式 (a|ab|abc) 匹配字符串 "abcd" 时，引擎会依次尝试 a、ab、abc 三个分支，即使第一个分支 a 已经匹配成功，但由于后续分支的存在，引擎仍然会继续尝试，造成不必要的回溯。
示例：灾难性回溯
考虑以下正则表达式，用于匹配 HTML 标签：
1
<.*>.*</.*>
当用这个正则表达式匹配如下恶意构造的字符串时：
会发生灾难性回溯。因为 <.*> 会贪婪地匹配到最后一个 <a> 的结束尖括号 >，然后 .* 会匹配到 <b> 之前的所有内容，最后 <!--.*--> 尝试匹配 </b> 时，由于 .* 已经匹配到了 <b> 之前的所有内容，导致匹配失败。此时，正则表达式引擎会回溯，<.*> 会释放最后一个 <a> 的 >，重新尝试匹配，如此反复，直到尝试所有可能的回溯路径，最终导致超时。
避免回溯陷阱的原则：
⚝ 明确匹配目标：尽量使用更精确的模式，避免过度使用通配符 .。
⚝ 减少嵌套量词：尽量避免使用嵌套量词，可以使用非捕获组 (?:...) 或固化分组 (?>...) 来减少回溯。
⚝ 优化分支结构：将更可能匹配的分支放在前面，提取公共前缀，使用互斥的分支结构。
⚝ 使用占有量词：在不需要回溯的场景下，可以使用占有量词 +?、*?、??，阻止回溯。
6.1.2 优化正则表达式的技巧（Techniques for Optimizing Regular Expressions）
除了避免回溯陷阱，还可以通过以下技巧来优化正则表达式的性能：
① 使用非捕获组 (?:...)：如果不需要捕获子表达式的结果，可以使用非捕获组 (?:...)，减少引擎的捕获开销，提高性能。
② 使用锚点 ^ 和 $：如果匹配的目标字符串位于行首或行尾，可以使用锚点 ^ 和 $ 限定匹配位置，避免不必要的搜索。
③ 使用字符类 [...] 和预定义字符类 \d、\w、\s：字符类和预定义字符类比通配符 . 更高效，因为它们缩小了匹配范围。
④ 使用固化分组 (?>...)：固化分组 (?>...) 会阻止回溯，一旦子表达式匹配成功，就不会再回溯尝试其他的匹配路径。这可以提高匹配效率，尤其是在确定不需要回溯的场景下。
⑤ 编译正则表达式：对于需要多次使用的正则表达式，可以预先编译成 regex 对象，避免重复编译的开销。
⑥ 选择合适的匹配算法：Boost.Regex 库会自动选择合适的匹配算法，但在某些特殊情况下，可以通过 regex_constants::algo_type 选项手动指定匹配算法，例如 regex_constants::nosubs 可以禁用子表达式匹配，提高性能。
代码示例：性能优化
假设我们需要从一段文本中提取所有的数字。
未优化的正则表达式：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a text with numbers 123, 456, and 789.";
7
boost::regex re(".*([0-9]+).*"); // 容易回溯
8
boost::smatch match;
9
10
if (boost::regex_search(text, match, re)) {
11
for (size_t i = 1; i < match.size(); ++i) {
12
std::cout << "Match " << i << ": " << match[i] << std::endl;
13
}
14
}
15
return 0;
16
}
优化的正则表达式：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
#include <boost/foreach.hpp>
5
6
int main() {
7
std::string text = "This is a text with numbers 123, 456, and 789.";
8
boost::regex re("\\d+"); // 使用预定义字符类，避免回溯
9
boost::smatch match;
10
11
boost::sregex_iterator begin(text.begin(), text.end(), re);
12
boost::sregex_iterator end;
13
14
BOOST_FOREACH(boost::smatch const& m, boost::make_iterator_range(begin, end))
15
{
16
std::cout << "Match: " << m[0] << std::endl;
17
}
18
19
return 0;
20
}
优化的版本使用了预定义字符类 \d，并直接匹配数字，避免了使用通配符 . 和捕获组，提高了匹配效率。同时，使用了 boost::sregex_iterator 迭代器来查找所有匹配项，而不是只查找第一个匹配项。
6.2 Unicode 支持（Unicode Support）
随着全球化的发展，处理多语言文本的需求日益增加。Unicode 是一种字符编码标准，旨在涵盖世界上所有的字符。Boost.Regex 库提供了强大的 Unicode 支持，可以处理各种 Unicode 字符和编码。
6.2.1 Unicode 字符类和属性（Unicode Character Classes and Properties）
Boost.Regex 库支持 Unicode 字符类和属性，可以使用它们来匹配特定类型的 Unicode 字符。
① Unicode 字符类：Unicode 字符类以 \p{} 或 \P{} 的形式表示，其中 {} 内是字符类的名称。\p{} 匹配属于该字符类的字符，\P{} 匹配不属于该字符类的字符。
常用的 Unicode 字符类包括：
⚝ \p{Lu}：大写字母（Uppercase letter）
⚝ \p{Ll}：小写字母（Lowercase letter）
⚝ \p{Lt}：首字母大写的字母（Titlecase letter）
⚝ \p{Lm}：修饰符字母（Modifier letter）
⚝ \p{Lo}：其他字母（Other letter）
⚝ \p{Nl}：字母数字（Letter number）
⚝ \p{Nd}：十进制数字（Decimal digit number）
⚝ \p{No}：其他数字（Other number）
⚝ \p{Zs}：空格分隔符（Space separator）
⚝ \p{Zl}：行分隔符（Line separator）
⚝ \p{Zp}：段落分隔符（Paragraph separator）
⚝ \p{Cc}：控制字符（Control character）
⚝ \p{Cf}：格式字符（Format character）
⚝ \p{Cs}：代理对字符（Surrogate character）
⚝ \p{Co}：私有使用字符（Private-use character）
⚝ \p{Cn}：未分配字符（Unassigned character）
⚝ \p{P}：标点符号（Punctuation）
⚝ \p{S}：符号（Symbol）
⚝ \p{Z}：分隔符（Separator）
⚝ \p{C}：控制字符（Control）
例如，\p{Nd}+ 可以匹配一个或多个 Unicode 十进制数字，包括阿拉伯数字、中文数字、泰文数字等。
② Unicode 属性：Unicode 属性以 \p{property=value} 或 \P{property=value} 的形式表示，其中 property 是属性名称，value 是属性值。
常用的 Unicode 属性包括：
⚝ General_Category 或 gc：通用类别，可以使用字符类名称作为值，例如 \p{gc=Lu} 等价于 \p{Lu}。
⚝ Script 或 sc：脚本，表示字符所属的文字系统，例如 \p{sc=Han} 匹配汉字。
⚝ Block 或 blk：块，表示字符所属的 Unicode 块，例如 \p{blk=CJK_Unified_Ideographs} 匹配CJK统一表意符号块中的字符。
代码示例：Unicode 字符类
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Hello，世界！123你好"; // 包含英文、中文、数字、标点符号
7
boost::wregex re_chinese(L"\\p{Han}+"); // 匹配一个或多个汉字
8
boost::wregex re_digit(L"\\p{Nd}+"); // 匹配一个或多个 Unicode 数字
9
boost::wsmatch match;
10
11
std::wcout << L"Original text: " << text << std::endl;
12
13
std::wcout << L"Chinese characters: ";
14
boost::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
15
std::wstring wtext = converter.from_bytes(text);
16
boost::wsregex_iterator begin_chinese(wtext.begin(), wtext.end(), re_chinese);
17
boost::wsregex_iterator end_chinese;
18
for (boost::wsregex_iterator i = begin_chinese; i != end_chinese; ++i) {
19
std::wcout << i->str() << L" ";
20
}
21
std::wcout << std::endl;
22
23
std::wcout << L"Unicode digits: ";
24
boost::wsregex_iterator begin_digit(wtext.begin(), wtext.end(), re_digit);
25
boost::wsregex_iterator end_digit;
26
for (boost::wsregex_iterator i = begin_digit; i != end_digit; ++i) {
27
std::wcout << i->str() << L" ";
28
}
29
std::wcout << std::endl;
30
31
return 0;
32
}
这段代码演示了如何使用 Unicode 字符类 \p{Han} 和 \p{Nd} 分别匹配汉字和 Unicode 数字。需要注意的是，在使用 Unicode 字符类时，需要使用宽字符版本 wregex 和 wsmatch，并使用宽字符串字面量 L""。
6.2.2 处理不同编码的字符串（Handling Strings with Different Encodings）
Unicode 可以使用不同的编码方式来表示，常见的编码方式包括 UTF-8、UTF-16、UTF-32 等。Boost.Regex 库可以处理不同编码的字符串，但需要注意以下几点：
① 选择合适的字符类型：对于 UTF-8 编码的字符串，可以使用 std::string 和 boost::regex；对于 UTF-16 或 UTF-32 编码的字符串，可以使用 std::wstring 和 boost::wregex。
② 设置正确的语法选项：在创建 regex 或 wregex 对象时，需要设置正确的语法选项，以告知库使用的字符编码。默认情况下，Boost.Regex 假设输入字符串是窄字符编码（如 ASCII 或 Latin-1）。对于 UTF-8 编码，可以使用 boost::regex::flag::utf8 选项；对于宽字符编码（如 UTF-16 或 UTF-32），可以使用 boost::regex::flag::wregex 选项。
③ 进行编码转换：如果输入字符串的编码与正则表达式库期望的编码不一致，需要进行编码转换。可以使用 Boost.Locale 库或 ICU 库等进行编码转换。
代码示例：UTF-8 编码处理
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string utf8_text = "你好，世界！🌍"; // UTF-8 编码的字符串，包含 emoji
7
boost::regex utf8_re("世界！🌍"); // 匹配 UTF-8 字符串
8
boost::smatch match;
9
10
if (boost::regex_search(utf8_text, match, utf8_re)) {
11
std::cout << "Match found: " << match.str() << std::endl;
12
} else {
13
std::cout << "Match not found." << std::endl;
14
}
15
16
return 0;
17
}
这段代码演示了如何处理 UTF-8 编码的字符串。由于默认情况下 Boost.Regex 假设输入是窄字符编码，因此可以直接使用 std::string 和 boost::regex 处理 UTF-8 字符串，无需额外设置语法选项。但是，如果正则表达式本身包含 Unicode 字符类或属性，则需要使用 boost::regex::flag::utf8 选项显式指定 UTF-8 编码。
6.3 自定义 Locale（Custom Locales）
Locale（区域设置）是指一组与特定地理区域、语言或文化相关的设置，包括日期格式、时间格式、数字格式、货币符号、字符排序规则等。Boost.Regex 库支持自定义 Locale，可以根据不同的 Locale 设置来调整正则表达式的行为。
默认情况下，Boost.Regex 使用全局 Locale 设置。可以通过以下方式自定义 Locale：
① 使用 std::locale 对象：可以创建一个 std::locale 对象，并将其传递给 regex 或 wregex 对象的构造函数，或者传递给 regex_match、regex_search 等函数的 locale 参数。
② 使用 Boost.Locale 库：Boost.Locale 库提供了更强大的 Locale 管理功能，可以使用 Boost.Locale 库创建和管理 Locale 对象，并将其应用于 Boost.Regex。
自定义 Locale 可以影响正则表达式的以下行为：
⚝ 字符类：例如，\w 字符类在不同的 Locale 下可能匹配不同的字符集合。在某些 Locale 下，\w 可能只匹配 ASCII 字母和数字，而在其他 Locale 下，可能匹配包括 Unicode 字母和数字在内的更广泛的字符集合。
⚝ 大小写不敏感匹配：大小写不敏感匹配（icase 选项）的行为受 Locale 设置影响。在不同的 Locale 下，大小写转换规则可能不同。
⚝ 排序规则：在某些高级正则表达式操作中，例如使用 collating element（排序元素）时，排序规则受 Locale 设置影响。
代码示例：自定义 Locale
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
#include <locale>
5
6
int main() {
7
std::string text = "straße"; // 德语单词 "街道"
8
boost::regex re_default("\\w+"); // 默认 Locale
9
boost::regex re_german("\\w+", boost::regex::flag::extended, std::locale("de_DE.UTF-8")); // 德语 Locale
10
boost::smatch match;
11
12
std::cout << "Default Locale: ";
13
if (boost::regex_search(text, match, re_default)) {
14
std::cout << match.str() << std::endl; // 可能只匹配 "stra"
15
} else {
16
std::cout << "No match" << std::endl;
17
}
18
19
std::cout << "German Locale: ";
20
if (boost::regex_search(text, match, re_german)) {
21
std::cout << match.str() << std::endl; // 可能匹配 "straße"
22
} else {
23
std::cout << "No match" << std::endl;
24
}
25
26
return 0;
27
}
这段代码演示了如何使用自定义 Locale。在默认 Locale 下，\w+ 可能无法正确匹配德语单词 "straße" 中的 "ß" 字符，而在德语 Locale 下，\w+ 可以正确匹配整个单词。
6.4 正则表达式选项（Regex Options）
Boost.Regex 库提供了丰富的正则表达式选项，可以通过这些选项来控制正则表达式的语法和匹配行为。正则表达式选项可以分为两类：语法选项（Syntax Options）和匹配选项（Match Options）。
6.4.1 regex_constants::syntax_option_type：语法选项（Syntax Options）
语法选项用于控制正则表达式的语法规则，可以在创建 regex 或 wregex 对象时指定。常用的语法选项包括：
① regex_constants::ECMAScript：ECMAScript 语法（默认选项），符合 ECMAScript 标准的正则表达式语法，也是最常用的语法。
② regex_constants::basic：基本 POSIX 正则表达式语法。
③ regex_constants::extended：扩展 POSIX 正则表达式语法。
④ regex_constants::awk：AWK 正则表达式语法。
⑤ regex_constants::grep：GREP 正则表达式语法。
⑥ regex_constants::egrep：EGREP 正则表达式语法。
⑦ regex_constants::icase：忽略大小写（Case-insensitive）。
⑧ regex_constants::nosubs：禁用子表达式匹配，只返回匹配结果，不返回子表达式匹配结果，可以提高性能。
⑨ regex_constants::optimize：优化正则表达式，提高匹配速度，但可能会增加编译时间。
⑩ regex_constants::collate：使用 Locale 相关的排序规则。
⑪ regex_constants::multiline：多行模式，^ 和 $ 匹配每一行的开头和结尾，而不是整个字符串的开头和结尾。
⑫ regex_constants::newline_alt：允许 \n 作为换行符的替代。
⑬ regex_constants::no_mod_m：禁用多行模式，即使指定了 multiline 选项。
⑭ regex_constants::no_mod_s：单行模式，. 匹配包括换行符在内的所有字符。
⑮ regex_constants::mod_x：宽松模式，忽略正则表达式中的空格和注释。
⑯ regex_constants::unicode：启用 Unicode 支持。
⑰ regex_constants::utf8：假设输入字符串是 UTF-8 编码。
代码示例：语法选项
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Hello World";
7
boost::regex re_icase("hello", boost::regex::flag::icase); // 忽略大小写
8
boost::regex re_extended("Hel[lo]+", boost::regex::flag::extended); // 扩展 POSIX 语法
9
boost::smatch match;
10
11
std::cout << "Case-insensitive match: ";
12
if (boost::regex_search(text, match, re_icase)) {
13
std::cout << "Match found" << std::endl;
14
} else {
15
std::cout << "Match not found" << std::endl;
16
}
17
18
std::cout << "Extended POSIX syntax match: ";
19
if (boost::regex_search(text, match, re_extended)) {
20
std::cout << "Match found" << std::endl;
21
} else {
22
std::cout << "Match not found" << std::endl;
23
}
24
25
return 0;
26
}
这段代码演示了如何使用 icase 选项进行大小写不敏感匹配，以及如何使用 extended 选项启用扩展 POSIX 正则表达式语法。
6.4.2 regex_constants::match_flag_type：匹配选项（Match Options）
匹配选项用于控制正则表达式的匹配行为，可以在调用 regex_match、regex_search、regex_replace 等函数时指定。常用的匹配选项包括：
① regex_constants::match_default：默认匹配选项。
② regex_constants::match_not_bol：不将输入序列的起始位置视为行首（Beginning of Line）。
③ regex_constants::match_not_eol：不将输入序列的结束位置视为行尾（End of Line）。
④ regex_constants::match_not_bow：不将当前匹配位置之前的位置视为单词边界（Beginning of Word）。
⑤ regex_constants::match_not_eow：不将当前匹配位置之后的位置视为单词边界（End of Word）。
⑥ regex_constants::match_any：如果存在多于一个可能的匹配，则返回任意一个匹配结果。
⑦ regex_constants::match_partial：允许部分匹配，即使整个输入序列没有完全匹配正则表达式，只要输入序列的前缀部分匹配正则表达式，也算作匹配成功。
⑧ regex_constants::match_continuous：连续匹配，匹配必须从输入序列的起始位置开始。
⑨ regex_constants::match_prev_avail：在调用 regex_search 时，如果指定了 match_prev_avail 选项，则 regex_search 函数会假设输入序列的起始位置之前存在一个字符。这通常用于迭代搜索，在每次搜索时，将上次匹配的结束位置作为下次搜索的起始位置。
⑩ regex_constants::format_default：默认替换格式。
⑪ regex_constants::format_sed：SED 替换格式，使用 SED 风格的替换字符串。
⑫ regex_constants::format_perl：Perl 替换格式，使用 Perl 风格的替换字符串。
⑬ regex_constants::format_literal：字面替换格式，将替换字符串视为字面值，不进行任何特殊字符转义。
代码示例：匹配选项
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "line1\nline2";
7
boost::regex re_multiline("^line\\d"); // 多行模式，匹配行首的 "line" + 数字
8
boost::regex re_default("^line\\d"); // 默认模式，只匹配字符串开头的 "line" + 数字
9
boost::smatch match;
10
11
std::cout << "Multiline mode: " << std::endl;
12
boost::sregex_iterator begin_multiline(text.begin(), text.end(), re_multiline, boost::regex::multiline);
13
boost::sregex_iterator end_multiline;
14
for (boost::sregex_iterator i = begin_multiline; i != end_multiline; ++i) {
15
std::cout << i->str() << std::endl; // 匹配 "line1" 和 "line2"
16
}
17
18
std::cout << "Default mode: " << std::endl;
19
boost::sregex_iterator begin_default(text.begin(), text.end(), re_default);
20
boost::sregex_iterator end_default;
21
for (boost::sregex_iterator i = begin_default; i != end_default; ++i) {
22
std::cout << i->str() << std::endl; // 只匹配 "line1"
23
}
24
25
return 0;
26
}
这段代码演示了如何使用 multiline 匹配选项启用多行模式，使得 ^ 锚点可以匹配每一行的开头。在多行模式下，正则表达式可以匹配到 "line1" 和 "line2" 两行，而在默认模式下，只能匹配到 "line1"。
END_OF_CHAPTER
7. chapter 7： Boost.Regex API 参考详解（Boost.Regex API Reference and Detailed Explanation）
7.1 regex 类详解（Detailed Explanation of regex Class）
regex 类是 Boost.Regex 库的核心，用于表示正则表达式对象。它封装了正则表达式的编译结果，并提供了多种构造、赋值和操作正则表达式的方法。理解 regex 类的功能和用法是掌握 Boost.Regex 的基础。
7.1.1 regex 类的定义（Definition of regex Class）
regex 类定义在 <boost/regex.hpp> 头文件中。其基本定义如下（简化版本）：
1
namespace boost {
2
namespace regex_constants {
3
// ... 定义 regex_constants 命名空间，包含语法选项等
4
} // namespace regex_constants
5
6
template <class charT, class traits = regex_traits<charT> >
7
class basic_regex {
8
public:
9
// ... 构造函数
10
// ... 赋值运算符
11
// ... 标志访问器
12
// ... 替换 locale
13
// ... 获取标记的子表达式的数量
14
// ... 交换函数
15
// ... 迭代器支持 (deprecated)
16
// ... ...
17
};
18
19
typedef basic_regex<char> regex;
20
typedef basic_regex<wchar_t> wregex;
21
22
} // namespace boost
实际上，regex 是 basic_regex<char> 的别名，用于处理 char 类型的字符串；wregex 是 basic_regex<wchar_t> 的别名，用于处理宽字符 wchar_t 类型的字符串，以支持 Unicode 等宽字符集。regex_traits<charT> 模板类定义了字符特征，例如字符分类、大小写转换等，通常使用默认值即可。
7.1.2 regex 类的构造函数（Constructors of regex Class）
regex 类提供了多种构造函数，允许从不同来源创建正则表达式对象：
① 默认构造函数：regex()
创建一个空的 regex 对象，它不匹配任何内容。通常在稍后使用赋值运算符赋予其正则表达式。
1
boost::regex empty_regex;
② 从字符串字面量构造：regex(const charT* p, flag_type f = regex_constants::ECMAScript)
从以 null 结尾的 C 风格字符串 p 构造 regex 对象。f 是正则表达式的语法选项，默认为 regex_constants::ECMAScript，表示 ECMAScript 语法。
1
boost::regex r1("abc"); // 使用 ECMAScript 语法
2
boost::regex r2("^[0-9]+$", boost::regex::extended); // 使用 extended 语法
③ 从 std::string 或 std::wstring 构造：regex(const std::basic_string<charT>& s, flag_type f = regex_constants::ECMAScript)
从 std::string 或 std::wstring 对象 s 构造 regex 对象。f 是语法选项，默认为 regex_constants::ECMAScript。
1
std::string pattern = "[a-zA-Z]+";
2
boost::regex r3(pattern);
3
4
std::wstring wpattern = L"\\d+";
5
boost::wregex wr1(wpattern);
④ 从迭代器范围构造：regex(ForwardIterator first, ForwardIterator last, flag_type f = regex_constants::ECMAScript)
从迭代器 [first, last) 指定的范围构造 regex 对象。这允许从任何字符序列（例如字符数组的一部分）创建正则表达式。
1
char buffer[] = "regex pattern here";
2
boost::regex r4(buffer + 6, buffer + 13); // 从 "pattern" 构造
⑤ 拷贝构造函数和移动构造函数：regex(const regex& other) 和 regex(regex&& other)
标准的拷贝和移动构造函数，用于创建正则表达式对象的副本或转移所有权。
1
boost::regex r5("[0-9]*");
2
boost::regex r6 = r5; // 拷贝构造
3
boost::regex r7 = std::move(r5); // 移动构造，r5 变为有效但未指定状态
语法选项 flag_type f：
flag_type 是 regex_constants::syntax_option_type 的别名，用于指定正则表达式的语法和行为。常用的选项包括：
⚝ regex_constants::ECMAScript：默认选项，使用 ECMAScript 语法，这是最常用的正则表达式语法。
⚝ regex_constants::basic：POSIX 基本正则表达式语法。
⚝ regex_constants::extended：POSIX 扩展正则表达式语法。
⚝ regex_constants::awk：AWK 语法。
⚝ regex_constants::grep：grep 语法。
⚝ regex_constants::egrep：egrep 语法。
⚝ regex_constants::icase：忽略大小写匹配。
⚝ regex_constants::nosubs：不存储捕获的子表达式。
⚝ regex_constants::optimize：优化正则表达式的匹配速度，可能牺牲编译速度。
⚝ regex_constants::collate：使用当前 locale 进行字符排序。
这些选项可以使用 | 运算符组合使用，例如 boost::regex::ECMAScript | boost::regex::icase。
7.1.3 regex 类的赋值运算符（Assignment Operators of regex Class）
regex 类提供了赋值运算符，允许将新的正则表达式赋值给已有的 regex 对象：
① 从字符串字面量赋值：regex& operator=(const charT* p)
1
boost::regex r;
2
r = "new pattern";
② 从 std::string 或 std::wstring 赋值：regex& operator=(const std::basic_string<charT>& s)
1
boost::regex r;
2
std::string pattern_str = "another pattern";
3
r = pattern_str;
③ 拷贝赋值运算符和移动赋值运算符：regex& operator=(const regex& other) 和 regex& operator=(regex&& other)
1
boost::regex r1("old regex");
2
boost::regex r2;
3
r2 = r1; // 拷贝赋值
4
boost::regex r3;
5
r3 = std::move(r1); // 移动赋值，r1 变为有效但未指定状态
7.1.4 regex 类的成员函数（Member Functions of regex Class）
regex 类提供了一些有用的成员函数，用于获取正则表达式的信息或进行操作：
① flags()：flag_type flags() const;
返回构造 regex 对象时使用的语法选项标志。
1
boost::regex r("example", boost::regex::icase);
2
boost::regex::flag_type f = r.flags();
3
if (f & boost::regex::icase) {
4
std::cout << "忽略大小写匹配已启用" << std::endl;
5
}
② imbue()：std::locale imbue(std::locale loc); 和 std::locale imbue() const;
设置或获取 regex 对象使用的 locale。locale 影响字符分类和排序规则。
1
boost::regex r("[[:alpha:]]+"); // 默认 locale
2
std::locale german_locale("de_DE.UTF-8");
3
r.imbue(german_locale); // 设置为德语 locale
4
std::locale current_locale = r.imbue(); // 获取当前 locale
③ mark_count()：unsigned mark_count() const;
返回正则表达式中捕获组的数量。
1
boost::regex r("([a-z]+)(\\d*)");
2
unsigned count = r.mark_count(); // 返回 2，因为有两个捕获组
④ swap()：void swap(regex& other);
交换两个 regex 对象的内容。这是一个快速且异常安全的交换操作。
1
boost::regex r1("pattern1");
2
boost::regex r2("pattern2");
3
r1.swap(r2); // r1 现在包含 "pattern2"，r2 现在包含 "pattern1"
⑤ assign()：regex& assign( ... );
assign() 函数族提供了类似于构造函数和赋值运算符的功能，可以重新设置 regex 对象的内容。它有多个重载版本，接受 C 风格字符串、std::string、迭代器范围等作为参数，并可以指定语法选项。
1
boost::regex r;
2
r.assign("new pattern", boost::regex::extended); // 使用 extended 语法重新赋值
7.1.5 regex 类的异常处理（Exception Handling of regex Class）
当正则表达式的语法错误时，regex 类的构造函数和 assign() 函数可能会抛出 regex_error 异常。因此，在创建 regex 对象时，应该使用 try-catch 块来捕获并处理可能的异常。
1
#include <iostream>
2
#include <boost/regex.hpp>
3
4
int main() {
5
try {
6
boost::regex r("invalid[ regex"); // 语法错误：[ 没有匹配的 ]
7
} catch (const boost::regex_error& e) {
8
std::cerr << "正则表达式编译错误: " << e.what() << std::endl;
9
std::cerr << "错误代码: " << e.code() << std::endl;
10
return 1;
11
}
12
std::cout << "正则表达式编译成功" << std::endl;
13
return 0;
14
}
regex_error 类的 what() 成员函数返回错误描述字符串，code() 成员函数返回错误代码，错误代码是 regex_constants::error_type 枚举类型的值，例如 regex_constants::error_badregex 表示正则表达式语法错误。
7.1.6 regex 类的使用示例（Examples of regex Class Usage）
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Hello Boost.Regex!";
7
std::string pattern_str = "\\w+"; // 匹配单词
8
boost::regex pattern(pattern_str); // 创建 regex 对象
9
10
if (boost::regex_search(text, pattern)) {
11
std::cout << "文本中包含匹配正则表达式的子串" << std::endl;
12
} else {
13
std::cout << "文本中不包含匹配正则表达式的子串" << std::endl;
14
}
15
16
boost::regex case_insensitive_pattern("boost", boost::regex::icase); // 忽略大小写
17
if (boost::regex_search(text, case_insensitive_pattern)) {
18
std::cout << "忽略大小写匹配成功" << std::endl;
19
}
20
21
return 0;
22
}
总结：
⚝ regex 类是 Boost.Regex 库中表示正则表达式的核心类。
⚝ 提供了多种构造函数和赋值运算符，方便从不同来源创建和修改正则表达式对象。
⚝ flags(), imbue(), mark_count(), swap(), assign() 等成员函数提供了对正则表达式对象的访问和操作能力。
⚝ 构造和赋值操作可能抛出 regex_error 异常，需要进行异常处理。
⚝ 理解 regex 类的使用是学习 Boost.Regex 的关键步骤。
7.2 smatch 类详解（Detailed Explanation of smatch Class）
smatch 类是 Boost.Regex 库中用于存储正则表达式匹配结果的容器。它派生自 match_results 模板类，专门用于存储 regex_search 和 regex_match 等函数的匹配结果。smatch 对象包含了整个匹配的信息以及所有捕获组的匹配信息。
7.2.1 smatch 类的定义（Definition of smatch Class）
smatch 类定义在 <boost/regex.hpp> 头文件中。其基本定义如下（简化版本）：
1
namespace boost {
2
3
template <class StringIterator, class Allocator = std::allocator<sub_match<StringIterator> > >
4
class match_results {
5
public:
6
// ... 类型定义，例如 value_type, iterator, difference_type, size_type, allocator_type
7
// ... 构造函数
8
// ... 状态检查函数：ready(), empty(), size(), max_size()
9
// ... 子匹配访问：operator[], prefix(), suffix(), length(), position()
10
// ... 迭代器支持：begin(), cbegin(), end(), cend()
11
// ... 格式化函数：format()
12
// ... 交换函数：swap()
13
// ... ...
14
};
15
16
typedef match_results<std::string::const_iterator> smatch;
17
typedef match_results<std::wstring::const_iterator> wsmatch;
18
19
} // namespace boost
smatch 是 match_results<std::string::const_iterator> 的别名，用于处理 char 类型的字符串匹配结果；wsmatch 是 match_results<std::wstring::const_iterator> 的别名，用于处理 wchar_t 类型的字符串匹配结果。match_results 是一个模板类，可以用于不同类型的迭代器，但 smatch 和 wsmatch 专门针对字符串迭代器进行了实例化。
7.2.2 smatch 类的主要功能（Main Functions of smatch Class）
smatch 对象主要用于访问和操作正则表达式匹配的结果，包括：
① 状态检查：
⚝ ready()：返回 bool 值，指示 smatch 对象是否包含有效的匹配结果。如果匹配操作成功，则返回 true，否则返回 false。
⚝ empty()：返回 bool 值，指示是否找到了匹配。如果 ready() 返回 true 但没有找到任何匹配（例如，正则表达式匹配空字符串），则 empty() 返回 true，否则返回 false。通常情况下，如果 ready() 返回 false，empty() 也返回 true。
⚝ size()：返回匹配的子表达式（包括整个匹配）的数量。通常等于正则表达式中捕获组的数量加 1（整个匹配本身算作一个子表达式）。
⚝ max_size()：返回 smatch 对象可以存储的最大子表达式数量。通常与实现相关，实际使用中 size() 不会超过 max_size()。
② 子匹配访问：
⚝ operator[](size_type n)：返回索引为 n 的子匹配对象 sub_match。索引 0 表示整个匹配，索引 1, 2, ... 表示正则表达式中第 1, 2, ... 个捕获组的匹配。如果索引超出范围，行为未定义。
⚝ prefix()：返回表示匹配前缀的 sub_match 对象。前缀是指输入序列中匹配开始位置之前的部分。
⚝ suffix()：返回表示匹配后缀的 sub_match 对象。后缀是指输入序列中匹配结束位置之后的部分。
③ 子匹配信息：
sub_match 对象是 smatch 对象的元素类型，表示一个子匹配（可以是整个匹配或某个捕获组的匹配）。sub_match 类提供了以下主要成员函数：
⚝ matched: 返回 bool 值，指示子匹配是否成功。如果对应的捕获组参与了匹配，则为 true，否则为 false（例如，捕获组是可选的，但没有实际匹配到内容）。
⚝ first: 返回指向子匹配开始位置的迭代器。
⚝ second: 返回指向子匹配结束位置的迭代器。
⚝ length(): 返回子匹配的长度。
⚝ str(): 返回子匹配的字符串表示。
④ 迭代器：
smatch 类提供了迭代器，可以遍历所有子匹配对象。
⚝ begin() 和 cbegin()：返回指向第一个子匹配（索引 0，整个匹配）的迭代器。
⚝ end() 和 cend()：返回指向最后一个子匹配之后位置的迭代器。
⑤ 格式化：
⚝ format() 函数族：可以将匹配结果格式化为字符串，支持使用格式化字符串和标志。
7.2.3 smatch 类的使用示例（Examples of smatch Class Usage）
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Name: John Doe, Age: 30";
7
boost::regex pattern("Name: (\\w+ \\w+), Age: (\\d+)");
8
boost::smatch match;
9
10
if (boost::regex_search(text, match, pattern)) {
11
std::cout << "匹配成功" << std::endl;
12
std::cout << "整个匹配: " << match[0] << std::endl; // 整个匹配
13
std::cout << "姓名: " << match[1] << std::endl; // 第一个捕获组
14
std::cout << "年龄: " << match[2] << std::endl; // 第二个捕获组
15
16
std::cout << "匹配前缀: " << match.prefix() << std::endl;
17
std::cout << "匹配后缀: " << match.suffix() << std::endl;
18
19
for (size_t i = 0; i < match.size(); ++i) {
20
std::cout << "子匹配 " << i << ": " << match[i] << "，长度: " << match[i].length() << "，位置: [" << match[i].first - text.begin() << ", " << match[i].second - text.begin() << ")" << std::endl;
21
}
22
} else {
23
std::cout << "匹配失败" << std::endl;
24
}
25
26
return 0;
27
}
示例输出：
1
匹配成功
2
整个匹配: Name: John Doe, Age: 30
3
姓名: John Doe
4
年龄: 30
5
匹配前缀:
6
匹配后缀:
7
子匹配 0: Name: John Doe, Age: 30，长度: 23，位置: [0, 23)
8
子匹配 1: John Doe，长度: 8，位置: [6, 14)
9
子匹配 2: 30，长度: 2，位置: [20, 22)
总结：
⚝ smatch 类用于存储正则表达式匹配的结果，包括整个匹配和所有捕获组的匹配。
⚝ 提供了 ready(), empty(), size() 等函数检查匹配状态。
⚝ 可以使用 operator[]、prefix(), suffix() 等函数访问子匹配信息。
⚝ sub_match 类表示一个子匹配，包含匹配的字符串、长度、位置等信息。
⚝ 可以通过迭代器遍历所有子匹配。
⚝ smatch 是 Boost.Regex 中处理匹配结果的关键类，是进行后续操作的基础。
7.3 regex_match 函数详解（Detailed Explanation of regex_match Function）
regex_match 函数是 Boost.Regex 库中用于执行完全匹配的算法。它尝试将整个输入序列与正则表达式进行匹配。只有当整个输入序列完全匹配正则表达式时，regex_match 才会返回 true。
7.3.1 regex_match 函数的定义（Definition of regex_match Function）
regex_match 函数有多个重载版本，定义在 <boost/regex.hpp> 头文件中。常用的版本包括：
① 版本 1：使用 smatch 存储结果
1
template <class StringIterator, class MatchResults, class Regex, class Flags>
2
bool regex_match(StringIterator first, StringIterator last, MatchResults& m, const Regex& e, Flags flags = regex_constants::match_default);
3
4
template <class String, class Allocator, class Regex, class Flags>
5
bool regex_match(const String& s, match_results<typename String::const_iterator, Allocator>& m, const Regex& e, Flags flags = regex_constants::match_default);
6
7
template <class String, class Regex, class Flags>
8
bool regex_match(const String& s, const Regex& e, Flags flags = regex_constants::match_default);
9
10
template <class StringIterator, class Regex, class Flags>
11
bool regex_match(StringIterator first, StringIterator last, const Regex& e, Flags flags = regex_constants::match_default);
⚝ first, last: 定义输入序列的迭代器范围 [first, last)。
⚝ m: smatch 或 wsmatch 对象，用于存储匹配结果。如果匹配成功，结果将存储在 m 中。
⚝ e: regex 或 wregex 对象，表示要匹配的正则表达式。
⚝ flags: regex_constants::match_flag_type 类型的匹配选项，默认为 regex_constants::match_default。
② 版本 2：不存储结果，只返回是否匹配
1
template <class String, class Regex, class Flags>
2
bool regex_match(const String& s, const Regex& e, Flags flags = regex_constants::match_default);
3
4
template <class StringIterator, class Regex, class Flags>
5
bool regex_match(StringIterator first, StringIterator last, const Regex& e, Flags flags = regex_constants::match_default);
⚝ 参数与版本 1 类似，但没有 MatchResults& m 参数。
⚝ 只返回 bool 值，指示是否完全匹配成功。
7.3.2 regex_match 函数的功能和用法（Functionality and Usage of regex_match Function）
regex_match 函数的主要功能是判断整个输入序列是否与给定的正则表达式完全匹配。
完全匹配的含义：
⚝ 从输入序列的起始位置开始匹配。
⚝ 正则表达式必须匹配到输入序列的结束位置。
⚝ 不允许输入序列中存在未匹配的部分。
使用场景：
⚝ 验证用户输入的格式是否完全符合要求，例如验证身份证号码、日期格式等。
⚝ 判断一个字符串是否完全符合某种模式。
返回值：
⚝ 如果匹配成功，返回 true。
⚝ 如果匹配失败，返回 false。
⚝ 如果使用了 smatch 参数，并且匹配成功，匹配结果将存储在 smatch 对象中。
匹配选项 flags：
flags 参数是 regex_constants::match_flag_type 类型，用于控制匹配的行为。常用的选项包括：
⚝ regex_constants::match_default：默认选项。
⚝ regex_constants::match_continuous：匹配必须从输入序列的起始位置开始。对于 regex_match 来说，这个选项默认是启用的，因此通常不需要显式指定。
⚝ regex_constants::match_not_bol：不将输入序列的起始位置视为行首 (^ 锚点不匹配起始位置)。
⚝ regex_constants::match_not_eol：不将输入序列的结束位置视为行尾 ($ 锚点不匹配结束位置)。
⚝ regex_constants::match_not_bow：不将输入序列的起始位置视为单词边界 (\\b 不匹配起始位置)。
⚝ regex_constants::match_not_eow：不将输入序列的结束位置视为单词边界 (\\b 不匹配结束位置)。
⚝ regex_constants::match_any：如果存在多于一个可能的匹配，可以返回任何一个。
⚝ regex_constants::match_partial：如果输入序列是正则表达式的前缀，也认为匹配成功（部分匹配）。regex_match 默认不进行部分匹配。
⚝ regex_constants::match_sed：兼容 sed 的行为。
⚝ regex_constants::match_perl：兼容 Perl 的行为。
⚝ regex_constants::match_posix：兼容 POSIX 的行为。
⚝ ... (更多选项请参考 Boost.Regex 文档)
这些选项可以使用 | 运算符组合使用。
7.3.3 regex_match 函数的使用示例（Examples of regex_match Function Usage）
① 验证整数：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string input1 = "12345";
7
std::string input2 = "123.45";
8
boost::regex integer_pattern("^[0-9]+$"); // 匹配由数字组成的字符串
9
10
if (boost::regex_match(input1, integer_pattern)) {
11
std::cout << "\"" << input1 << "\" 是一个整数" << std::endl;
12
} else {
13
std::cout << "\"" << input1 << "\" 不是一个整数" << std::endl;
14
}
15
16
if (boost::regex_match(input2, integer_pattern)) {
17
std::cout << "\"" << input2 << "\" 是一个整数" << std::endl;
18
} else {
19
std::cout << "\"" << input2 << "\" 不是一个整数" << std::endl;
20
}
21
22
return 0;
23
}
示例输出：
1
"12345" 是一个整数
2
"123.45" 不是一个整数
② 验证日期格式 (YYYY-MM-DD)：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string date1 = "2023-10-27";
7
std::string date2 = "2023/10/27";
8
boost::regex date_pattern("^\\d{4}-\\d{2}-\\d{2}$"); // 匹配 YYYY-MM-DD 格式
9
10
if (boost::regex_match(date1, date_pattern)) {
11
std::cout << "\"" << date1 << "\" 是有效的日期格式" << std::endl;
12
} else {
13
std::cout << "\"" << date1 << "\" 不是有效的日期格式" << std::endl;
14
}
15
16
if (boost::regex_match(date2, date_pattern)) {
17
std::cout << "\"" << date2 << "\" 是有效的日期格式" << std::endl;
18
} else {
19
std::cout << "\"" << date2 << "\" 不是有效的日期格式" << std::endl;
20
}
21
22
return 0;
23
}
示例输出：
1
"2023-10-27" 是有效的日期格式
2
"2023/10/27" 不是有效的日期格式
③ 使用 smatch 获取匹配结果：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string input = "Full Name: Alice Smith";
7
boost::regex name_pattern("^Full Name: (.*)$"); // 捕获姓名
8
boost::smatch match;
9
10
if (boost::regex_match(input, match, name_pattern)) {
11
std::cout << "完全匹配成功" << std::endl;
12
std::cout << "捕获的姓名: " << match[1] << std::endl; // 获取第一个捕获组
13
} else {
14
std::cout << "完全匹配失败" << std::endl;
15
}
16
17
return 0;
18
}
示例输出：
1
完全匹配成功
2
捕获的姓名: Alice Smith
总结：
⚝ regex_match 函数用于执行完全匹配，判断整个输入序列是否与正则表达式匹配。
⚝ 返回 bool 值指示匹配结果，也可以使用 smatch 参数获取详细的匹配信息。
⚝ 适用于需要验证输入格式或判断字符串是否完全符合某种模式的场景。
⚝ 理解完全匹配的概念是使用 regex_match 的关键。
7.4 regex_search 函数详解（Detailed Explanation of regex_search Function）
regex_search 函数是 Boost.Regex 库中用于执行搜索匹配的算法。它在输入序列中查找与正则表达式匹配的任何子序列。只要在输入序列中找到至少一个子序列与正则表达式匹配，regex_search 就会返回 true。
7.4.1 regex_search 函数的定义（Definition of regex_search Function）
regex_search 函数也有多个重载版本，定义在 <boost/regex.hpp> 头文件中。常用的版本包括：
① 版本 1：使用 smatch 存储结果
1
template <class StringIterator, class MatchResults, class Regex, class Flags>
2
bool regex_search(StringIterator first, StringIterator last, MatchResults& m, const Regex& e, Flags flags = regex_constants::match_default);
3
4
template <class String, class Allocator, class Regex, class Flags>
5
bool regex_search(const String& s, match_results<typename String::const_iterator, Allocator>& m, const Regex& e, Flags flags = regex_constants::match_default);
6
7
template <class String, class Regex, class Flags>
8
bool regex_search(const String& s, const Regex& e, Flags flags = regex_constants::match_default);
9
10
template <class StringIterator, class Regex, class Flags>
11
bool regex_search(StringIterator first, StringIterator last, const Regex& e, Flags flags = regex_constants::match_default);
⚝ 参数与 regex_match 类似，first, last, m, e, flags 的含义相同。
② 版本 2：不存储结果，只返回是否匹配
1
template <class String, class Regex, class Flags>
2
bool regex_search(const String& s, const Regex& e, Flags flags = regex_constants::match_default);
3
4
template <class StringIterator, class Regex, class Flags>
5
bool regex_search(StringIterator first, StringIterator last, const Regex& e, Flags flags = regex_constants::match_default);
⚝ 参数与版本 1 类似，但没有 MatchResults& m 参数。
⚝ 只返回 bool 值，指示是否搜索到匹配的子序列。
7.4.2 regex_search 函数的功能和用法（Functionality and Usage of regex_search Function）
regex_search 函数的主要功能是在输入序列中搜索与正则表达式匹配的子序列。
搜索匹配的含义：
⚝ 在输入序列中查找任何位置开始的子序列。
⚝ 只要找到至少一个子序列与正则表达式匹配，就认为搜索成功。
⚝ 输入序列中可以存在未匹配的部分。
使用场景：
⚝ 在文本中查找特定的模式，例如查找所有邮箱地址、URL、电话号码等。
⚝ 从日志文件中提取特定信息。
⚝ 在一段文本中查找关键词。
返回值：
⚝ 如果搜索到匹配的子序列，返回 true。
⚝ 如果没有搜索到匹配的子序列，返回 false。
⚝ 如果使用了 smatch 参数，并且搜索成功，第一个找到的匹配结果将存储在 smatch 对象中。
匹配选项 flags：
flags 参数的含义与 regex_match 函数相同，但 regex_search 函数中一些选项的行为可能略有不同。例如：
⚝ regex_constants::match_continuous：对于 regex_search，match_continuous 选项表示匹配必须从输入序列的起始位置开始。如果起始位置无法匹配，则搜索失败，不会在后续位置继续搜索。
⚝ regex_constants::match_partial：对于 regex_search，match_partial 选项表示如果从某个位置开始，输入序列的剩余部分是正则表达式的前缀，也认为匹配成功（部分匹配）。
其他常用选项如 regex_constants::match_not_bol, regex_constants::match_not_eol, regex_constants::match_not_bow, regex_constants::match_not_eow, regex_constants::match_any 等在 regex_search 中也适用。
7.4.3 regex_search 函数的使用示例（Examples of regex_search Function Usage）
① 查找邮箱地址：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Contact us at support@example.com or sales@example.org";
7
boost::regex email_pattern("\\b[\\w.%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}\\b"); // 简单的邮箱地址正则表达式
8
9
boost::smatch match;
10
if (boost::regex_search(text, match, email_pattern)) {
11
std::cout << "找到邮箱地址: " << match[0] << std::endl; // 第一个找到的邮箱地址
12
} else {
13
std::cout << "未找到邮箱地址" << std::endl;
14
}
15
16
return 0;
17
}
示例输出：
1
找到邮箱地址: support@example.com
② 查找 URL：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Visit our website at http://www.example.com or https://example.org/path";
7
boost::regex url_pattern("https?://[\\w.-]+(?:\\.[\\w.-]+)+[\\w\\-._~:/?#[\\]@!$&'()*+,;=]*"); // 简单的 URL 正则表达式
8
9
boost::smatch match;
10
if (boost::regex_search(text, match, url_pattern)) {
11
std::cout << "找到 URL: " << match[0] << std::endl; // 第一个找到的 URL
12
} else {
13
std::cout << "未找到 URL" << std::endl;
14
}
15
16
return 0;
17
}
示例输出：
1
找到 URL: http://www.example.com
③ 查找所有匹配的子序列（循环搜索）：
要查找文本中所有匹配的子序列，可以循环调用 regex_search 函数，并更新搜索的起始位置。
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Numbers: 123, 456, 789";
7
boost::regex number_pattern("\\d+");
8
boost::smatch match;
9
std::string::const_iterator start = text.cbegin();
10
std::string::const_iterator end = text.cend();
11
12
while (boost::regex_search(start, end, match, number_pattern)) {
13
std::cout << "找到数字: " << match[0] << "，位置: [" << match.position() << ", " << match.position() + match.length() << ")" << std::endl;
14
start = match[0].second; // 更新搜索起始位置为上一个匹配的结束位置
15
}
16
17
return 0;
18
}
示例输出：
1
找到数字: 123，位置: [9, 12)
2
找到数字: 456，位置: [14, 17)
3
找到数字: 789，位置: [19, 22)
总结：
⚝ regex_search 函数用于执行搜索匹配，在输入序列中查找与正则表达式匹配的子序列。
⚝ 返回 bool 值指示是否搜索到匹配，也可以使用 smatch 参数获取第一个找到的匹配信息。
⚝ 适用于需要在文本中查找特定模式的场景，例如提取信息、关键词查找等。
⚝ 可以通过循环调用 regex_search 来查找所有匹配的子序列。
⚝ 理解搜索匹配的概念和与 regex_match 的区别是使用 regex_search 的关键。
7.5 regex_replace 函数详解（Detailed Explanation of regex_replace Function）
regex_replace 函数是 Boost.Regex 库中用于执行替换操作的算法。它在输入序列中查找与正则表达式匹配的子序列，并将找到的子序列替换为指定的替换字符串。
7.5.1 regex_replace 函数的定义（Definition of regex_replace Function）
regex_replace 函数有多个重载版本，定义在 <boost/regex.hpp> 头文件中。常用的版本包括：
① 版本 1：返回新的字符串
1
template <class OutputIterator, class BidirectionalIterator, class Regex, class FormatFlags>
2
OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const Regex& e, const char* fmt, FormatFlags flags = regex_constants::format_default);
3
4
template <class OutputIterator, class BidirectionalIterator, class Regex, class FormatFlags>
5
OutputIterator regex_replace(OutputIterator out, BidirectionalIterator first, BidirectionalIterator last, const Regex& e, const std::basic_string<charT>& fmt, FormatFlags flags = regex_constants::format_default);
6
7
template <class BidirectionalIterator, class Regex, class FormatFlags>
8
std::basic_string<typename std::iterator_traits<BidirectionalIterator>::value_type>
9
regex_replace(BidirectionalIterator first, BidirectionalIterator last, const Regex& e, const char* fmt, FormatFlags flags = regex_constants::format_default);
10
11
template <class BidirectionalIterator, class Regex, class FormatFlags>
12
std::basic_string<typename std::iterator_traits<BidirectionalIterator>::value_type>
13
regex_replace(BidirectionalIterator first, BidirectionalIterator last, const Regex& e, const std::basic_string<charT>& fmt, FormatFlags flags = regex_constants::format_default);
14
15
template <class String, class Regex, class FormatFlags>
16
std::basic_string<typename String::value_type>
17
regex_replace(const String& s, const Regex& e, const char* fmt, FormatFlags flags = regex_constants::format_default);
18
19
template <class String, class Regex, class FormatFlags>
20
std::basic_string<typename String::value_type>
21
regex_replace(const String& s, const Regex& e, const std::basic_string<charT>& fmt, FormatFlags flags = regex_constants::format_default);
⚝ out: 输出迭代器，用于写入替换后的结果。
⚝ first, last: 定义输入序列的迭代器范围 [first, last)。
⚝ e: regex 或 wregex 对象，表示要匹配的正则表达式。
⚝ fmt: 替换格式字符串，可以是 C 风格字符串或 std::string。
⚝ flags: regex_constants::format_flag_type 类型的格式化选项，默认为 regex_constants::format_default。
② 版本 2：返回新的字符串 (简化版本)
1
template <class BidirectionalIterator, class Regex, class FormatFlags>
2
std::basic_string<typename std::iterator_traits<BidirectionalIterator>::value_type>
3
regex_replace(BidirectionalIterator first, BidirectionalIterator last, const Regex& e, const std::basic_string<charT>& fmt, FormatFlags flags = regex_constants::format_default);
4
5
template <class String, class Regex, class FormatFlags>
6
std::basic_string<typename String::value_type>
7
regex_replace(const String& s, const Regex& e, const std::basic_string<charT>& fmt, FormatFlags flags = regex_constants::format_default);
⚝ 这些版本直接返回替换后的新字符串，无需提供输出迭代器。
7.5.2 regex_replace 函数的功能和用法（Functionality and Usage of regex_replace Function）
regex_replace 函数的主要功能是在输入序列中查找所有与正则表达式匹配的子序列，并将它们替换为指定的替换字符串。
替换操作的含义：
⚝ 在输入序列中查找所有不重叠的匹配子序列。
⚝ 将每个匹配的子序列替换为替换字符串。
⚝ 未匹配的部分保持不变。
⚝ 替换操作的结果可以写入到输出迭代器，或者作为新的字符串返回。
使用场景：
⚝ 文本替换，例如批量替换文档中的关键词、格式转换等。
⚝ 数据清洗和预处理，例如去除 HTML 标签、替换特殊字符等。
⚝ 代码转换和重构，例如批量修改代码中的变量名、函数名等。
替换格式字符串 fmt：
替换格式字符串 fmt 可以包含特殊格式说明符，用于引用匹配结果中的捕获组。常用的格式说明符包括：
⚝ $& 或 $0：整个匹配的子序列。
⚝ $1, $2, $3, ... , $9：第 1, 2, 3, ... , 9 个捕获组匹配的子序列。
⚝ $``：匹配的前缀部分。
⚝$'：匹配的后缀部分。
⚝$$：插入一个$字符。
⚝${name}：具名捕获组 name 匹配的子序列（如果正则表达式使用了具名捕获组）。
格式化选项 flags：
flags 参数是 regex_constants::format_flag_type 类型，用于控制替换操作的行为。常用的选项包括：
⚝ regex_constants::format_default：默认选项。
⚝ regex_constants::format_sed：兼容 sed 的替换行为。
⚝ regex_constants::format_perl：兼容 Perl 的替换行为。
⚝ regex_constants::format_literal：将替换字符串 fmt 视为字面量字符串，不解析格式说明符。
⚝ regex_constants::format_no_copy：不复制未匹配的部分到输出。默认情况下，未匹配的部分也会被复制到输出。
⚝ regex_constants::format_first_only：只替换第一个匹配的子序列。默认情况下，替换所有匹配的子序列。
这些选项可以使用 | 运算符组合使用。
7.5.3 regex_replace 函数的使用示例（Examples of regex_replace Function Usage）
① 替换所有数字为 # 字符：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Order ID: 12345, Quantity: 10, Price: 99.99";
7
boost::regex number_pattern("\\d+(\\.\\d+)?"); // 匹配数字（整数或浮点数）
8
std::string replacement = "#";
9
10
std::string replaced_text = boost::regex_replace(text, number_pattern, replacement);
11
std::cout << "替换后的文本: " << replaced_text << std::endl;
12
13
return 0;
14
}
示例输出：
1
替换后的文本: Order ID: #, Quantity: #, Price: #
② 交换姓名中的姓和名：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string name = "John Doe";
7
boost::regex name_pattern("(\\w+) (\\w+)"); // 捕获名和姓
8
std::string replacement = "$2, $1"; // 替换为 "姓, 名" 格式
9
10
std::string swapped_name = boost::regex_replace(name, name_pattern, replacement);
11
std::cout << "交换后的姓名: " << swapped_name << std::endl;
12
13
return 0;
14
}
示例输出：
1
交换后的姓名: Doe, John
③ 使用 format_literal 选项：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Price: $100";
7
boost::regex dollar_pattern("\\$\\d+");
8
std::string replacement = "$$$&"; // 期望替换为 "$$100"
9
10
std::string replaced_text1 = boost::regex_replace(text, dollar_pattern, replacement); // 默认格式
11
std::cout << "默认格式替换: " << replaced_text1 << std::endl; // 格式说明符被解析
12
13
std::string replaced_text2 = boost::regex_replace(text, dollar_pattern, replacement, boost::regex::format_literal); // 字面量格式
14
std::cout << "字面量格式替换: " << replaced_text2 << std::endl; // 格式说明符被视为字面量
15
16
return 0;
17
}
示例输出：
1
默认格式替换: Price: $Price: $100
2
字面量格式替换: Price: $$$100
总结：
⚝ regex_replace 函数用于执行替换操作，将输入序列中匹配正则表达式的子序列替换为指定的替换字符串。
⚝ 可以使用格式说明符在替换字符串中引用匹配结果中的捕获组。
⚝ 提供了多种格式化选项，控制替换行为。
⚝ 适用于文本替换、数据清洗、代码转换等场景。
⚝ 理解替换格式字符串和格式化选项是使用 regex_replace 的关键。
7.6 迭代器详解：regex_iterator 和 regex_token_iterator（Detailed Explanation of Iterators: regex_iterator and regex_token_iterator）
Boost.Regex 库提供了两种迭代器，用于遍历正则表达式的匹配结果：regex_iterator 和 regex_token_iterator。
7.6.1 regex_iterator 详解（Detailed Explanation of regex_iterator）
regex_iterator 用于迭代查找输入序列中所有与正则表达式匹配的子序列。每次迭代器递增时，它会在输入序列中查找下一个匹配项。
7.6.1.1 regex_iterator 的定义（Definition of regex_iterator）
regex_iterator 类定义在 <boost/regex.hpp> 头文件中。其基本定义如下（简化版本）：
1
namespace boost {
2
3
template <class BidirectionalIterator, class charT = typename std::iterator_traits<BidirectionalIterator>::value_type, class traits = regex_traits<charT>, class Allocator = std::allocator<sub_match<BidirectionalIterator> > >
4
class regex_iterator {
5
public:
6
// ... 类型定义，例如 iterator_category, value_type, difference_type, pointer, reference
7
// ... 构造函数
8
// ... 解引用运算符：operator*(), operator->()
9
// ... 递增运算符：operator++(), operator++(int)
10
// ... 等于和不等于运算符：operator==(), operator!=()
11
// ... ...
12
};
13
14
typedef regex_iterator<std::string::const_iterator> sregex_iterator;
15
typedef regex_iterator<std::wstring::const_iterator> wsregex_iterator;
16
17
} // namespace boost
sregex_iterator 是 regex_iterator<std::string::const_iterator> 的别名，用于处理 char 类型的字符串；wsregex_iterator 是 regex_iterator<std::wstring::const_iterator> 的别名，用于处理 wchar_t 类型的字符串。
7.6.1.2 regex_iterator 的构造函数（Constructors of regex_iterator）
regex_iterator 有两个主要的构造函数：
① 构造迭代器开始位置：
1
regex_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex& e, match_flag_type flags = regex_constants::match_default);
⚝ a, b: 定义输入序列的迭代器范围 [a, b)。
⚝ e: regex 或 wregex 对象，表示要匹配的正则表达式。
⚝ flags: regex_constants::match_flag_type 类型的匹配选项，默认为 regex_constants::match_default。
这个构造函数会立即在输入序列 [a, b) 中查找第一个匹配项。如果找到匹配，迭代器将指向第一个匹配结果；如果没有找到匹配，迭代器将变为尾后迭代器。
② 默认构造函数（尾后迭代器）：
1
regex_iterator();
创建一个尾后迭代器。尾后迭代器表示迭代的结束，与 regex_iterator 的结束位置进行比较。
7.6.1.3 regex_iterator 的操作（Operations of regex_iterator）
⚝ 解引用运算符 * 和 ->：返回当前的匹配结果，类型为 smatch 或 wsmatch 对象。
⚝ 递增运算符 ++ (前缀和后缀)：查找输入序列中的下一个匹配项。如果找到匹配，迭代器指向新的匹配结果；如果没有找到匹配，迭代器变为尾后迭代器。
⚝ 等于和不等于运算符 == 和 !=：用于比较两个 regex_iterator 是否相等。两个迭代器相等，如果它们都是尾后迭代器，或者它们指向相同的匹配结果。
7.6.1.4 regex_iterator 的使用示例（Examples of regex_iterator Usage）
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Words: hello world regex iterator example";
7
boost::regex word_pattern("\\b\\w+\\b"); // 匹配单词
8
9
boost::sregex_iterator begin(text.begin(), text.end(), word_pattern);
10
boost::sregex_iterator end; // 尾后迭代器
11
12
for (boost::sregex_iterator i = begin; i != end; ++i) {
13
boost::smatch match = *i;
14
std::cout << "找到单词: " << match[0] << "，位置: [" << match.position() << ", " << match.position() + match.length() << ")" << std::endl;
15
}
16
17
return 0;
18
}
示例输出：
1
找到单词: Words，位置: [0, 5)
2
找到单词: hello，位置: [7, 12)
3
找到单词: world，位置: [13, 18)
4
找到单词: regex，位置: [19, 24)
5
找到单词: iterator，位置: [25, 33)
6
找到单词: example，位置: [34, 41)
7.6.2 regex_token_iterator 详解（Detailed Explanation of regex_token_iterator）
regex_token_iterator 提供了更灵活的迭代方式，可以迭代匹配的子序列，也可以迭代未匹配的子序列（分割字符串）。
7.6.2.1 regex_token_iterator 的定义（Definition of regex_token_iterator）
regex_token_iterator 类定义在 <boost/regex.hpp> 头文件中。其基本定义如下（简化版本）：
1
namespace boost {
2
3
template <class BidirectionalIterator, class charT = typename std::iterator_traits<BidirectionalIterator>::value_type, class traits = regex_traits<charT>, class Allocator = std::allocator<std::basic_string<charT> > >
4
class regex_token_iterator {
5
public:
6
// ... 类型定义
7
// ... 构造函数
8
// ... 解引用运算符：operator*(), operator->()
9
// ... 递增运算符：operator++(), operator++(int)
10
// ... 等于和不等于运算符：operator==(), operator!=()
11
// ... ...
12
};
13
14
typedef regex_token_iterator<std::string::const_iterator> sregex_token_iterator;
15
typedef regex_token_iterator<std::wstring::const_iterator> wsregex_token_iterator;
16
17
} // namespace boost
sregex_token_iterator 和 wsregex_token_iterator 分别用于处理 char 和 wchar_t 类型的字符串。
7.6.2.2 regex_token_iterator 的构造函数（Constructors of regex_token_iterator）
regex_token_iterator 有多个构造函数，其中最常用的包括：
① 迭代匹配的子表达式：
1
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex& e, int submatch = 0, match_flag_type flags = regex_constants::match_default);
2
regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex& e, const std::vector<int>& submatches, match_flag_type flags = regex_constants::match_default);
⚝ a, b: 定义输入序列的迭代器范围 [a, b)。
⚝ e: regex 或 wregex 对象。
⚝ submatch: 指定要迭代的子表达式的索引。
▮▮▮▮⚝ 0：迭代整个匹配的子序列（默认值）。
▮▮▮▮⚝ 1, 2, ...：迭代第 1, 2, ... 个捕获组匹配的子序列.
▮▮▮▮⚝ -1：迭代未匹配的子序列（分割字符串）。
⚝ submatches: 可以指定一个整数向量，迭代多个子表达式或未匹配的子序列。
⚝ flags: 匹配选项。
② 默认构造函数（尾后迭代器）：
1
regex_token_iterator();
创建尾后迭代器。
7.6.2.3 regex_token_iterator 的操作（Operations of regex_token_iterator）
⚝ 解引用运算符 * 和 ->：返回当前的迭代结果，类型为 std::string 或 std::wstring 对象（而不是 smatch）。
⚝ 递增运算符 ++ (前缀和后缀)：查找下一个迭代结果。
⚝ 等于和不等于运算符 == 和 !=：用于比较两个 regex_token_iterator 是否相等。
7.6.2.4 regex_token_iterator 的使用示例（Examples of regex_token_iterator Usage）
① 迭代整个匹配的子序列（默认行为，等同于 regex_iterator）：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Tokens: token1, token2, token3";
7
boost::regex token_pattern("\\b\\w+\\b");
8
9
boost::sregex_token_iterator begin(text.begin(), text.end(), token_pattern);
10
boost::sregex_token_iterator end;
11
12
for (boost::sregex_token_iterator i = begin; i != end; ++i) {
13
std::cout << "Token: " << *i << std::endl;
14
}
15
16
return 0;
17
}
示例输出：
1
Token: Tokens
2
Token: token1
3
Token: token2
4
Token: token3
② 迭代第一个捕获组：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Pairs: key1=value1, key2=value2";
7
boost::regex pair_pattern("(\\w+)=(\\w+)"); // 捕获 key 和 value
8
9
boost::sregex_token_iterator begin(text.begin(), text.end(), pair_pattern, 1); // 迭代第一个捕获组 (key)
10
boost::sregex_token_iterator end;
11
12
for (boost::sregex_token_iterator i = begin; i != end; ++i) {
13
std::cout << "Key: " << *i << std::endl;
14
}
15
16
return 0;
17
}
示例输出：
1
Key: key1
2
Key: key2
③ 迭代未匹配的子序列（分割字符串）：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "Split,this,string,by,comma";
7
boost::regex comma_pattern(","); // 以逗号作为分隔符
8
9
boost::sregex_token_iterator begin(text.begin(), text.end(), comma_pattern, -1); // 迭代未匹配的子序列
10
boost::sregex_token_iterator end;
11
12
for (boost::sregex_token_iterator i = begin; i != end; ++i) {
13
std::cout << "Part: " << *i << std::endl;
14
}
15
16
return 0;
17
}
示例输出：
1
Part: Split
2
Part: this
3
Part: string
4
Part: by
5
Part: comma
总结：
⚝ regex_iterator 用于迭代查找输入序列中所有匹配的子序列，每次迭代返回 smatch 对象。
⚝ regex_token_iterator 提供了更灵活的迭代方式，可以迭代匹配的子序列或未匹配的子序列。
⚝ regex_token_iterator 可以通过指定子表达式索引或 -1 来选择迭代的内容。
⚝ regex_token_iterator 的解引用运算符返回 std::string 或 std::wstring 对象。
⚝ regex_iterator 适用于需要遍历所有匹配结果的场景，regex_token_iterator 适用于需要更灵活地处理匹配结果或分割字符串的场景。
END_OF_CHAPTER
8. chapter 8： 实战案例分析（Practical Case Studies）
8.1 数据验证：邮箱、URL、电话号码验证（Data Validation: Email, URL, Phone Number Validation）
数据验证（Data Validation）是软件开发中不可或缺的一环，它确保用户输入的数据符合预期的格式和规则，从而提高程序的健壮性和安全性。正则表达式（Regular Expressions）在数据验证领域扮演着至关重要的角色，能够简洁高效地定义复杂的验证规则。Boost.Regex 库为 C++ 开发者提供了强大的正则表达式工具，使得数据验证任务变得更加便捷。
本节将通过三个常见的实战案例：邮箱验证、URL 验证和电话号码验证，详细展示如何使用 Boost.Regex 进行数据验证。
8.1.1 邮箱验证（Email Validation）
邮箱地址的格式相对复杂，但存在一些通用的规则。一个基本的邮箱地址通常由以下部分组成：
① 用户名（Username）：由字母、数字、下划线、点号等字符组成。
② @ 符号：分隔用户名和域名。
③ 域名（Domain）：由字母、数字、点号、短横线等字符组成，通常包含顶级域名（例如 .com、.org、.net 等）。
一个简单的邮箱验证正则表达式可以如下所示：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string email;
7
std::cout << "请输入邮箱地址: ";
8
std::cin >> email;
9
10
boost::regex email_regex(R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})"); // 原始字符串字面量
11
12
if (boost::regex_match(email, email_regex)) {
13
std::cout << "邮箱地址格式正确！" << std::endl;
14
} else {
15
std::cout << "邮箱地址格式错误！" << std::endl;
16
}
17
18
return 0;
19
}
代码解析：
⚝ R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})"：这是一个原始字符串字面量（Raw String Literal）表示的正则表达式。使用原始字符串字面量可以避免反斜杠 \ 的转义问题，使正则表达式更易读。
▮▮▮▮⚝ [a-zA-Z0-9._%+-]+：匹配用户名部分，允许字母、数字、点号 .、下划线 _、百分号 %、加号 +、短横线 -，+ 表示至少出现一次。
▮▮▮▮⚝ @：匹配 @ 符号。
▮▮▮▮⚝ [a-zA-Z0-9.-]+：匹配域名部分，允许字母、数字、点号 .、短横线 -，+ 表示至少出现一次。
▮▮▮▮⚝ \.：匹配点号 .，需要使用反斜杠 \ 进行转义，因为 . 在正则表达式中是元字符，表示匹配任意字符。
▮▮▮▮⚝ [a-zA-Z]{2,}：匹配顶级域名部分，允许字母，{2,} 表示至少出现两次，例如 .com、.org。
更严格的邮箱验证：
上述正则表达式已经可以满足大部分邮箱验证需求，但在实际应用中，可能需要更严格的验证规则，例如：
⚝ 限制用户名和域名的字符范围。
⚝ 验证顶级域名的有效性。
⚝ 考虑国际化域名（Internationalized Domain Name，IDN）。
更严格的邮箱验证正则表达式可能会非常复杂，可以参考 RFC 5322 等标准文档。但需要权衡验证的严格性和性能，以及用户体验。对于大多数应用场景，上述简单的正则表达式已经足够。
8.1.2 URL 验证（URL Validation）
URL（Uniform Resource Locator，统一资源定位符）用于定位互联网上的资源。URL 的格式比较复杂，包含协议（Protocol）、域名（Domain）、路径（Path）、查询参数（Query Parameters）等部分。
一个基本的 URL 验证正则表达式可以如下所示：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string url;
7
std::cout << "请输入 URL: ";
8
std::cin >> url;
9
10
boost::regex url_regex(R"((https?|ftp)://[^\s/$.?#].[^\s]*)");
11
12
if (boost::regex_match(url, url_regex)) {
13
std::cout << "URL 格式正确！" << std::endl;
14
} else {
15
std::cout << "URL 格式错误！" << std::endl;
16
}
17
18
return 0;
19
}
代码解析：
⚝ R"((https?|ftp)://[^\s/$.?#].[^\s]*)"：这是一个用于 URL 验证的正则表达式。
▮▮▮▮⚝ (https?|ftp)：匹配协议部分，https? 匹配 http 或 https，| 表示或，ftp 匹配 ftp。
▮▮▮▮⚝ ://：匹配 ://。
▮▮▮▮⚝ [^\s/$.?#.]：匹配域名或 IP 地址的第一个字符，[^...] 表示排除字符集，\s 匹配空白字符，/、$、.、?、# 都是 URL 中的分隔符或特殊字符，需要排除。
▮▮▮▮⚝ [^\s]*：匹配域名、路径、查询参数等剩余部分，[^\s] 匹配非空白字符，* 表示零个或多个。
更完善的 URL 验证：
上述正则表达式可以验证基本的 URL 格式，但对于更复杂的 URL 结构，可能需要更完善的正则表达式，例如：
⚝ 验证域名格式的有效性。
⚝ 验证路径和查询参数的格式。
⚝ 考虑端口号、用户名密码等信息。
更严格的 URL 验证正则表达式会更加复杂，可以参考 RFC 3986 等标准文档。实际应用中，可以根据具体需求选择合适的验证严格程度。
8.1.3 电话号码验证（Phone Number Validation）
电话号码的格式因国家和地区而异，没有统一的国际标准。但通常都遵循一定的规则，例如：
⚝ 包含数字。
⚝ 可能包含区号、国家代码、分隔符（例如空格、短横线）。
⚝ 长度有一定的限制。
以下是一个简单的中国大陆地区手机号码验证的正则表达式示例：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string phone_number;
7
std::cout << "请输入中国大陆手机号码: ";
8
std::cin >> phone_number;
9
10
boost::regex phone_regex(R"((?:(?:\+|00)86)?1[3-9]\d{9})");
11
12
if (boost::regex_match(phone_number, phone_regex)) {
13
std::cout << "手机号码格式正确！" << std::endl;
14
} else {
15
std::cout << "手机号码格式错误！" << std::endl;
16
}
17
18
return 0;
19
}
代码解析：
⚝ R"((?:(?:\+|00)86)?1[3-9]\d{9})"：这是一个用于中国大陆手机号码验证的正则表达式。
▮▮▮▮⚝ (?:(?:\+|00)86)?：匹配可选的国家代码，(?:...) 表示非捕获组，\+ 匹配加号 +，| 表示或，00 匹配 00，86 是中国大陆的国家代码，? 表示整个国家代码部分是可选的。
▮▮▮▮⚝ 1：匹配手机号码的第一位数字 1。
▮▮▮▮⚝ [3-9]：匹配手机号码的第二位数字，中国大陆手机号码第二位数字通常是 3 到 9。
▮▮▮▮⚝ \d{9}：匹配手机号码的后九位数字，\d 匹配数字，{9} 表示出现九次。
更灵活的电话号码验证：
由于电话号码格式的多样性，更通用的电话号码验证正则表达式会更加复杂，需要考虑：
⚝ 不同国家和地区的区号和格式。
⚝ 分隔符的多样性。
⚝ 固定电话和移动电话的区别。
可以使用更复杂的正则表达式，或者结合其他库（例如 libphonenumber）进行更精确的电话号码验证。在实际应用中，可以根据具体需求选择合适的验证策略。
8.2 日志文件分析与处理（Log File Analysis and Processing）
日志文件（Log File）记录了系统或应用程序运行时的各种事件信息，是故障排查、性能分析、安全审计的重要数据来源。日志文件通常包含大量的文本数据，结构化程度较低，使用正则表达式可以高效地从日志文件中提取关键信息，进行分析和处理。
本节将以一个简单的 Web 服务器访问日志为例，展示如何使用 Boost.Regex 进行日志文件分析。
日志示例：
1
[2023-10-27 10:00:00] [INFO] [192.168.1.100] - GET /index.html HTTP/1.1 - 200 OK
2
[2023-10-27 10:00:05] [ERROR] [192.168.1.101] - POST /api/user - 404 Not Found
3
[2023-10-27 10:00:10] [WARNING] [192.168.1.102] - GET /image.png HTTP/1.1 - 304 Not Modified
4
[2023-10-27 10:00:15] [INFO] [192.168.1.103] - GET /style.css HTTP/1.1 - 200 OK
日志分析需求：
假设我们需要从上述日志文件中提取以下信息：
① 时间戳（Timestamp）
② 日志级别（Log Level）
③ IP 地址（IP Address）
④ 请求方法（Method）
⑤ 请求路径（Path）
⑥ 状态码（Status Code）
Boost.Regex 代码示例：
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
#include <boost/regex.hpp>
5
6
int main() {
7
std::ifstream log_file("access.log"); // 假设日志文件名为 access.log
8
std::string line;
9
boost::regex log_regex(R"(\[(.*?)\]\s\[(.*?)\]\s\[(.*?)\]\s-\s(GET|POST|PUT|DELETE)\s(.*?)\sHTTP/1\.1\s-\s(\d{3})\s.*)");
10
11
if (log_file.is_open()) {
12
while (std::getline(log_file, line)) {
13
boost::smatch match;
14
if (boost::regex_match(line, match, log_regex)) {
15
std::cout << "时间戳: " << match[1] << std::endl;
16
std::cout << "日志级别: " << match[2] << std::endl;
17
std::cout << "IP 地址: " << match[3] << std::endl;
18
std::cout << "请求方法: " << match[4] << std::endl;
19
std::cout << "请求路径: " << match[5] << std::endl;
20
std::cout << "状态码: " << match[6] << std::endl;
21
std::cout << "--------------------" << std::endl;
22
}
23
}
24
log_file.close();
25
} else {
26
std::cerr << "无法打开日志文件！" << std::endl;
27
return 1;
28
}
29
30
return 0;
31
}
代码解析：
⚝ std::ifstream log_file("access.log");：打开名为 access.log 的日志文件。
⚝ boost::regex log_regex(R"(\[(.*?)\]\s\[(.*?)\]\s\[(.*?)\]\s-\s(GET|POST|PUT|DELETE)\s(.*?)\sHTTP/1\.1\s-\s(\d{3})\s.*)");：定义日志分析的正则表达式。
▮▮▮▮⚝ \[(.*?)\]：匹配方括号 [] 包围的内容，例如时间戳、日志级别、IP 地址。 .*? 使用懒惰量词 *? 匹配尽可能少的字符，避免跨行匹配。
▮▮▮▮⚝ \s：匹配空白字符。
▮▮▮▮⚝ (GET|POST|PUT|DELETE)：匹配请求方法，使用分组捕获。
▮▮▮▮⚝ (.*?)：匹配请求路径，使用分组捕获。
▮▮▮▮⚝ (\d{3})：匹配状态码，使用分组捕获，\d{3} 匹配三个数字。
▮▮▮▮⚝ .*：匹配日志行的剩余部分。
⚝ boost::smatch match;：声明 smatch 对象用于存储匹配结果。
⚝ boost::regex_match(line, match, log_regex)：使用 regex_match 函数尝试将当前日志行与正则表达式进行匹配。如果匹配成功，结果存储在 match 对象中。
⚝ match[1], match[2], ..., match[6]：通过索引访问 smatch 对象，获取捕获组的内容，分别对应时间戳、日志级别、IP 地址、请求方法、请求路径、状态码。
日志分析进阶：
上述示例展示了基本的日志文件分析方法。在实际应用中，日志分析可能更加复杂，例如：
⚝ 处理不同格式的日志文件。
⚝ 进行更复杂的日志信息提取和转换。
⚝ 结合其他工具（例如 Elasticsearch, Logstash, Kibana (ELK) 栈）进行日志分析和可视化。
Boost.Regex 可以作为日志分析的基础工具，与其他工具和技术结合使用，构建更强大的日志分析系统。
8.3 文本编辑器中的查找与替换功能实现（Implementing Find and Replace Functionality in a Text Editor）
文本编辑器的查找与替换功能是日常工作中常用的文本处理工具。正则表达式可以为查找与替换功能提供强大的模式匹配能力，支持更灵活、更复杂的查找和替换操作。Boost.Regex 库可以方便地集成到文本编辑器中，实现基于正则表达式的查找与替换功能。
查找功能实现：
文本编辑器的查找功能通常需要用户输入查找的文本或正则表达式，然后在文本中查找匹配的内容。Boost.Regex 的 regex_search 函数可以用于实现查找功能。
代码示例：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a test string with some words like test, testing, and tests.";
7
std::string pattern;
8
std::cout << "请输入查找的正则表达式: ";
9
std::getline(std::cin, pattern); // 使用 getline 读取包含空格的正则表达式
10
11
boost::regex find_regex(pattern);
12
boost::smatch match;
13
14
if (boost::regex_search(text, match, find_regex)) {
15
std::cout << "找到匹配项: " << match.str() << std::endl;
16
std::cout << "匹配位置: " << match.position() << std::endl;
17
} else {
18
std::cout << "未找到匹配项！" << std::endl;
19
}
20
21
return 0;
22
}
代码解析：
⚝ std::getline(std::cin, pattern);：使用 getline 函数读取用户输入的正则表达式，可以处理包含空格的正则表达式。
⚝ boost::regex find_regex(pattern);：根据用户输入的正则表达式创建 regex 对象。
⚝ boost::regex_search(text, match, find_regex)：使用 regex_search 函数在文本 text 中查找与正则表达式 find_regex 匹配的内容。如果找到匹配项，结果存储在 match 对象中。
⚝ match.str()：获取匹配的字符串。
⚝ match.position()：获取匹配项在文本中的起始位置。
替换功能实现：
文本编辑器的替换功能需要在查找的基础上，将匹配的内容替换为指定的文本。Boost.Regex 的 regex_replace 函数可以用于实现替换功能。
代码示例：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string text = "This is a test string with some words like test, testing, and tests.";
7
std::string pattern;
8
std::string replacement;
9
10
std::cout << "请输入查找的正则表达式: ";
11
std::getline(std::cin, pattern);
12
std::cout << "请输入替换文本: ";
13
std::getline(std::cin, replacement);
14
15
boost::regex replace_regex(pattern);
16
std::string replaced_text = boost::regex_replace(text, replace_regex, replacement);
17
18
std::cout << "替换后的文本: " << replaced_text << std::endl;
19
20
return 0;
21
}
代码解析：
⚝ std::getline(std::cin, replacement);：读取用户输入的替换文本。
⚝ boost::regex_replace(text, replace_regex, replacement)：使用 regex_replace 函数将文本 text 中与正则表达式 replace_regex 匹配的内容替换为 replacement 文本，返回替换后的新字符串。
查找与替换功能增强：
基于 Boost.Regex，可以实现更强大的查找与替换功能，例如：
⚝ 区分大小写/不区分大小写：通过 regex 对象的选项控制，例如 boost::regex::icase。
⚝ 全局替换/替换第一个匹配项：regex_replace 函数默认进行全局替换，可以通过 regex_search 和 regex_replace 结合循环实现替换第一个匹配项的功能。
⚝ 使用捕获组进行替换：在替换文本中使用 $1, $2 等引用捕获组的内容，实现更灵活的替换。
⚝ 正则表达式语法选择：Boost.Regex 支持多种正则表达式语法，可以根据需要选择合适的语法。
8.4 网络爬虫中的信息提取（Information Extraction in Web Crawlers）
网络爬虫（Web Crawler）是自动抓取互联网信息的程序。从 HTML 网页中提取有用的信息是网络爬虫的核心任务之一。HTML 是一种结构化的文本格式，但其结构复杂，标签嵌套，直接解析 HTML 文本比较困难。正则表达式可以用于从 HTML 文本中提取特定模式的信息，例如链接、图片、标题、正文等。
HTML 示例：
1
<!DOCTYPE html>
2
<html>
3
<head>
4
<title>Example Page</title>
5
</head>
6
<body>
7
<h1>Welcome to Example Page</h1>
8
<p>This is an example page with a <a href="https://www.example.com">link</a> and an <img src="image.jpg" alt="example image">.</p>
9
</body>
10
</html>
信息提取需求：
假设我们需要从上述 HTML 文本中提取以下信息：
① 网页标题（Title）
② 链接（Links）
③ 图片链接（Image URLs）
Boost.Regex 代码示例：
1
#include <iostream>
2
#include <string>
3
#include <boost/regex.hpp>
4
5
int main() {
6
std::string html_text = R"(
7
<!DOCTYPE html>
8
<html>
9
<head>
10
<title>Example Page</title>
11
</head>
12
<body>
13
<h1>Welcome to Example Page</h1>
14
<p>This is an example page with a <a href="https://www.example.com">link</a> and an <img src="image.jpg" alt="example image">.</p>
15
</body>
16
</html>
17
)";
18
19
// 提取网页标题
20
boost::regex title_regex(R"(<title>(.*?)</title>)");
21
boost::smatch title_match;
22
if (boost::regex_search(html_text, title_match, title_regex)) {
23
std::cout << "网页标题: " << title_match[1] << std::endl;
24
}
25
26
// 提取链接
27
boost::regex link_regex(R"(<a href="(.*?)">)");
28
boost::sregex_iterator link_begin(html_text.begin(), html_text.end(), link_regex);
29
boost::sregex_iterator link_end;
30
std::cout << "链接: " << std::endl;
31
for (boost::sregex_iterator it = link_begin; it != link_end; ++it) {
32
std::cout << it->str(1) << std::endl;
33
}
34
35
// 提取图片链接
36
boost::regex img_regex(R"(<img src="(.*?)"[^>]*>)");
37
boost::sregex_iterator img_begin(html_text.begin(), html_text.end(), img_regex);
38
boost::sregex_iterator img_end;
39
std::cout << "图片链接: " << std::endl;
40
for (boost::sregex_iterator it = img_begin; it != img_end; ++it) {
41
std::cout << it->str(1) << std::endl;
42
}
43
44
return 0;
45
}
代码解析：
⚝ std::string html_text = R"(...)";：使用原始字符串字面量存储 HTML 文本。
⚝ 提取网页标题：
▮▮▮▮⚝ boost::regex title_regex(R"(<title>(.*?)</title>)");：定义提取网页标题的正则表达式，.*? 匹配 title 标签之间的内容。
▮▮▮▮⚝ boost::regex_search(html_text, title_match, title_regex)：使用 regex_search 函数查找标题。
▮▮▮▮⚝ title_match[1]：获取捕获组的内容，即网页标题。
⚝ 提取链接：
▮▮▮▮⚝ boost::regex link_regex(R"(<a href="(.*?)">)");：定义提取链接的正则表达式，.*? 匹配 href 属性的值。
▮▮▮▮⚝ boost::sregex_iterator link_begin(html_text.begin(), html_text.end(), link_regex);：创建 sregex_iterator 对象，用于迭代查找所有匹配的链接。
▮▮▮▮⚝ for (boost::sregex_iterator it = link_begin; it != link_end; ++it)：使用迭代器遍历所有匹配项。
▮▮▮▮⚝ it->str(1)：获取当前匹配项的第一个捕获组的内容，即链接地址。
⚝ 提取图片链接：
▮▮▮▮⚝ boost::regex img_regex(R"(<img src="(.*?)"[^>]*>)");：定义提取图片链接的正则表达式，.*? 匹配 src 属性的值，[^>]* 匹配 > 之前的其他属性。
▮▮▮▮⚝ 使用 sregex_iterator 迭代器遍历所有匹配的图片链接，方法与提取链接类似。
HTML 解析进阶：
正则表达式可以用于简单的 HTML 信息提取，但对于复杂的 HTML 结构，正则表达式的解析能力有限，容易出错。更健壮的 HTML 解析方法通常使用专门的 HTML 解析库，例如：
⚝ Beautiful Soup (Python)
⚝ jsoup (Java)
⚝ libxml2 (C/C++)
这些库可以将 HTML 文档解析成 DOM（Document Object Model）树结构，方便开发者使用 CSS 选择器或 XPath 等方式进行更精确、更可靠的信息提取。在实际网络爬虫开发中，可以根据 HTML 的复杂程度选择合适的解析工具。对于简单的网页结构，Boost.Regex 仍然可以作为一种快速的信息提取手段。
END_OF_CHAPTER
9. chapter 9： Boost.Regex 与其他 Boost 库的集成（Integration of Boost.Regex with Other Boost Libraries）
9.1 Boost.Asio 与 Boost.Regex：网络编程中的应用（Boost.Asio and Boost.Regex: Applications in Network Programming）
Boost.Asio 库是一个用于网络和底层 I/O 编程的跨平台 C++ 库，它允许开发者编写高性能、可伸缩的网络应用程序。在网络编程中，处理和解析各种文本协议和数据格式是常见的任务。而 Boost.Regex 库在处理文本模式匹配和提取方面表现出色，将两者结合使用，可以极大地简化和增强网络应用程序中数据处理的能力。本节将探讨 Boost.Asio 与 Boost.Regex 如何协同工作，以及在网络编程中的实际应用场景。
① 数据包解析与协议分析：
在网络编程中，接收到的数据通常需要按照特定的协议格式进行解析。例如，HTTP 协议、SMTP 协议等都有其特定的文本格式。Boost.Regex 可以用来解析这些协议的头部信息、请求行、状态行等关键部分。
例如，假设我们需要解析一个简单的 HTTP 请求头，提取出请求方法和 URL。我们可以使用 Boost.Asio 接收数据，然后使用 Boost.Regex 对接收到的字符串进行解析。
1
#include <iostream>
2
#include <string>
3
#include <boost/asio.hpp>
4
#include <boost/regex.hpp>
5
6
using namespace boost::asio;
7
using namespace boost::asio::ip;
8
9
int main() {
10
try {
11
io_context io_context;
12
tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 8080));
13
tcp::socket socket(io_context);
14
acceptor.accept(socket);
15
16
boost::asio::streambuf buffer;
17
boost::asio::read_until(socket, buffer, "\r\n\r\n"); // 读取到 HTTP 头部结束
18
19
std::string http_header(boost::asio::buffer_cast<const char*>(buffer.data()));
20
std::cout << "Received HTTP Header:\n" << http_header << std::endl;
21
22
boost::regex request_line_regex("^(\\w+) (\\S+) HTTP/\\d\\.\\d$");
23
boost::smatch match;
24
25
if (boost::regex_search(http_header, match, request_line_regex)) {
26
std::cout << "Request Method: " << match[1] << std::endl;
27
std::cout << "URL: " << match[2] << std::endl;
28
} else {
29
std::cout << "Failed to parse HTTP request line." << std::endl;
30
}
31
32
} catch (std::exception& e) {
33
std::cerr << "Exception: " << e.what() << std::endl;
34
}
35
return 0;
36
}
在这个例子中，我们首先使用 Boost.Asio 建立一个简单的 TCP 服务器，接收客户端发送的 HTTP 请求头。然后，我们使用 boost::regex 定义了一个正则表达式 request_line_regex，用于匹配 HTTP 请求行的格式。通过 boost::regex_search 函数，我们在接收到的 HTTP 头部字符串中搜索匹配请求行，并将匹配结果存储在 boost::smatch 对象 match 中。最后，我们从 match 对象中提取出请求方法和 URL。
② 网络数据验证：
在网络应用程序中，验证接收到的数据是否符合预期的格式和规范至关重要。例如，验证用户输入的邮箱地址、URL、IP 地址等。Boost.Regex 可以用来进行这些数据验证，确保数据的有效性和安全性。
假设我们需要验证从网络接收到的数据是否为有效的 IPv4 地址。
1
#include <iostream>
2
#include <string>
3
#include <boost/asio.hpp>
4
#include <boost/regex.hpp>
5
6
using namespace boost::asio;
7
using namespace boost::asio::ip;
8
9
bool is_valid_ipv4(const std::string& ip_address) {
10
boost::regex ipv4_regex("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$");
11
return boost::regex_match(ip_address, ipv4_regex);
12
}
13
14
int main() {
15
try {
16
io_context io_context;
17
tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), 8080));
18
tcp::socket socket(io_context);
19
acceptor.accept(socket);
20
21
boost::asio::streambuf buffer;
22
boost::asio::read_until(socket, buffer, "\r\n"); // 假设接收 IP 地址以换行符结尾
23
24
std::string ip_address(boost::asio::buffer_cast<const char*>(buffer.data()));
25
ip_address.pop_back(); // 移除换行符
26
std::cout << "Received IP Address: " << ip_address << std::endl;
27
28
if (is_valid_ipv4(ip_address)) {
29
std::cout << "Valid IPv4 address." << std::endl;
30
} else {
31
std::cout << "Invalid IPv4 address." << std::endl;
32
}
33
34
} catch (std::exception& e) {
35
std::cerr << "Exception: " << e.what() << std::endl;
36
}
37
return 0;
38
}
在这个例子中，is_valid_ipv4 函数使用正则表达式 ipv4_regex 来验证输入的字符串是否符合 IPv4 地址的格式。在 main 函数中，我们接收来自网络的数据，并使用 is_valid_ipv4 函数验证接收到的字符串是否为有效的 IPv4 地址。
③ 日志分析与过滤：
网络应用程序通常会生成大量的日志信息，这些日志信息对于监控应用运行状态、排查错误非常重要。Boost.Regex 可以用于分析和过滤网络应用程序的日志，提取出关键信息或错误日志。
假设我们有一个网络服务器的日志文件，每行日志包含时间戳、日志级别和日志消息。我们想要过滤出所有错误级别的日志信息。虽然 Boost.Asio 本身不直接处理文件，但可以结合 Boost.Filesystem 读取日志文件，然后使用 Boost.Regex 进行日志分析。 （下一节将详细介绍 Boost.Filesystem 与 Boost.Regex 的集成）。
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
#include <boost/regex.hpp>
5
6
int main() {
7
std::ifstream log_file("server.log");
8
std::string log_line;
9
boost::regex error_log_regex("^\\[(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2})\\] \\[ERROR\\] (.*)$"); // 匹配 [时间戳] [ERROR] 日志消息
10
boost::smatch match;
11
12
if (log_file.is_open()) {
13
while (std::getline(log_file, log_line)) {
14
if (boost::regex_search(log_line, match, error_log_regex)) {
15
std::cout << "Timestamp: " << match[1] << ", Error Message: " << match[2] << std::endl;
16
}
17
}
18
log_file.close();
19
} else {
20
std::cerr << "Unable to open log file." << std::endl;
21
}
22
return 0;
23
}
这个例子演示了如何使用 Boost.Regex 从日志文件中提取错误日志。我们定义了一个正则表达式 error_log_regex 来匹配包含 "[ERROR]" 关键字的日志行，并提取出时间戳和错误消息。
通过以上示例，我们可以看到 Boost.Asio 与 Boost.Regex 结合使用，可以有效地处理网络编程中的数据解析、验证和日志分析等任务，提高网络应用程序的开发效率和健壮性。
9.2 Boost.Filesystem 与 Boost.Regex：文件系统操作中的应用（Boost.Filesystem and Boost.Regex: Applications in File System Operations）
Boost.Filesystem 库提供了一种可移植的方式来操作文件系统，包括文件和目录的创建、删除、遍历、查询属性等。在文件系统操作中，经常需要根据特定的模式查找文件、处理文件名或文件内容。Boost.Regex 可以与 Boost.Filesystem 库结合使用，实现强大的文件系统操作功能。本节将探讨 Boost.Filesystem 与 Boost.Regex 如何协同工作，以及在文件系统操作中的实际应用场景。
① 文件查找与过滤：
Boost.Filesystem 提供了目录迭代器（directory_iterator 和 recursive_directory_iterator）用于遍历目录及其子目录。结合 Boost.Regex，我们可以根据文件名或路径名模式来过滤文件。
例如，假设我们需要在一个目录及其子目录中查找所有扩展名为 .txt 的文件。
1
#include <iostream>
2
#include <string>
3
#include <boost/filesystem.hpp>
4
#include <boost/regex.hpp>
5
6
namespace fs = boost::filesystem;
7
8
int main() {
9
fs::path directory_path = "./"; // 查找当前目录
10
boost::regex txt_file_regex(".*\\.txt$"); // 匹配以 .txt 结尾的文件名
11
12
if (fs::exists(directory_path) && fs::is_directory(directory_path)) {
13
fs::recursive_directory_iterator it(directory_path);
14
fs::recursive_directory_iterator end_it;
15
16
for (; it != end_it; ++it) {
17
if (fs::is_regular_file(*it)) {
18
std::string filename = it->path().filename().string();
19
if (boost::regex_match(filename, txt_file_regex)) {
20
std::cout << "Found TXT file: " << it->path().string() << std::endl;
21
}
22
}
23
}
24
} else {
25
std::cerr << "Invalid directory path." << std::endl;
26
}
27
return 0;
28
}
在这个例子中，我们使用 fs::recursive_directory_iterator 遍历指定目录及其子目录下的所有文件和目录。对于每个文件，我们提取文件名，并使用 boost::regex_match 函数检查文件名是否匹配正则表达式 txt_file_regex，该正则表达式匹配以 .txt 结尾的文件名。
② 文件名批量重命名：
在文件管理中，批量重命名文件是一个常见的需求。Boost.Regex 可以用于匹配文件名模式，并结合 Boost.Filesystem 的文件重命名功能，实现灵活的文件名批量重命名。
例如，假设我们需要将当前目录下所有文件名中包含 "old" 的文件重命名，将 "old" 替换为 "new"。
1
#include <iostream>
2
#include <string>
3
#include <boost/filesystem.hpp>
4
#include <boost/regex.hpp>
5
6
namespace fs = boost::filesystem;
7
8
int main() {
9
fs::path directory_path = "./"; // 当前目录
10
boost::regex old_name_regex("(.*)old(.*)"); // 匹配包含 "old" 的文件名
11
std::string replacement_format = "\\1new\\2"; // 替换格式，使用反向引用
12
13
if (fs::exists(directory_path) && fs::is_directory(directory_path)) {
14
fs::directory_iterator it(directory_path);
15
fs::directory_iterator end_it;
16
17
for (; it != end_it; ++it) {
18
if (fs::is_regular_file(*it)) {
19
fs::path old_path = it->path();
20
std::string old_filename = old_path.filename().string();
21
boost::smatch match;
22
23
if (boost::regex_match(old_filename, match, old_name_regex)) {
24
std::string new_filename = boost::regex_replace(old_filename, old_name_regex, replacement_format);
25
fs::path new_path = old_path.parent_path() / new_filename;
26
fs::rename(old_path, new_path);
27
std::cout << "Renamed '" << old_filename << "' to '" << new_filename << "'" << std::endl;
28
}
29
}
30
}
31
} else {
32
std::cerr << "Invalid directory path." << std::endl;
33
}
34
return 0;
35
}
在这个例子中，我们遍历当前目录下的所有文件。对于每个文件，我们使用 boost::regex_match 检查文件名是否匹配正则表达式 old_name_regex，该正则表达式匹配包含 "old" 的文件名。如果匹配成功，我们使用 boost::regex_replace 函数将文件名中的 "old" 替换为 "new"，并使用 fs::rename 函数重命名文件。替换格式字符串 replacement_format 使用了反向引用 \1 和 \2，保留了 "old" 前后部分的文件名。
③ 文件内容搜索与替换：
除了文件名操作，Boost.Regex 还可以用于搜索和替换文件内容。结合 Boost.Filesystem 读取文件内容，我们可以实现强大的文件内容处理功能。
例如，假设我们需要在一个目录下的所有 .txt 文件中，查找并替换所有出现的 "apple" 单词为 "orange"。
1
#include <iostream>
2
#include <fstream>
3
#include <string>
4
#include <boost/filesystem.hpp>
5
#include <boost/regex.hpp>
6
7
namespace fs = boost::filesystem;
8
9
int main() {
10
fs::path directory_path = "./"; // 当前目录
11
boost::regex search_regex("apple"); // 查找 "apple" 单词
12
std::string replacement = "orange"; // 替换为 "orange"
13
boost::regex txt_file_regex(".*\\.txt$"); // 匹配 .txt 文件
14
15
if (fs::exists(directory_path) && fs::is_directory(directory_path)) {
16
fs::recursive_directory_iterator it(directory_path);
17
fs::recursive_directory_iterator end_it;
18
19
for (; it != end_it; ++it) {
20
if (fs::is_regular_file(*it) && boost::regex_match(it->path().filename().string(), txt_file_regex)) {
21
fs::path file_path = it->path();
22
std::ifstream input_file(file_path.string());
23
std::string file_content((std::istreambuf_iterator<char>(input_file)), std::istreambuf_iterator<char>()); // 读取文件全部内容
24
input_file.close();
25
26
std::string new_content = boost::regex_replace(file_content, search_regex, replacement);
27
28
if (new_content != file_content) { // 内容发生改变才写回
29
std::ofstream output_file(file_path.string());
30
output_file << new_content;
31
output_file.close();
32
std::cout << "Replaced 'apple' with 'orange' in file: " << file_path.string() << std::endl;
33
}
34
}
35
}
36
} else {
37
std::cerr << "Invalid directory path." << std::endl;
38
}
39
return 0;
40
}
在这个例子中，我们遍历指定目录下的所有 .txt 文件。对于每个文件，我们读取其全部内容，并使用 boost::regex_replace 函数将文件内容中所有出现的 "apple" 替换为 "orange"。如果文件内容发生改变，我们将新的内容写回文件。
通过以上示例，我们可以看到 Boost.Filesystem 与 Boost.Regex 结合使用，可以实现强大的文件查找、文件名批量重命名和文件内容处理等功能，极大地增强了文件系统操作的灵活性和效率。
9.3 Boost.Spirit 与 Boost.Regex：更复杂的文本解析（Boost.Spirit and Boost.Regex: More Complex Text Parsing）
Boost.Spirit 库是一个强大的 C++ 框架，用于构建基于语法的解析器。它允许开发者使用 EBNF (Extended Backus-Naur Form) 语法规则直接在 C++ 代码中定义解析器，从而实现复杂的文本解析任务。虽然 Boost.Spirit 本身已经提供了丰富的解析器组件，但在某些情况下，结合 Boost.Regex 可以简化语法规则的定义，或者处理词法分析中的一些细节。本节将探讨 Boost.Spirit 与 Boost.Regex 如何协同工作，以及在更复杂的文本解析场景中的应用。
① 词法分析中的 Token 匹配：
在编译原理中，词法分析（Lexical Analysis）是将输入的字符流分解成一个个 Token 的过程。Token 是具有特定意义的最小语法单元，例如关键字、标识符、运算符、字面量等。Boost.Regex 可以用于定义和匹配各种 Token 的模式，然后在 Boost.Spirit 的语法规则中使用这些 Token。
例如，假设我们需要解析一种简单的配置文件，其中包含键值对，键和值之间用等号 = 分隔，每行一个键值对。键可以是字母、数字和下划线组成的标识符，值可以是字符串或数字。我们可以使用 Boost.Regex 定义标识符、字符串和数字的 Token 模式，然后在 Boost.Spirit 中构建解析器。
1
#include <iostream>
2
#include <string>
3
#include <vector>
4
#include <boost/spirit/include/qi.hpp>
5
#include <boost/spirit/include/phoenix.hpp>
6
#include <boost/regex.hpp>
7
8
namespace qi = boost::spirit::qi;
9
namespace phoenix = boost::phoenix;
10
11
// 定义 Token 的正则表达式
12
boost::regex identifier_regex("[a-zA-Z_][a-zA-Z0-9_]*");
13
boost::regex string_regex("\"([^\\\"]|\\\\.)*\""); // 简单字符串，允许转义字符
14
boost::regex number_regex("[0-9]+");
15
16
// 定义 Spirit 语法规则
17
template <typename Iterator>
18
struct config_file_parser : qi::grammar<Iterator, std::vector<std::pair<std::string, std::string>>(), qi::space_type> {
19
config_file_parser() : config_file_parser::base_type(start) {
20
using qi::lexeme;
21
using qi::lit;
22
using qi::eps;
23
using qi::_1;
24
using qi::_2;
25
using phoenix::push_back;
26
using phoenix::make_pair;
27
28
identifier = lexeme[qi::char_('_' | qi::alpha) >> *qi::char_('_' | qi::alnum)]; // Spirit 方式定义标识符，更推荐的方式
29
string_literal = lexeme['"' >> *('\\' >> qi::char_ | (qi::char_ - '"')) >> '"']; // Spirit 方式定义字符串字面量，更推荐的方式
30
number_literal = lexeme[+qi::digit]; // Spirit 方式定义数字字面量，更推荐的方式
31
32
// 使用 regex token (不推荐，Spirit 本身已足够强大)
33
regex_identifier = lexeme[qi::as_string[qi::regex(identifier_regex)]];
34
regex_string_literal = lexeme[qi::as_string[qi::regex(string_regex)]];
35
regex_number_literal = lexeme[qi::as_string[qi::regex(number_regex)]];
36
37
38
key_value_pair =
39
(identifier >> lit("=") >> (string_literal | number_literal)) [push_back(_val, make_pair(_1, _2))]
40
;
41
42
line = key_value_pair >> qi::eol;
43
start = *line;
44
45
// 调试语法规则
46
qi::debug(identifier);
47
qi::debug(string_literal);
48
qi::debug(number_literal);
49
qi::debug(key_value_pair);
50
qi::debug(line);
51
qi::debug(start);
52
}
53
54
qi::rule<Iterator, std::string(), qi::space_type> identifier, string_literal, number_literal;
55
qi::rule<Iterator, std::string(), qi::space_type> regex_identifier, regex_string_literal, regex_number_literal; // 使用 regex token
56
qi::rule<Iterator, std::pair<std::string, std::string>(), qi::space_type> key_value_pair;
57
qi::rule<Iterator, std::vector<std::pair<std::string, std::string>>(), qi::space_type> line, start;
58
};
59
60
int main() {
61
std::string config_text = R"(
62
name = "My Application"
63
version = 123
64
author = "John Doe"
65
)";
66
67
using iterator_type = std::string::const_iterator;
68
iterator_type begin = config_text.begin();
69
iterator_type end = config_text.end();
70
config_file_parser<iterator_type> parser;
71
std::vector<std::pair<std::string, std::string>> config_data;
72
73
bool success = qi::phrase_parse(begin, end, parser, qi::space, config_data);
74
75
if (success && begin == end) {
76
std::cout << "Parse successful!" << std::endl;
77
for (const auto& pair : config_data) {
78
std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
79
}
80
} else {
81
std::cerr << "Parse failed!" << std::endl;
82
std::string rest(begin, end);
83
std::cerr << "Remaining input: \"" << rest << "\"" << std::endl;
84
}
85
86
return 0;
87
}
在这个例子中，我们首先定义了三个正则表达式 identifier_regex, string_regex, number_regex，分别用于匹配标识符、字符串字面量和数字字面量。然后在 config_file_parser 结构体中，我们定义了 Boost.Spirit 的语法规则。
虽然示例中展示了如何使用 qi::regex 结合 Boost.Regex，但实际上，Boost.Spirit 本身提供了更强大和灵活的方式来定义词法规则，例如 qi::char_, qi::alpha, qi::alnum, qi::digit 等解析器，以及 lexeme[] 指令用于将多个解析器组合成一个词法单元。 通常情况下，直接使用 Boost.Spirit 的内置解析器和指令来定义词法规则是更推荐的做法，因为这样可以更好地利用 Boost.Spirit 的优化和错误处理机制。 示例代码中 identifier, string_literal, number_literal 的定义展示了更推荐的 Spirit 原生方式。
② 复杂模式匹配与提取：
在某些复杂的文本解析场景中，可能需要使用正则表达式进行更精细的模式匹配和数据提取。Boost.Spirit 可以与 Boost.Regex 结合，在语法规则中嵌入正则表达式匹配逻辑。
例如，假设我们需要解析一种日志格式，其中日志消息部分包含复杂的结构化数据，需要使用正则表达式提取特定字段。虽然 Boost.Spirit 主要用于语法结构解析，但结合 Boost.Regex 可以处理日志消息内部的细粒度模式匹配。
需要注意的是，过度依赖正则表达式可能会使语法规则变得复杂和难以维护。Boost.Spirit 的优势在于其强大的语法组合能力和结构化解析，对于复杂的语法解析任务，应优先考虑使用 Boost.Spirit 的原生解析器和组合器来构建清晰、可维护的语法规则。 只有在确实需要正则表达式的强大模式匹配能力，且 Boost.Spirit 原生功能不足以胜任时，才考虑结合 Boost.Regex。
总而言之，Boost.Spirit 和 Boost.Regex 可以协同工作，在更复杂的文本解析任务中发挥各自的优势。Boost.Regex 可以辅助 Boost.Spirit 进行词法分析中的 Token 匹配，或者处理一些细粒度的模式匹配和数据提取任务。然而，在大多数情况下，Boost.Spirit 本身已经足够强大，能够胜任各种复杂的文本解析任务，过度依赖正则表达式可能会降低语法规则的可读性和可维护性。 应该根据具体的解析需求，权衡使用 Boost.Spirit 和 Boost.Regex 的方式，选择最合适的解决方案。
END_OF_CHAPTER
10. chapter 10： 未来展望与发展趋势（Future Trends and Development）
10.1 C++ 标准库正则表达式的比较与展望（Comparison with C++ Standard Library Regex and Future Prospects）
随着 C++ 标准的不断演进，正则表达式的支持也逐渐成为了标准库的一部分。C++11 标准正式引入了 <regex> 库，为开发者提供了标准化的正则表达式功能。然而，Boost.Regex 作为先驱者，在 C++ 标准库正则表达式出现之前，就已经在业界得到了广泛的应用。本节将对 Boost.Regex 与 C++ 标准库的正则表达式进行深入的比较，并展望未来正则表达式在 C++ 领域的发展趋势。
① 历史沿革与发展背景
Boost.Regex 库的开发历史悠久，其设计和实现对 C++ 标准库正则表达式的设计产生了深远的影响。Boost.Regex 在功能性、性能和平台兼容性方面都经历了长时间的考验和优化，积累了丰富的实践经验。
C++ 标准库的 <regex> 库，虽然起步较晚，但站在了 Boost.Regex 等库的肩膀上，吸取了许多成熟的设计理念和经验。标准库的优势在于其标准化（Standardization）和广泛支持（Broad Support），这意味着它能够更好地融入 C++ 的生态系统，并得到各个编译器的良好支持。
② 功能特性对比
在功能特性方面，Boost.Regex 和 C++ 标准库的 <regex> 库在核心功能上非常相似，都提供了正则表达式的匹配、搜索、替换和迭代等基本操作。它们都支持 Perl 兼容的正则表达式语法（Perl Compatible Regular Expressions, PCRE），以及其他一些常见的正则表达式语法选项。
然而，在一些细节和高级特性上，两者可能存在差异：
⚝ 语法选项（Syntax Options）：Boost.Regex 提供了更为丰富的语法选项，允许用户更精细地控制正则表达式的解析和匹配行为。例如，Boost.Regex 支持更多的非标准扩展和标志，以适应不同的应用场景。C++ 标准库的 <regex> 库在语法选项方面相对保守，更侧重于提供标准化的、跨平台一致的行为。
⚝ Unicode 支持（Unicode Support）：两者都提供了 Unicode 支持，但具体的实现细节和对不同 Unicode 特性的支持程度可能有所不同。Boost.Regex 在 Unicode 支持方面起步较早，可能在某些特定场景下提供更完善的处理能力。C++ 标准库的 Unicode 支持也在不断完善，并力求与最新的 Unicode 标准保持同步。
⚝ 性能表现（Performance）：性能是正则表达式库的关键指标之一。Boost.Regex 经过多年的优化，在性能方面表现出色。C++ 标准库的 <regex> 库的性能在不断提升，但具体的性能表现可能因编译器实现和使用场景而异。在对性能有较高要求的应用中，可能需要进行实际的性能测试和比较。
⚝ 错误处理（Error Handling）：两者都提供了完善的错误处理机制，通过异常（Exception）来报告正则表达式的编译错误和运行时错误。Boost.Regex 和 C++ 标准库都定义了 regex_error 异常类，用于表示正则表达式相关的错误。
③ API 设计与易用性
Boost.Regex 的 API 设计成熟且稳定，经过了广泛的应用和验证。其类和函数命名清晰，接口设计符合 C++ 的编程习惯。regex 类、smatch 类、regex_match、regex_search、regex_replace 等核心组件的设计都非常经典，为 C++ 标准库 <regex> 库的设计提供了重要的参考。
C++ 标准库的 <regex> 库在 API 设计上借鉴了 Boost.Regex 的成功经验，力求提供易用且符合标准规范的接口。标准库的优势在于其一致性（Consistency）和可预测性（Predictability），开发者可以期望在不同的平台上获得相似的行为和体验。
④ 标准库正则表达式的展望
C++ 标准库正则表达式的引入是 C++ 语言发展的重要里程碑，它为 C++ 开发者提供了标准化的、跨平台的正则表达式工具。随着 C++ 标准的持续演进，可以预见标准库正则表达式将会在以下几个方面继续发展和完善：
⚝ 性能优化： 随着编译器技术的进步和标准库实现的不断优化，C++ 标准库正则表达式的性能将会持续提升，逐渐缩小与一些高性能正则表达式库（如 Boost.Regex）之间的差距。
⚝ 功能增强： 未来 C++ 标准可能会考虑引入更多高级的正则表达式特性，例如对 Unicode 更深入的支持、新的语法选项、以及对正则表达式与其他 C++ 标准库组件（如并发、文件系统等）的更好集成。
⚝ 模块化与扩展性： C++ 标准库可能会朝着更加模块化和可扩展的方向发展，允许开发者根据自身需求选择性地引入正则表达式功能，并提供扩展机制以支持自定义的正则表达式引擎或语法。
⚝ 与其他标准库的协同： 未来，标准库正则表达式有望与 C++ 的其他标准库组件进行更紧密的协同工作，例如与 <filesystem> 库结合，实现对文件名的批量匹配和处理；与 <asio> 或 <networking> 库结合，实现网络数据包的深度解析和过滤；与 <ranges> 库结合，提供更灵活、更高效的正则表达式迭代和转换操作。
⑤ Boost.Regex 的定位与价值
即使 C++ 标准库已经提供了正则表达式功能，Boost.Regex 仍然具有其独特的定位和价值：
⚝ 成熟度和稳定性： Boost.Regex 经历了长时间的开发和实践检验，拥有极高的成熟度和稳定性。对于一些对可靠性要求极高的应用场景，Boost.Regex 仍然是值得信赖的选择。
⚝ 更丰富的功能和选项： Boost.Regex 提供了比 C++ 标准库 <regex> 库更丰富的功能和语法选项，能够满足一些特殊或高级的应用需求。对于需要精细控制正则表达式行为的开发者，Boost.Regex 提供了更大的灵活性。
⚝ 持续创新和实验平台： Boost 社区一直以来都是 C++ 技术创新的前沿阵地。Boost.Regex 可以作为正则表达式技术的实验平台，探索新的特性、优化方法和应用模式，为未来的 C++ 标准库正则表达式发展提供有益的参考和借鉴。
⚝ 向后兼容性： 对于一些遗留项目或需要在不同 C++ 标准版本之间保持兼容性的项目，Boost.Regex 可以提供更好的向后兼容性保障。
总而言之，C++ 标准库正则表达式的出现是 C++ 正则表达式发展的重要一步，它为开发者提供了标准化的解决方案，并将在未来持续发展和完善。而 Boost.Regex 作为先驱者和创新平台，仍然在 C++ 正则表达式领域扮演着重要的角色，与标准库正则表达式共同推动 C++ 语言在文本处理和模式匹配领域的应用和发展。
10.2 Boost.Regex 的未来发展方向（Future Development Directions of Boost.Regex）
Boost.Regex 作为一个成熟且强大的正则表达式库，在 C++ 社区中拥有广泛的用户群体和深远的影响力。尽管 C++ 标准库已经引入了 <regex> 库，Boost.Regex 仍然有其独特的价值和发展空间。展望未来，Boost.Regex 可以从以下几个方向继续发展，以保持其领先地位并满足不断变化的应用需求。
① 持续的性能优化
性能一直是正则表达式库的关键指标。Boost.Regex 可以继续在性能优化方面进行投入，探索新的算法和实现技术，以提升匹配速度和资源利用率。
⚝ 编译时优化（Compile-time Optimization）： 探索在编译时进行更多正则表达式优化的可能性，例如利用编译时计算和代码生成技术，生成更高效的匹配代码。这可以借助 C++ 的模板元编程（Template Metaprogramming）和编译时反射（Compile-time Reflection）等特性来实现。
⚝ 运行时优化（Runtime Optimization）： 继续优化运行时匹配算法，例如改进回溯算法、探索新的自动机模型、以及利用 SIMD 指令等硬件加速技术来提升匹配速度。
⚝ 内存优化（Memory Optimization）： 优化正则表达式引擎的内存使用，减少内存分配和拷贝开销，特别是在处理大规模文本数据时，内存优化至关重要。
② 增强 Unicode 支持
随着全球化的发展，Unicode 支持变得越来越重要。Boost.Regex 可以继续增强其 Unicode 支持，以更好地处理各种语言和字符集。
⚝ 支持最新的 Unicode 标准： 及时跟进最新的 Unicode 标准，支持新的 Unicode 字符属性、字符类和转换规则。
⚝ 改进对复杂文本布局的支持： 探索对复杂文本布局（Complex Text Layout, CTL）的支持，例如阿拉伯语、希伯来语等从右向左书写的文字，以及需要进行字符组合和变形的文字。
⚝ 提供更灵活的 Unicode 处理选项： 允许用户更精细地控制 Unicode 字符的匹配和处理方式，例如区分不同的 Unicode 规范化形式（Normalization Forms）、支持不同的 Unicode 排序规则（Collation Rules）等.
③ 扩展正则表达式语法
正则表达式语法也在不断演进，新的语法特性不断涌现，以满足更复杂的模式匹配需求。Boost.Regex 可以考虑引入一些有用的新语法特性，并保持与业界标准的同步。
⚝ 支持新的正则表达式运算符和修饰符： 例如，可以考虑引入占有量词（Possessive Quantifiers）、条件表达式（Conditional Expressions）、递归正则表达式（Recursive Regular Expressions）等高级语法特性。
⚝ 提供可扩展的语法框架： 设计一个可扩展的语法框架，允许用户自定义正则表达式语法，以满足特定领域或应用的需求。
⚝ 与其他模式匹配技术的融合： 探索将正则表达式与其他模式匹配技术（例如，通配符匹配、模糊匹配、语法分析等）进行融合的可能性，提供更强大的文本处理能力。
④ 与其他 Boost 库的深度集成
Boost 库是一个庞大的 C++ 库集合，各个库之间具有良好的协同性和互操作性。Boost.Regex 可以进一步加强与其他 Boost 库的集成，发挥更大的综合效能。
⚝ 与 Boost.Asio 的集成： 在网络编程领域，正则表达式可以用于协议解析、数据包过滤、安全审计等方面。Boost.Regex 可以与 Boost.Asio 深度集成，提供更便捷的网络数据处理接口。
⚝ 与 Boost.Filesystem 的集成： 在文件系统操作中，正则表达式可以用于文件名匹配、文件内容搜索、日志分析等方面。Boost.Regex 可以与 Boost.Filesystem 深度集成，提供更高效的文件处理工具。
⚝ 与 Boost.Spirit 的集成： 对于需要进行复杂文本解析的应用，正则表达式通常只是第一步。Boost.Regex 可以与 Boost.Spirit 结合使用，构建更强大的语法分析器和领域特定语言（Domain-Specific Language, DSL）解析器。
⚝ 与 Boost.Coroutine 或 Boost.Fiber 的集成： 在处理大规模文本数据或进行复杂正则表达式匹配时，可以利用协程（Coroutine）或纤程（Fiber）技术来提高并发性和响应性。Boost.Regex 可以与 Boost.Coroutine 或 Boost.Fiber 集成，提供更高效的并发正则表达式处理能力。
⑤ 提升易用性和文档质量
易用性和文档质量是库的重要组成部分。Boost.Regex 可以继续努力提升易用性，并完善文档，降低学习和使用门槛。
⚝ 提供更友好的 API 接口： 在保持功能强大的前提下，可以考虑提供更简洁、更易于理解的 API 接口，例如提供更高级别的封装函数、更符合直觉的命名约定等。
⚝ 改进错误提示信息： 提供更详细、更友好的正则表达式编译和运行时错误提示信息，帮助用户快速定位和解决问题。
⚝ 完善文档和示例代码： 编写更全面、更清晰的文档，包括 API 参考、使用指南、最佳实践、常见问题解答等。提供更丰富的示例代码，演示 Boost.Regex 在各种应用场景下的使用方法。
⚝ 开发可视化工具： 可以考虑开发一些可视化工具，例如正则表达式测试器、调试器、性能分析器等，以辅助用户更好地理解、测试和优化正则表达式。
⑥ 拥抱新的 C++ 标准特性
C++ 标准在不断发展，新的语言特性不断涌现。Boost.Regex 可以积极拥抱新的 C++ 标准特性，例如 C++11/14/17/20 引入的 Lambda 表达式、右值引用、移动语义、概念（Concepts）、协程（Coroutines）等，以提升代码质量、性能和可维护性。
⚝ 利用 Lambda 表达式简化回调函数： 在正则表达式替换等操作中，可以利用 Lambda 表达式简化回调函数的编写，提高代码的可读性和简洁性。
⚝ 利用右值引用和移动语义优化资源管理： 在正则表达式对象的创建、拷贝和赋值等操作中，可以利用右值引用和移动语义减少不必要的资源拷贝，提升性能。
⚝ 利用概念（Concepts）改进接口设计： 在未来的 C++ 标准中，概念（Concepts）将成为重要的语言特性。Boost.Regex 可以利用概念来改进 API 接口设计，提供更强的类型安全性和编译时检查。
⚝ 探索协程（Coroutines）在正则表达式引擎中的应用： 协程（Coroutines）为异步编程和并发处理提供了新的解决方案。Boost.Regex 可以探索将协程应用于正则表达式引擎的实现，以提升并发性能和响应性。
总而言之，Boost.Regex 的未来发展方向是多方面的，既包括对现有功能的持续优化和完善，也包括对新技术的探索和应用。通过不断地创新和改进，Boost.Regex 将继续保持其在 C++ 正则表达式领域的领先地位，为 C++ 开发者提供更强大、更易用、更高效的正则表达式工具，应对未来不断涌现的文本处理挑战。
END_OF_CHAPTER