24 C++ 正则表达式

C++正则表达式

文章目录

• C++正则表达式
• • 一、核心组件
  • 二 匹配操作函数
  • 三 基础字符匹配 🌟
  • • 1 精确匹配
    • 2 字符集合
    • 3 重复匹配（量词规则）
    • 4 位置锚定规则 🧩
    • • 1. 单词边界
      • 2. 边界控制
    • 5 捕获与数据分组 🧭
  • 四 匹配函数 🔍
  • 1 子串搜索匹配函数：`std::regex_search`
  • 2 替换匹配内容：`std::regex_replace`
  • 3 迭代匹配结果
  • 五 高级匹配规则🎯
  • 六 匹配控制标志⚙️
  • • 1. 常用标志
    • 2. `regex_constants` 命名空间
  • 七 注意事项 ⏰
  • [附录]
  • • 📊 迭代器处理函数

一、核心组件

二 匹配操作函数

三 基础字符匹配 🌟

1 精确匹配

• 示例：

  #include <iostream>
  #include <regex>

  using namespace std;

  int main()
  {
  string str1 ="Abc B";
  string str2 ="Abc B";//

  std::regex re( str2 );
  std::smatch match;

  if(regex_match(str1, match, re) )
  {
  cout<<str1<<" 和 "<<str2<<" 匹配"<<endl;
  }

  return 0;
  }

Abc B 和 Abc B 匹配

• 示例：

  include <iostream>
  #include <regex>

  using namespace std;

  int main()
  {
  string str1 ="Abc B";
  string str2 ="Abc.B";//

  std::regex re( str2 );
  std::smatch match;

  if(regex_match(str1, match, re) )
  {
  cout<<str1<<" 和 "<<match[0]<<" 匹配"<<endl;
  }

  str1 ="AbcxB";
  if(regex_match(str1, match, re) )
  {
  cout<<str1<<" 和 "<<str2<<" 匹配"<<endl;
  }

  str1 ="Abc B";
  if(regex_match(str1, match, re) )
  {
  cout<<str1<<" 和 "<<str2<<" 匹配"<<endl;
  }

  str1 =".?*+^$()";
  str2 =R"(\\.\\?\\*\\+\\^\\$\\(\\))"; //匹配 .?*+^$()
  // re( str2 ); 必须使用 assign() 方法：
  re.assign(str2); // ✅ 正确：修改现有的 std::regex 对象

  if(regex_match(str1, match, re) )
  {
  cout<<str1<<" 和 "<<str2<<" 匹配"<<endl;
  }

  return 0;
  }

  输出：

  Abc B 和 Abc B 匹配
  AbcxB 和 Abc.B 匹配
  Abc B 和 Abc.B 匹配
  .?*+^$() 和 \\.\\?\\*\\+\\^\\$\\(\\) 匹配

• 正则表达式：R"(\\.\\?\\*\\+\\^\\$\\(\\))" \\. 匹配 . \\? 匹配 ? \\* 匹配 * \\+ 匹配 + \\^ 匹配 ^ \\$ 匹配 $ \\( 匹配 ( \\) 匹配 )

• 原始字符串字面量（Raw String Literal）：

  • R"(…)"是 C++11 引入的原始字符串语法，避免了对反斜杠 \\ 的额外转义。
  • 如果不使用原始字符串，正则表达式需要写成 "\\\\.\\\\?\\\\*\\\\+\\\\^\\\\$\\\\(\\\\)"（需要双重转义）。

• re( str2 ); std::regex 没有 operator()，所以不能像函数一样调用。 想修改它的正则表达式模式，必须使用 assign() 方法。

2 字符集合

• 示例：

  #include <iostream>
  #include <regex>

  using namespace std;

  int main()
  {
  string id ="2";
  // string str2 =R"(\\d)"; // 匹配任一个数字
  string str2 =R"([0-9])"; // 匹配任一个数字

  std::regex re( str2 );
  std::smatch match;

  if(std::regex_match(id, match, re) )
  {
  std::cout<<id<<" 和 "<<str2<<" 匹配"<<std::endl;
  }

  id ="202";
  if(true != std::regex_match(id, match, re) )
  {
  std::cout<<id<<" 和 "<<str2<<" 不匹配"<<std::endl;
  }

  id ="C";
  if(true != std::regex_match(id, match, re) )
  {
  std::cout<<id<<" 和 "<<str2<<" 不匹配"<<std::endl;
  }

  return 0;
  }

  输出结果:

  2 和 [0–9] 匹配
  202 和 [0–9] 不匹配
  C 和 [0–9] 不匹配

3 重复匹配（量词规则）

4 位置锚定规则 🧩

1. 单词边界

✅ \\b 的核心逻辑：通过 \\w 和 \\W 的差异定位单词边界，适合精确匹配独立单词

std::regex re(R"(\\bword\\b)"); // 匹配独立单词

• \\bword\\b 确保 "word" 前后是单词边界（如空格、标点或字符串开头/结尾）。

• 不会匹配 "keyword" 或 "sword" 中的 "word"。

  #include <iostream>
  #include <regex>
  #include <string>

  int main() {
  std::string text = "word"; // 独立单词
  std::regex re(R"(\\bword\\b)"); // 必须完全匹配 "word"

  if (std::regex_match(text, re)) {
  std::cout << "匹配成功: \\"" << text << "\\" 是一个独立单词。" << std::endl;
  }
  //匹配成功: "word" 是一个独立单词。

  std::smatch match;
  text = "This is a sword and word example."; // "word" 是子串

  if (std::regex_search(text, match, re)) {
  std::cout << "找到独立单词: \\"" << match[0]
  << "\\" 在位置 " << match.position() << std::endl;
  }
  //找到独立单词: "word" 在位置 20

  return 0;
  }

• regex_match vs regex_search – regex_match：整个字符串必须完全匹配正则表达式（适合验证独立单词）。 – regex_search：字符串中只要包含匹配即可（适合在句子中查找单词）。

• \\b 是匹配单词边界：\\w 和 \\W 之间的位置，是 位置（零宽度断言），而不是具体的字符。 例如，\\b 匹配以下两种位置： 1. \\w 和 \\W 之间（单词字符后接非单词字符，如 "word!" 中的 d 和 !）。 2. \\W 和 \\w 之间（非单词字符后接单词字符，如 "!word" 中的 ! 和 w）。

• 自定义单词边界

  • \\b 不匹配下划线 _，因为 _ 属于 \\w。

    std::string text = "word_word";
    std::regex re(R"(\\bword\\b)");
    // 不匹配，因为 `_` 是 `\\w`集合，`word` 前后没有单词边界

  • \\b 会匹配带连字符-的单词，- 不是 \\w，会触发单词边界 例如 "well-known" 如果默认的 \\w 不符合需求（例如不想将 _ 视为单词字符），可以显式定义边界：

    std::string text = "word_word";
    // 只允许字母和数字作为单词字符（排除 `_`）
    std::regex re(R"((?<![a-zA-Z0-9])word(?![a-zA-Z0-9]))");

    • (?<![a-zA-Z0-9])：前面不能是字母或数字（负向后顾）。
    • (?![a-zA-Z0-9])：后面不能是字母或数字（负向先行）。

2. 边界控制

✅ ^ 和 $ 是锚点（anchors），用于精准定位匹配位置。

• 示例：

  std::regex re1("^Start"); // 字符串 Start 起始
  std::regex re2("End$"); // 字符串 End 结束

• 忽略大小写的边界控制 通过 std::regex::icase 标志实现：

  std::regex re1("^start", std::regex::icase); // 匹配 "Start"、"START" 等
  std::regex re2("end$", std::regex::icase); // 匹配 "End"、"END" 等

• 完整示例：

  #include <iostream>
  #include <regex>
  #include <string>

  int main() {
  // 测试字符串
  std::string str1 = "Start of the day";
  std::string str2 = "The End";
  std::string str3 = "Start and End";
  std::string str4 = "Middle of the road";

  // 定义正则表达式
  std::regex re1("^Start"); // 匹配以 "Start" 开头的字符串
  std::regex re2("End$"); // 匹配以 "End" 结尾的字符串

  // 测试 re1: 匹配开头
  if (std::regex_search(str1, re1)) {
  std::cout << "\\"" << str1 << "\\" 以 'Start' 开头" << std::endl;
  } else {
  std::cout << "\\"" << str1 << "\\" 不以 'Start' 开头" << std::endl;
  }

  // 测试 re2: 匹配结尾
  if (std::regex_search(str2, re2)) {
  std::cout << "\\"" << str2 << "\\" 以 'End' 结尾" << std::endl;
  } else {
  std::cout << "\\"" << str2 << "\\" 不以 'End' 结尾" << std::endl;
  }

  // 测试同时匹配开头和结尾
  if (std::regex_search(str3, re1) && std::regex_search(str3, re2)) {
  std::cout << "\\"" << str3 << "\\" 以 'Start' 开头且以 'End' 结尾" << std::endl;
  } else {
  std::cout << "\\"" << str3 << "\\" 不满足条件" << std::endl;
  }

  // 测试不匹配的情况
  if (!std::regex_search(str4, re1) && !std::regex_search(str4, re2)) {
  std::cout << "\\"" << str4 << "\\" 既不以 'Start' 开头，也不以 'End' 结尾" << std::endl;
  }

  return 0;
  }

  输出结果:

  "Start of the day" 以 'Start' 开头
  "The End" 以 'End' 结尾
  "Start and End" 以 'Start' 开头且以 'End' 结尾
  "Middle of the road" 既不以 'Start' 开头，也不以 'End' 结尾

[关键点解析]

• ^ 表示匹配字符串的开头。

• $ 表示匹配字符串的结尾。

• 完整示例：

  #include <iostream>
  #include <regex>
  #include <string>

  int main() {
  // 测试字符串
  std::string str1 = "两个黄鹂鸣翠柳";
  std::string str2 = "一行白鹭上青天";
  std::string str3 = "两个黄鹂鸣翠柳，一行白鹭上青天";
  std::string str4 = "两个黄鹂鸣翠柳，夜话白鹭四条腿";

  // 定义正则表达式
  std::regex re1("^两个"); // 匹配以 "两个" 开头的字符串
  std::regex re2("天$"); // 匹配以 "天" 结尾的字符串

  // 测试 re1: 匹配开头
  if (std::regex_search(str1, re1)) {
  std::cout << "\\"" << str1 << "\\"" <<"以 \\"两个\\" 开头" << std::endl;
  }

  // 测试 re2: 匹配结尾
  if (std::regex_search(str2, re2)) {
  std::cout << "\\"" << str2 << "\\" 以 \\"天\\" 结尾" << std::endl;
  }

  // 测试同时匹配开头和结尾
  if (std::regex_search(str3, re1) && std::regex_search(str3, re2)) {
  std::cout << "\\"" << str3 << "\\" 以 \\"两个\\" 开头且以 \\"天\\" 结尾" << std::endl;
  } else {
  std::cout << "\\"" << str3 << "\\" 不满足条件" << std::endl;
  }

  // 测试匹配和不匹配的情况
  if (std::regex_search(str4, re1) && !std::regex_search(str4, re2)) {
  std::cout << "\\"" << str4 << "\\" 以 \\"两个\\" 开头，不以 \\"天\\" 结尾" << std::endl;
  }

  return 0;
  }

  输出结果：

  "两个黄鹂鸣翠柳"以 "两个" 开头
  "一行白鹭上青天" 以 "天" 结尾
  "两个黄鹂鸣翠柳，一行白鹭上青天" 以 "两个" 开头且以 "天" 结尾
  "两个黄鹂鸣翠柳，夜话白鹭四条腿" 以 "两个" 开头，不以 "天" 结尾

• 多行匹配方法

  #include <iostream> // 输入输出
  #include <sstream> // 字符串流
  #include <regex> // 正则表达式
  #include <string> // 字符串处理

  int main() {
  std::string text =
  "行 1：风急天高猿啸哀，渚清沙白鸟飞回。\\n"
  "行 2：无边落木萧萧下，不尽长江滚滚来。\\n"
  "无效行…… ……\\n"
  "行 3：万里悲秋常作客，百年多病独登台。\\n"
  " 行4：艰难苦恨繁霜鬓，潦倒新停浊酒杯。\\n"
  "Line 1: This starts with Line\\n"
  "Not a match\\n"
  "Line 2: Another Line\\n"
  " Line 3: Indented (no match)\\n"
  "End of text";

  std::istringstream stream(text);
  std::string line;
  int line_count = 0;
  int match_count = 0;

  // 定义正则表达式模式
  std::regex chinese_pattern(R"(^\\s*行\\s*\\d*[：:])"); // 匹配：任意空格 + 行 + 可选数字 + 冒号
  std::regex english_pattern(R"(^Line\\s+\\d+[:])"); // 匹配：Line + 空格 + 数字 + 冒号

  std::cout << "===== 正则匹配结果 =====\\n";
  while (std::getline(stream, line)) {
  ++line_count;

  // 使用正则表达式匹配
  if (std::regex_search(line, chinese_pattern)) {
  std::cout << "[中文] " << line << "\\n";
  ++match_count;
  }
  else if (std::regex_search(line, english_pattern)) {
  std::cout << "[英文] " << line << "\\n";
  ++match_count;
  }
  }

  std::cout << "===== 统计信息 =====\\n";
  std::cout << "文本总行数: " << line_count << "\\n";
  std::cout << "匹配行数量: " << match_count << "\\n";
  return 0;
  }

  输出结果：

  ===== 正则匹配结果 =====
  [中文] 行 1：风急天高猿啸哀，渚清沙白鸟飞回。
  [中文] 行 2：无边落木萧萧下，不尽长江滚滚来。
  [中文] 行 3：万里悲秋常作客，百年多病独登台。
  [中文] 行4：艰难苦恨繁霜鬓，潦倒新停浊酒杯。
  [英文] Line 1: This starts with Line
  [英文] Line 2: Another Line
  ===== 统计信息 =====
  文本总行数: 10
  匹配行数量: 6

5 捕获与数据分组 🧭

• 语法示例： std::regex palindrome(R"((\\w)\\1)"); // 匹配AA/BB类重复 (\\w)匹配任意单词字符（字母/数字/下划线） \\1 反向引用第一个捕获组内容

• 完整示例：

  #include <iostream>
  #include <regex>
  #include <string>

  int main() {
  // 创建重复字符检测器
  std::regex palindrome(R"((\\w)\\1)"); // ✅ 核心表达式

  // 测试字符串
  std::string test_str = "Bookkeeper";

  // 执行单次匹配
  std::smatch match;
  if (std::regex_search(test_str, match, palindrome)) {

  // 提取匹配结果
  std::cout << "原始文本: \\"" << test_str << "\\"\\n";
  std::cout << "发现重复: \\"" << match[0].str() << "\\"" << std::endl;
  std::cout << "起始位置: " << match.position() << std::endl;

  }

  return 0;
  }

  输出结果:

  原始文本: "Bookkeeper"
  发现重复: "oo"
  起始位置: 1

四 匹配函数 🔍

1 子串搜索匹配函数：std::regex_search

• R"(<.*>)"会匹配 从第一个 < 到最后一个 >，可能错误匹配多个标签。
• R"(<.*?>)"只匹配 最短的标签。

std::regex greedy("<.*>"); // 匹配整个标签内容
std::regex lazy("<.*?>"); // 匹配最短标签

#include <iostream>
#include <regex>

using namespace std;

int main()
{
string str1 ="ac<bdef>abc<b>def</b>";
string str2 =R"(<.*>)"; // 匹配标签

std::regex re( str2 );
std::smatch match;

if(std::regex_search(str1, match, re) )
{
cout << "找到匹配: " << match[0] <<' '<<match[1]<< ' '<<match[2]<<endl;
}
else {
cout << "未找到匹配" << endl;
}

str1 ="ac<b>def</b>xyz";
str2 =R"(<.*?>)"; // 非贪婪匹配标签
re.assign(str2);
if(std::regex_search(str1, match, re) )
{
cout << "找到匹配: " << match[0] <<' '<<match[1]<< endl;
}
else {
cout << "未找到匹配" << endl;
}

return 0;
}

输出结果:

找到匹配: <bdef>abc<b>def</b>
找到匹配: <b>

2 替换匹配内容：std::regex_replace

功能：替换所有匹配的子串 返回值：string 新字符串（原始字符串不变）

• 示例：以@为分隔符查找邮箱

  std::string text = "Contact: user@example.com or support@domain.com";
  std::string str1 = R"([\\w.]+@[\\w.]+)";

• [\\w.]+（主体部分） – \\w：匹配任意单词字符（等价于 [a-zA-Z0-9_]） – .：匹配字面点字符（需转义但此处在[]内不转义） – +：匹配前项1次或多次（至少1个字符） – 合起来就是匹配-字符或者字符和点，例如：john.doe，service2025。

• @（固定分隔符） – 必须存在分隔符号

• [\\w.]+ （域名部分） – 规则同主体部分，匹配-字符或者字符和点，例如：john.doe，service2025。

• 完整示例

  #include <iostream>
  #include <regex>
  #include <string>

  int main() {
  // 创建重复字符检测器
  std::string text = "Contact: user.r@example.com or support@domain.com -john.doe@service2025";
  std::string str1 = R"([\\w.]+@[\\w.]+)";
  std::regex re(str1);

  std::string result = std::regex_replace(text, re, "@");
  std::cout << result<<"\\n";

  text = "Contact: 138-1234-5678, 139-8765-4321";
  str1 = (R"(\\b(\\d{3})-(\\d{4})-\\d{4}\\b)");
  re.assign(str1);

  // 隐藏手机号中间四位
  result = std::regex_replace(text, re, "$1—$2");
  std::cout << result;

  return 0;
  }

  输出结果:

  Contact: @ or @ –@
  Contact: 138—–1234, 139—–8765

3 迭代匹配结果

• ⚠️ 空匹配处理

  if (it == std::sregex_iterator()) {
  std::cerr << "未找到任何匹配";
  }

• ⚠️ 避免悬空引用

  // 错误：text生命周期结束后使用迭代器
  auto create_iter() {
  std::string local = "test";
  return std::sregex_iterator(local.begin(), local.end(), pattern);
  }

• ⚠️ 性能优化

  // 预编译正则表达式（避免重复构造）
  static const std::regex cache_pattern(R"(\\d+)");

五 高级匹配规则🎯

六 匹配控制标志⚙️

1. 常用标志

这些常用标志都包含在regex_constants 命名空间里

2. regex_constants 命名空间

用于定义与正则表达式操作相关的各种常量和标志。这些常量主要用于控制正则表达式的匹配行为、语法选项和错误处理方式。 以下是其核心内容的详细说明：

[综述]

• regex_constants 是正则操作的“控制开关”，通过标志位精细控制匹配逻辑。
• 语法选项（如 icase）影响正则的编译规则。
• 匹配选项（如 match_not_bol）影响运行时行为。

七 注意事项 ⏰

• 性能：复杂正则可能导致回溯爆炸，尽量优化表达式（如避免嵌套量词）。

• 匹配规则的字符串字面量：使用 R"()" 避免转义字符混乱（如 R"(\\d+)" 代替 “\\d+”）。

  std::regex path(R"(C:\\\\Users\\\\.+\\.txt)"); // 避免双反斜杠

• 在关键路径中使用 std::regex_constants::optimize 可提显著升匹配速度(30%)，对长文本效果显著。建议搭配静态正则对象使用：

  static const std::regex email_regex(R"(\\w+@\\w+\\.\\w+)",
  std::regex::optimize | std::regex::icase);

• 灾难性回溯防御

  – 危险模式: ".*@.*\\.com"
  + 安全模式: "[^@]+@[^.]+\\.com"

• 现代C++特性

  // 使用string_view避免拷贝
  bool match_email(std::string_view email) {
  return std::regex_match(email.data(), kEmail);
  }

[实践建议]

💎 终极建议：对于性能关键场景（如日志处理系统），建议使用Google的RE2库（），其性能比std::regex高出3-5倍，且无回溯爆炸风险。 建议关键系统使用Valgrind正则分析器检测性能瓶颈。

⚡ C++正则匹配方法性能深度对比（基于2025年实测数据） 测试环境：Clang 18.0 / C++20 / Intel i9-13900K / 高频业务场景数据集（10GB日志）

🔧 核心性能指标对比表

⚠️ 注：n=字符串长度，m=匹配次数，k=捕获组数量

[附录]

📊 迭代器处理函数

• 作用：用于遍历匹配的子组或未匹配的间隔（类似拆分字符串）。

• 构造函数：

  sregex_token_iterator(); // 默认构造（结束迭代器）
  sregex_token_iterator(string::const_iterator first,
  string::const_iterator last,
  const regex& re,
  int submatch = 0, // 指定子组索引
  regex_constants::match_flag_type flags = regex_constants::match_default);

  // 支持多个子组的版本（通过 initializer_list 或向量指定）
  sregex_token_iterator(string::const_iterator first,
  string::const_iterator last,
  const regex& re,
  const std::vector<int>& submatches,
  regex_constants::match_flag_type flags = regex_constants::match_default);

• 关键行为：

  • 若 submatch 为 0，返回整个匹配。
  • 若 submatch 为 -1，返回未匹配的间隔（相当于拆分字符串）。
  • 支持通过列表指定多个子组（如 {1,2}）。

• 示例代码

  #include <regex>
  #include <string>
  #include <iostream>

  int main() {
  std::string text = "abc-123 xyz-456";
  std::regex re(R"((\\w+)-(\\d+))");

  // sregex_iterator 示例：遍历所有匹配
  std::sregex_iterator it(text.begin(), text.end(), re);
  std::sregex_iterator end;
  for (; it != end; ++it) {
  std::cout << "Full match: " << it->str() << "\\n";
  std::cout << "Group 1: " << (*it)[1].str() << "\\n";
  }

  // sregex_token_iterator 示例：提取所有子组1
  std::sregex_token_iterator tok_it(text.begin(), text.end(), re, 1);
  std::sregex_token_iterator tok_end;
  for (; tok_it != tok_end; ++tok_it) {
  std::cout << "Group 1 content: " << *tok_it << "\\n";
  }
  }

  输出结果:

  Full match: abc-123
  Group 1: abc
  Full match: xyz-456
  Group 1: xyz
  Group 1 content: abc
  Group 1 content: xyz

  关键区别

  特性sregex_iteratorsregex_token_iterator

  返回内容	完整的 smatch 对象	直接返回子组或间隔的字符串
  典型用途	提取匹配的完整信息（含子组）	快速提取特定子组或拆分字符串
  构造函数参数	无子组索引参数	支持子组索引（submatch）
  使用场景	适合复杂匹配分析	适合高效提取或拆分