C++正则表达式全攻略：从基础到高级应用_c++ 匹配单个字符

一、基础知识

正则表达式是一种用于匹配、搜索和编辑文本的字符串模式。它由一系列字符和特殊符号构成，可以灵活地表达文本的模式、结构和特征。正则表达式在各种编程语言和应用程序中广泛应用，包括C++。它可以用来在文本中查找特定模式的字符串、验证输入的格式、提取信息和进行文本替换等操作。

正则表达式的基本元素包括普通字符（如字母、数字和符号）、特殊字符（如通配符、边界符和量词）以及捕获组和反向引用等高级功能。通过组合这些元素，可以构建复杂的匹配规则，实现强大的文本处理功能。

C++中使用正则表达式的优势：

1. 强大的文本处理能力：正则表达式提供了灵活的方式来描述文本模式和规则，能够轻松地实现复杂的文本匹配、搜索和提取功能。

2. 通过正则表达式，可以快速验证用户输入的数据格式是否符合要求，提高了数据的准确性和一致性。

3. 正则表达式可以轻松地进行文本替换和格式化操作，例如批量替换文本中的内容或者格式化输出文本。

4. 正则表达式可以用较短的代码实现复杂的文本处理功能，提高代码的可读性和简洁性。

5. 正则表达式可以用于日志分析、数据提取、文本解析等各种场景，为 C++ 提供了强大的文本处理工具。

在 C++ 中使用正则表达式，通过提供的<regex>头文件来实现。基本语法和规则：

1. 普通字符：包括字母、数字和一些符号，表示自身字符。

2. 特殊字符：包括元字符（如 ^、$、.、*、+、?、|、\ 等），用于描述匹配规则。

3. 量词：指定前面模式出现的次数，如 *（零次或多次）、+（一次或多次）、?（零次或一次），{m,n}（出现次数范围为m到n次）等。

4. 转义字符：使用 \ 来转义特殊字符，使其成为普通字符。

5. 字符类：用 [ ] 表示一组字符中的任意一个。比如 [abc] 匹配 “a”、“b” 或 “c” 中的任意一个。

6. 捕获组：用( )将模式组合成一个单元，可以获取匹配的子串。

在 C++ 的 <regex> 头文件中，常用的类有 std::regex、std::smatch 和 std::regex_match 等，通过这些类可以实现正则表达式的匹配、搜索和提取。例如，使用 std::regex_match 函数来检查一个字符串是否与指定的正则表达式匹配，使用 std::smatch 类来存储匹配的结果。

正则表达式在 C++ 中的基本语法和规则与其他语言中的正则表达式基本相同，但在具体的实现上可能会有一些差异。可查看官方介绍。

二、正则表达式的基本匹配

1. 匹配单个字符：

   • 使用普通字符进行匹配，例如正则表达式 a 可以匹配字符串中的单个字符 “a”。
   • 使用元字符.进行匹配任意单个字符，例如正则表达式 s. 可以匹配字符串中的 “sa”、“sb”、“sc” 等。

2. 匹配多个字符：

   • 使用量词*匹配前面的字符出现零次或多次，例如正则表达式ab*可以匹配 “a”, “ab”, “abb”, “abbb” 等。
   • 使用量词+匹配前面的字符出现一次或多次，例如正则表达式ab+可以匹配 “ab”, “abb”, “abbb” 等。
   • 使用量词?匹配前面的字符出现零次或一次，例如正则表达式ab?可以匹配 “a”, “ab” 等。
   • 使用花括号{m,n}匹配前面的字符出现m到n次，例如正则表达式a{2,4}可以匹配 “aa”, “aaa”, “aaaa”。

3. 匹配起始和结束位置：

   • 使用锚字符^匹配字符串的起始位置，例如正则表达式^start可以匹配以 “start” 开头的字符串。
   • 使用锚字符$匹配字符串的结束位置，例如正则表达式end$可以匹配以 “end” 结尾的字符串。

当使用正则表达式进行文本匹配时，需要匹配字符类（character class）和排除字符类（negated character class）。字符类用来匹配一个字符集合中的任何一个字符，而排除字符类则用来匹配除指定字符集合之外的任何字符。

在正则表达式中使用方括号[]来表示一个字符类，方括号内包含要匹配的字符集合。例如：

• [aeiou] 可以匹配任何一个小写元音字母。
• [A-Za-z] 可以匹配任何一个大写或小写字母。
• [0-9] 可以匹配任何一个数字字符。

另外，可以在方括号内使用连字符-来表示一个范围，如[a-z]表示匹配任何一个小写字母。

相反，使用脱字符^在字符类内表示排除字符类。例如：

• [^aeiou] 可以匹配除了小写元音字母之外的任何字符。

正则表达式支持匹配重复出现的模式，使用不同的量词来指定重复匹配的规则。

常用的量词：

• *：匹配前面的模式零次或多次。
• +：匹配前面的模式一次或多次。
• ?：匹配前面的模式零次或一次。
• {n}：匹配前面的模式恰好n次。
• {n,}：匹配前面的模式至少n次。
• {n,m}：匹配前面的模式至少n次且至多m次。

例如：

• a* 可以匹配零个或多个 “a”。
• a+ 可以匹配一个或多个 “a”。
• a? 可以匹配零个或一个 “a”。
• a{3} 可以匹配恰好三个 “a”。
• a{2,4} 可以匹配两个到四个 “a”。

正则表达式还有两个重要的概念是锚点（anchors）和分组（groups）。

锚点用来指定匹配的位置，常用的锚点：

• ^：匹配字符串的开始位置。
• $：匹配字符串的结束位置。
• \b：匹配单词边界。
• \B：匹配非单词边界。

例如：

• ^abc 可以匹配以 “abc” 开头的字符串。
• xyz$ 可以匹配以 “xyz” 结尾的字符串。
• \bword\b 可以匹配单独的 “word” 单词。
• \Bword\B 可以匹配 “word” 单词的内部。

分组则用来把对模式的匹配结果进行分组，并对每个分组进行单独的处理。分组用括号()表示。例如：

• (ab)+ 可以匹配 “ab”、“abab”、“ababab” 等。
• (a|b) 可以匹配 “a” 或者 “b”。

三、C++中使用正则表达式

1. 在C++中使用正则表达式需要包含 <regex> 头文件，并使用 std 命名空间。
2. 使用std::regex类来创建正则表达式对象。正则表达式对象可以用来存储和表示一个特定的正则表达式模式。
3. 使用正则表达式来进行匹配和搜索。在C++中使用std::regex_search函数和std::regex_match函数来实现这些功能。

示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "Hello, this is a sample text with some numbers 12345.";
    std::regex pattern("\\d+"); // 匹配一个或多个数字

    std::smatch matches; // 用于存储匹配结果

    if (std::regex_search(text, matches, pattern)) {
        std::cout << "Found match: " << matches.str() << std::endl;
    } else {
        std::cout << "No match found." << std::endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

使用std::regex_search函数来搜索文本text，并且尝试找到与正则表达式模式pattern匹配的内容。还使用了std::smatch类来存储匹配的结果，并打印出匹配的内容。

还可以使用std::regex_match函数来检查整个字符串是否完全匹配正则表达式模式。

if (std::regex_match(text, pattern)) {
    std::cout << "Full match found" << std::endl;
} else {
    std::cout << "No full match found" << std::endl;
}
1
2
3
4
5

此外，可以使用C++中的正则表达式库来提取和替换匹配的部分。C++标准库中的std::regex类和std::regex_replace函数可以完成这些任务。

示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The cat sat on the mat.";
    std::regex pattern("\\b(cat)\\b"); // 匹配整个单词"cat"

    std::sregex_iterator it(text.begin(), text.end(), pattern);
    std::sregex_iterator end;

    for (; it != end; ++it) {
        std::smatch match = *it;
        std::cout << "Match found: " << match.str() << " at position " << match.position() << std::endl;
    }

    // 替换匹配的部分
    std::string replaced_text = std::regex_replace(text, pattern, "dog");
    std::cout << "Replaced text: " << replaced_text << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用std::sregex_iterator来迭代查找匹配的结果，然后使用std::regex_replace函数来替换匹配的部分。这里还使用了position()函数来获取匹配的位置。

四、高级正则表达式

（1）较为复杂的模式匹配。C++的正则表达式库支持一系列功能强大的正则表达式语法，可以用于更复杂的模式匹配需求，实现更精细的文本匹配和提取。
示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The cat sat on the mat. The dog sat on the rug.";
    std::regex pattern("\\b(\\w+)\\s+sat\\s+on\\s+the\\s+(\\w+)\\b"); // 匹配类似"xxx sat on the xxx"的句子

    std::sregex_iterator it(text.begin(), text.end(), pattern);
    std::sregex_iterator end;

    for (; it != end; ++it) {
        std::smatch match = *it;
        std::cout << "Match found: " << match.str() << std::endl;
        std::cout << "First captured group: " << match[1].str() << std::endl;
        std::cout << "Second captured group: " << match[2].str() << std::endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（2）使用捕获组和回溯。捕获组允许在正则表达式中标记并捕获特定的部分，而回溯则允许在替换文本中引用捕获的内容。
示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The price is $10.99. The total is $25.50.";
    std::regex pattern("\\$(\\d+\\.\\d+)"); // 匹配美元金额

    std::string replaced_text = std::regex_replace(text, pattern, "¥$1"); // 使用捕获组的内容进行替换
    std::cout << "Replaced text: " << replaced_text << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

使用了捕获组来匹配金额，并在替换文本中使用了$1来引用捕获的内容进行替换。这里的$1表示使用第一个捕获组的内容来替换匹配的部分。

（3）懒惰匹配与贪婪匹配。懒惰匹配和贪婪匹配用于描述量词的匹配方式。贪婪匹配尽可能多地匹配字符串，而懒惰匹配则尽可能少地匹配字符串。

在C++的正则表达式中使用?来表示懒惰匹配。示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The cat sat on the mat. The dog sat on the rug.";
    std::regex greedy_pattern("s[a-z]+t"); // 贪婪匹配，尽可能多地匹配s和t之间的字母
    std::regex lazy_pattern("s[a-z]+?t");  // 懒惰匹配，尽可能少地匹配s和t之间的字母

    std::sregex_iterator it_greedy(text.begin(), text.end(), greedy_pattern);
    std::sregex_iterator end_greedy;
    for (; it_greedy != end_greedy; ++it_greedy) {
        std::smatch match = *it_greedy;
        std::cout << "Greedy Match found: " << match.str() << std::endl;
    }

    std::sregex_iterator it_lazy(text.begin(), text.end(), lazy_pattern);
    std::sregex_iterator end_lazy;
    for (; it_lazy != end_lazy; ++it_lazy) {
        std::smatch match = *it_lazy;
        std::cout << "Lazy Match found: " << match.str() << std::endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

贪婪匹配尽可能多地匹配了s和t之间的字母，而懒惰匹配尽可能少地匹配了s和t之间的字母。

（4）向前和向后查找。向前和向后查找提供了一种基于当前匹配位置的相对定位功能，能够查找在特定位置之前或之后的模式。这对于需要匹配特定上下文的情况非常有用。

示例：

#include <iostream>
#include <regex>

int main() {
    std::string text = "The quick brown fox jumps over the lazy dog";
    std::regex forward_pattern("\\b\\w+(?=\\sfox)"); // 向前查找，匹配fox之前的单词
    std::regex backward_pattern("(?<=brown\\s)\\w+\\b"); // 向后查找，匹配brown之后的单词

    std::smatch match;
    if (std::regex_search(text, match, forward_pattern)) {
        std::cout << "Forward match found: " << match.str() << std::endl;
    }

    if (std::regex_search(text, match, backward_pattern)) {
        std::cout << "Backward match found: " << match.str() << std::endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

向前查找使用 (?=\sfox) 来匹配 fox 之前的单词，向后查找使用 (?<=brown\s) 来匹配 brown 之后的单词。

五、实践示例

（1）数据验证与格式化。邮箱地址进行验证和格式化：

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

bool isValidEmail(const std::string& email) {
    std::regex pattern(R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})");
    return std::regex_match(email, pattern);
}

std::string formatPhoneNumber(const std::string& phoneNumber) {
    std::regex pattern(R"(\b(\d{3})(\d{3})(\d{4})\b)");
    return std::regex_replace(phoneNumber, pattern, R"($1-$2-$3)");
}

int main() {
    // 邮箱验证
    std::string email = "2505756506@qq.com";
    if (isValidEmail(email)) {
        std::cout << "Email is valid" << std::endl;
    } else {
        std::cout << "Invalid email" << std::endl;
    }

    // 电话号码格式化
    std::string phoneNumber = "12345678901";
    std::string formattedNumber = formatPhoneNumber(phoneNumber);
    std::cout << "Formatted phone number: " << formattedNumber << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

验证是通过std::regex_match实现，而格式化是通过std::regex_replace实现。

（2文本提取与分析。提取文本中的数字并进行分析：

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

std::vector<int> extractNumbers(const std::string& input) {
    std::vector<int> numbers;
    std::regex pattern(R"(\d+)");
    std::sregex_iterator iter(input.begin(), input.end(), pattern);
    std::sregex_iterator end;

    for (; iter != end; ++iter) {
        numbers.push_back(std::stoi(iter->str()));
    }

    return numbers;
}

int main() {
    std::string text = "The price of the item is $250. The weight is 5.5 pounds.";
    std::vector<int> numbers = extractNumbers(text);

    std::cout << "Extracted numbers: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // 分析提取的数字
    int sum = 0;
    for (int num : numbers) {
        sum += num;
    }

    std::cout << "Sum of the numbers: " << sum << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

（3）日志文件分析。提取和分析日志文件中的关键信息，例如时间戳、IP地址、错误信息等：

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

void analyzeLogFile(const std::string& filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
        std::cerr << "Error opening file " << filename << std::endl;
        return;
    }

    std::regex timePattern(R"((\d{2}:\d{2}:\d{2}))");
    std::regex ipPattern(R"((\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))");
    std::regex errorPattern(R"(error|ERROR)");

    std::string line;
    while (std::getline(file, line)) {
        std::smatch timeMatch;
        std::smatch ipMatch;
        std::smatch errorMatch;

        if (std::regex_search(line, timeMatch, timePattern) && std::regex_search(line, ipMatch, ipPattern) && std::regex_search(line, errorMatch, errorPattern)) {
            std::cout << "Timestamp: " << timeMatch[0] << ", IP address: " << ipMatch[0] << ", Error: " << errorMatch[0] << std::endl;
        }
    }

    file.close();
}

int main() {
    analyzeLogFile("example.log");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

（4）高级的文本处理应用。

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

void advancedTextProcessing(const std::string& text) {
    // 通过正则表达式替换文本中的日期格式
    std::regex datePattern(R"(\b(\d{1,2})/(\d{1,2})/(\d{4})\b)");
    std::string processedText = std::regex_replace(text, datePattern, "$3-$1-$2");
    std::cout << "Processed text with date format replaced: " << processedText << std::endl;

    // 提取文本中的URL
    std::regex urlPattern(R"((https?://\S+))");
    std::sregex_iterator iter(text.begin(), text.end(), urlPattern);
    std::sregex_iterator end;

    std::cout << "Extracted URLs: ";
    for (; iter != end; ++iter) {
        std::cout << iter->str() << " ";
    }
    std::cout << std::endl;

    // 使用正则表达式分组提取文本中的标题和内容
    std::regex articlePattern(R"(<title>(.*?)</title>.*?<content>(.*?)</content>)", std::regex::dotall);
    std::smatch match;
    if (std::regex_search(text, match, articlePattern)) {
        std::cout << "Title: " << match[1].str() << std::endl;
        std::cout << "Content: " << match[2].str() << std::endl;
    }
}

int main() {
    std::string sampleText = "Today's date is 12/30/2023. Visit our website at https://www.baidu.com/ for more information. <title>Sample Title</title><content>This is a sample content.</content>";
    advancedTextProcessing(sampleText);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

六、性能优化

6.1、编译正则表达式

1. 预先编译正则表达式：对于会重复使用的正则表达式，建议在程序初始化阶段就进行编译，以避免在每次匹配时都重新编译。可以使用 std::regex 的构造函数来进行编译。

   std::regex regExpr(pattern); // 预先编译正则表达式
   1

2. 在可能的情况下，尽量使用简单的正则表达式模式，避免过于复杂和耗时的匹配规则。

3. 在正则表达式中尽量使用非贪婪量词（*?、+?、{n, m}?）来进行匹配，以避免贪婪匹配导致的性能问题。

4. 如果可能的话，尽量在正则表达式中使用具体的字符串，而不是通用的通配符，以减少匹配的复杂度。

5. 如果程序需要频繁使用多个正则表达式，可以将它们预先编译并存储起来，以提高性能。

   std::unordered_map<std::string, std::regex> regexCache;
   regexCache["datePattern"] = std::regex(R"((\d{1,2})/(\d{1,2})/(\d{4}))");
   1
   2

6.2、避免过度使用回溯

在编写正则表达式时，避免过度使用回溯是非常重要的，因为回溯会导致正则表达式的性能下降，尤其是在处理长文本或复杂模式时。

1. 尽量使用非贪婪量词（例如*?、+?、{n,m}?），以避免匹配过程中出现不必要的回溯。

2. 避免在正则表达式中过度使用嵌套的重复，因为这可能导致回溯的增加。尽量简化模式，减少嵌套的深度。

3. 使用原子组: 原子组可以避免回溯，因此可以使用它们来限制回溯发生的范围。

4. 如果只需要匹配特定的固定字符串，最好直接使用字符串匹配函数，而不是使用正则表达式。

5. 有些正则表达式引擎可以将正则表达式编译为确定性有限自动机（DFA），这种方法可以避免回溯，提高匹配性能。

6. 预先编译正则表达式: 如前面所述，在程序初始化阶段就进行编译，可以避免在每次匹配时都重新编译，提高性能。

6.3、优化匹配算法

1. 不同的算法在不同的场景下有不同的性能表现。例如，在处理大型文本时，基于有限自动机（DFA）的算法会比回溯算法更高效。

2. 回溯是一种耗时的操作，尽量避免使得正则表达式需要进行大量回溯，可以通过优化正则表达式模式或使用非贪婪量词来减少回溯次数。

3. 如果只需要匹配特定的固定字符串，直接使用字符串匹配函数（如 strstr 或其它语言的等效函数）可能比使用正则表达式更高效。

4. 如果需要频繁匹配相同的正则表达式，可以缓存匹配结果以减少重复的匹配操作。

5. 对输入文本进行预处理（例如，去除不需要进行匹配的部分）可以减少匹配的复杂度，提高匹配性能。

6. 对于大量需要匹配的数据，使用多线程并行匹配来加快匹配速度。

七、总结

正则表达式应用方向：

1. 输入验证：用于验证用户输入的数据是否符合特定的格式，如电子邮件地址、电话号码、日期、密码等。

2. 数据提取：从文本中提取特定模式的数据，例如从网页中提取链接、从日志文件中提取特定格式的数据等。

3. 替换和格式化：在文本处理中用于替换特定模式的字符串或格式化文本，例如将日期格式进行统一、删除不需要的空格等。

4. URL路由：在web开发中用于定义和匹配URL路由规则，实现页面的跳转和参数的提取。

5. 语法分析：在编译器和解释器中用于解析和处理特定语法和结构，如正则表达式引擎本身就是一个语法解析器的实现。

6. 日志分析：用于分析和筛选大量日志数据中的特定模式和信息。

7. 数据清洗：在数据处理和清洗中使用正则表达式来识别和处理不规范的数据格式。

8. 敏感词过滤：用于在文本中过滤敏感词和不良内容。

9. 字符串匹配：用于查找字符串中是否包含特定的模式或关键字。