C++ 正则表达式简介

1. 正则表达式简介

正则表达式（Regular Expression，简称Regex）是一种用于匹配和处理文本的强大工具。它通过特定的符号组合形成匹配规则，常用于表单验证、文本搜索与替换、数据清洗等场景。

C++11标准引入了 <regex> 头文件，提供了对正则表达式的支持。这使得C++程序员能够更加方便地处理字符串。

1.1. 基本组件

• std::regex：表示一个正则表达式对象。
• std::smatch：用于存储匹配结果（字符串的子串）。
• std::regex_match：用于检查一个字符串是否完全匹配一个正则表达式。
• std::regex_search：用于在字符串中搜索与正则表达式部分匹配的子串。
• std::regex_replace：用于替换与正则表达式匹配的部分。

1.2. 常用元字符

元字符	描述	示例
.	匹配除换行符外的任意单个字符。	a.b 匹配 “acb”、“a1b” 等。
^	匹配字符串的开头。	^abc 匹配 “abc”。
$	匹配字符串的结尾。	abc$ 匹配 “abc”。
*	匹配前面的元素零次或多次。	a* 匹配 “a”、“aa”、“aaa” 等。
+	匹配前面的元素一次或多次。	a+ 匹配 “a”、“aa”、“aaa” 等。
?	匹配前面的元素零次或一次。	a? 匹配 “a” 或空字符串。
\d	匹配一个数字 (等价于 [0-9] )。	\d{2} 匹配两位数字。
\D	匹配一个非数字字符。	\D{2} 匹配两个非数字字符。
\w	匹配一个单词字符 (字母、数字、下划线)。	\w{2} 匹配两个单词字符。
\W	匹配一个非单词字符。	\W{2} 匹配两个非单词字符。
\s	匹配一个空白字符 (空格、制表符、换行符等)。	\s{2} 匹配两个空白字符。
\S	匹配一个非空白字符。	\S{2} 匹配两个非空白字符。
[abc]	匹配方括号中的任意一个字符。	[abc] 匹配 ‘a’、‘b’ 或 ‘c’。
[^abc]	匹配不在方括号中的任意一个字符。	[^abc] 匹配任何不是 ‘a’、‘b’ 或 ‘c’ 的字符。
(...)	分组，用于捕获子串或应用量词到整个组。	(abc)* 匹配零个或多个 “abc” 的序列。
{n}	匹配前面的元素恰好 n 次。	{3} 匹配恰好三个字符。
{n,}	匹配前面的元素至少 n 次。	{3,} 匹配至少三个字符。
{n,m}	匹配前面的元素至少 n 次，但不超过 m 次。	{3,5} 匹配至少三个且不超过五个字符。
`	`	或操作。
\	转义特殊字符。	\. 匹配实际的点字符。

1.3. 注意事项

1. 语法错误：正则表达式的语法本身可能导致运行时错误（std::regex_error），即使C++代码编译通过。
2. 预编译正则表达式：对于复杂的正则表达式或性能敏感的应用，考虑预编译正则表达式对象（std::regex）而不是在循环中重复创建它。

1.4. 原始字符串字面量

原始字符串字面量（Raw String Literals）是C++11引入的一种字符串表示方式，它允许你定义包含特殊字符如反斜杠、换行符等的字符串，而不需要对这些字符进行转义。这使得处理正则表达式、文件路径或其他含有大量转义字符的字符串变得更为方便。

1.4.1. 语法格式

原始字符串字面量的基本语法如下：

R"delimiter(字符串内容)delimiter"

• R：表示这是一个原始字符串字面量。
• delimiter：是一个可选的分隔符，可以由最多16个字符组成。如果使用了分隔符，则在开头的 ( 之前和结尾的 ) 之后都需要加上这个分隔符。分隔符不能包含空格，并且必须与结束标记相匹配。
• (字符串内容)：这是实际的字符串内容，可以跨越多行，不需要对双引号或反斜杠进行转义。

如果没有指定分隔符，则默认情况下没有分隔符，即直接使用 R"(字符串内容)" 的形式。

1.4.2. 基本示例

std::string basic = R"(Hello\nWorld)";
// 结果: Hello\nWorld (而不是换行)

std::regex pattern(R"(\d{4})"); // 正则表达式模式，匹配4个数字

//与以下写法等价
std::regex pattern2("\\d{4}");

1.4.3. 使用自定义分隔符

当你需要在字符串中包含 )" 这样的序列时，你可以使用自定义分隔符来避免冲突：

std::string with_delimiter = R"hello(World "with" ) special chars\)hello";
// 结果: World "with" ) special chars\

std::regex pattern ( R"xx(20(\d{2}))xx");

在这个例子中，hello 是我们选择的分隔符，确保它可以正确地包围我们的字符串内容而不引起解析错误。

1.4.4. 多行文本

原始字符串字面量非常适合用于编写跨多行的字符串：

std::string multi_line = R"(
这是一个
多行的
字符串
)";

这样就可以轻松创建包含换行符的字符串，而无需手动添加 \n。

1.5. std::regex_match

正则表达式匹配整个字符串，如果字符串与正则表达式完全匹配，则返回 true，否则返回 false。

    std::string str ="Hello 2025,Bye 2024"; // 待测试的字符串
    std::regex pattern(R"(\d{4})"); // 正则表达式模式，匹配4个数字
    // 尝试匹配整个字符串是否符合模式
    if(std::regex_match(str,pattern))
    {
        // 如果匹配成功，记录日志
        spdlog::info("regex_match(str,pattern) 查找到后的输出:{}",str);
    }

当然，也可以在调用中传入std::smatch

    str="2025";
    std::smatch match; // 用于存储匹配结果的对象
    pattern="20(\\d{2})"; // 新的正则表达式模式，匹配以 "20" 开头，后跟两位数字，并捕获这两位数字
    // 尝试匹配整个字符串是否符合新模式，并将匹配结果存入 match 对象
    if(std::regex_match(str,match,pattern))
    {
        // 如果匹配成功，记录整个匹配的字符串和第一个捕获组的内容
        spdlog::info("regex_match(str,match,pattern) 整个匹配的字符串:{}",match.str(0));
        spdlog::info("regex_match(str,match,pattern) 第一个捕获组:{}",match.str(1));
        
    }

1.6. std::regex_search

正则表达式搜索整个字符串，如果字符串中存在与正则表达式匹配的子串，则返回 true，否则返回 false。
注意其只返回找到的第一个字串，如果需要搜索所有匹配的子串，需要循环调用。

    str="Hello 2025,Bye 2024"; 
    pattern="\\d{4}"; // 正则表达式模式，匹配4个数字
    
    // 循环搜索字符串中所有符合模式的子串
    while(std::regex_search(str,match,pattern))
    {
        // 如果找到匹配项，记录匹配到的子串
        spdlog::info("regex_search(str,match,pattern) 查找后的输出 match.str():{}",match.str());
        // 更新待搜索的字符串为上一次匹配结果之后的部分
        str=match.suffix().str();
    }

1.7. std::regex_replace

进行正则表达式替换，会将所有找到的子串全都进行替换

    str="Hello 2025,Hello 2024"; 
    pattern="Hello"; // 新的正则表达式模式，匹配 "Hello"
    // 将字符串中所有匹配 "Hello" 的子串替换为 "Hi"
    string replaced_str=std::regex_replace(str,pattern,"Hi");
    // 记录替换后的字符串
    spdlog::info("replaced:{}",replaced_str);

如果只要替换某一个子串，可以使用std::regex_replace的第三个参数，指定要替换的子串的索引

  std::string str = "Hello 2025,Bye 2024"; // 待测试的字符串
    std::regex pattern("(\\d{4})"); // 正则表达式模式，匹配4个数字
    std::string replacement = "****"; // 替换字符串

    // 只替换第一个匹配的子串
    std::string result = std::regex_replace(str, pattern, replacement, std::regex_constants::format_first_only);
    std::cout << "替换第一个匹配项: " << result << std::endl; // 输出: "Hello ****,Bye 2024"

   

当然，也可以采用另一种做法,这种做法没有上一种简洁，但可以了解match.prefix()和match.suffix()的使用

str="Hello 2025,Hello 2024"; // 恢复待测试字符串
    pattern="Hello"; // 恢复之前的正则表达式模式，匹配 "Hello"
    
    // 搜索字符串中第一个符合模式的子串
    if(std::regex_search(str,match,pattern))
    {
        string replacement="Hi"; // 替换字符串
        // 手动构建只替换第一个匹配项后的字符串：匹配项前缀 + 替换字符串 + 匹配项后缀
        string s2=match.prefix().str()+replacement+match.suffix().str();
        // 记录只替换第一个匹配项后的输出
        spdlog::info("只替换第一个后的输出 :{}",s2);
    }