C++ regex

╰+哭是因爲堅強的太久メ 2022-05-14 02:25 143阅读 0赞

## 匹配字符串的基本规则 ##

1. 匹配固定的字符串

regex e("abc");

2. 匹配固定字符串，不区分大小写

regex e("abc", regex_constants::icase);

3. 匹配固定字符串之外多一个字符，不区分大小写

regex e("abc.", regex_constants::icase);     // .  Any character except newline. 1个字符

4. 匹配0个或1个字符

regex e("abc?");             // ?       Zero or 1 preceding character. 匹配?前一个字符

5. 匹配0个或多个字符

regex e("abc*");             // *       Zero or more preceding character. 匹配*前一个字符

6. 匹配1个或多个字符

regex e("abc+");             // +       One or more preceding character. 匹配+前一个字符

7. 匹配特定字符串中的字符

regex e("ab[cd]*");              // [...]   Any character inside square brackets. 匹配[]内的任意字符

8. 匹配非特定字符串的字符

regex e("ab[^cd]*");             // [...]   Any character not inside square brackets. 匹配非[]内的任意字符

9. 匹配特定字符串，且指定数量

regex e("ab[cd]{3}");                // {n}     匹配{}之前任意字符，且字符个数为3个

10. 匹配特定字符串，指定数量范围

regex e("ab[cd]{3,}");               // {n}     匹配{}之前任意字符，且字符个数为3个或3个以上
    regex e("ab[cd]{3,5}");         // {n}     匹配{}之前任意字符，且字符个数为3个以上，5个以下闭区间

11. 匹配规则中的某一个规则

regex e("abc|de[fg]");               // |       匹配|两边的任意一个规则

12. 匹配分组

regex e("(abc)de+");             // ()       ()表示一个子分组

13. 匹配子分组

regex e("(abc)de+\\1");          // ()       ()表示一个子分组，而\1表示在此位置匹配第一个分组的内容
    regex e("(abc)c(de+)\\2\\1");           // \2      表示的是在此匹配第二个分组的内容

14. 匹配某个字符串开头

regex e("^abc.");                // ^   begin of the string     查找以abc开头的子字符串

15. 匹配某个字符串结尾

regex e("abc.$");				// $ end of the string 查找以abc结尾的子字符串

以上是最基本的匹配模式的书写。通常如果要匹配特定的字符，需要使用\\进行转义，比如在匹配字符串中需要匹配”.”，那么在匹配字符串中应该在特定字符前加上\\。出了以上的基本规则，如果还不满足特定的需要，那么可以参考此[链接][Link 1]。使用了解基本的匹配模式后，需要使用正则表达式进行匹配、查找或者替代。

## 正则匹配、查找与替代 ##

书写好模式字符串后，需要将待匹配的字符串和模式字符串进行一定规则的匹配。包括三种方式：匹配（regex\_match）、查找（regex\_search）、替换（regex\_replace）。

匹配很简单，直接将待匹配字符串和模式字符串传入到regex\_match中，返回一个bool量来指明待匹配的字符串是否满足模式字符串的规则。匹配整个str字符串。

bool match = regex_match(str, e);        // 匹配整个字符串str

查找是在整个字符串中找到和满足模式字符串的子字符串。也就是只要str中存在满足模式字符串就会返回true。

bool match = regex_search(str, e);       // 查找字符串str中匹配e规则的子字符串

但是很多情况下，光是返回一个是否匹配的bool量是不够的，我们需要拿到匹配的子字符串。那么就需要在模式字符串中将匹配字符串分组，参考【匹配字符串的基本规则】第12点。再将smatch传入到regex\_search中，就可以获得满足每个子分组的字符串。

![复制代码][copycode.gif]

smatch m;
    bool found = regex_search(str, m, e);

for (int n = 0; n < m.size(); ++n) 
\{ 
cout << “m\[” << n << “\].str()=” << m\[n\].str() << endl; 
\}

![复制代码][copycode.gif]

替换也是基于模式字符串在分组情况下完成的。

cout << regex_replace(str, e, "$1 is on $2");

此时，会在满足分组1和分组2的字符串中间加上“ is on”。

以上三个函数有很多版本的重载，可以满足不同情况下的需求。

## 实战 ##

要求：找出满足sectionA(“sectionB”)或者sectionA (“sectionB”)的模式字符串。且分离出sectionA、sectionB。sectionA和sectionB不会出现数字，字符可大小写，至少有一个字符。

分析：根据要求，大致可分为两个部分，也就是sectionA和sectionaB。这是就需要用到分组。

第一步：写出满足section情况的模式字符串

[a-zA-Z]+

第二步：在sectionA和sectionB中可能会出现空格。暂且假设至多有1个空格

\\s?

将以上两个情况组合起来，也就是能满足我们需求的模式字符串。但是如何组织才能让其分为两组呢？

[a-zA-Z]+\\s[a-zA-Z]+

上面这种写法肯定不对的，根据分组规则，需要将分组以()进行区分

regex e("([a-zA-Z]+)\\s?\$\"([a-zA-Z]+)\"\$");

此时，在\\\\s?后面的\\\\(\\“是为了满足sectionB外层的引号和括号进行的转义。

以上完成后，可先用regex\_match进行匹配，如果匹配，那么继续使用regex\_search对字符串进行查找

![复制代码][copycode.gif]

if (regex_match(str, e))
 {
 smatch m;
 auto found = regex_search(str, m, e);
 for (int n = 0; n < m.size(); ++n)
 {
 cout << "m[" << n << "].str()=" << m[n].str() << endl;
 }
 }
 else
 {
 cout << "Not matched" << endl;
 }

![复制代码][copycode.gif]

<table> 
 <tbody> 
 <tr> 
 <th>表达式</th> 
 <th>匹配</th> 
 </tr> 
 <tr> 
 <td>/^\s*$/</td> 
 <td>匹配空行。</td> 
 </tr> 
 <tr> 
 <td>/\d{2}-\d{5}/</td> 
 <td>验证由两位数字、一个连字符再加 5 位数字组成的 ID 号。</td> 
 </tr> 
 <tr> 
 <td>/&lt;\s*(\S+)(\s[^&gt;]*)?&gt;[\s\S]*&lt;\s*\/\1\s*&gt;/</td> 
 <td>匹配 HTML 标记。</td> 
 </tr> 
 </tbody> 
</table>

下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：

<table> 
 <tbody> 
 <tr> 
 <th>字符</th> 
 <th>说明</th> 
 </tr> 
 <tr> 
 <td>\</td> 
 <td>将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n”匹配字符“n”。“\n”匹配换行符。序列“\\”匹配“\”，“\(”匹配“(”。</td> 
 </tr> 
 <tr> 
 <td>^</td> 
 <td>匹配输入字符串开始的位置。如果设置了&nbsp;RegExp&nbsp;对象的&nbsp;Multiline&nbsp;属性，^ 还会与“\n”或“\r”之后的位置匹配。</td> 
 </tr> 
 <tr> 
 <td>$</td> 
 <td>匹配输入字符串结尾的位置。如果设置了&nbsp;RegExp&nbsp;对象的&nbsp;Multiline&nbsp;属性，$ 还会与“\n”或“\r”之前的位置匹配。</td> 
 </tr> 
 <tr> 
 <td>*</td> 
 <td>零次或多次匹配前面的字符或子表达式。例如，zo* 匹配“z”和“zoo”。* 等效于 {0,}。</td> 
 </tr> 
 <tr> 
 <td>+</td> 
 <td>一次或多次匹配前面的字符或子表达式。例如，“zo+”与“zo”和“zoo”匹配，但与“z”不匹配。+ 等效于 {1,}。</td> 
 </tr> 
 <tr> 
 <td>?</td> 
 <td>零次或一次匹配前面的字符或子表达式。例如，“do(es)?”匹配“do”或“does”中的“do”。? 等效于 {0,1}。</td> 
 </tr> 
 <tr> 
 <td>{ n}</td> 
 <td>n&nbsp;是非负整数。正好匹配&nbsp;n&nbsp;次。例如，“o{2}”与“Bob”中的“o”不匹配，但与“food”中的两个“o”匹配。</td> 
 </tr> 
 <tr> 
 <td>{ n,}</td> 
 <td>n&nbsp;是非负整数。至少匹配&nbsp;n&nbsp;次。例如，“o{2,}”不匹配“Bob”中的“o”，而匹配“foooood”中的所有 o。“o{1,}”等效于“o+”。“o{0,}”等效于“o*”。</td> 
 </tr> 
 <tr> 
 <td>{ n,m}</td> 
 <td>M&nbsp;和&nbsp;n&nbsp;是非负整数，其中&nbsp;n&nbsp;&lt;=&nbsp;m。匹配至少&nbsp;n&nbsp;次，至多&nbsp;m&nbsp;次。例如，“o{1,3}”匹配“fooooood”中的头三个 o。’o{0,1}’ 等效于 ‘o?’。注意：您不能将空格插入逗号和数字之间。</td> 
 </tr> 
 <tr> 
 <td>?</td> 
 <td>当此字符紧随任何其他限定符（*、+、?、{ n}、{ n,}、{ n,m}）之后时，匹配模式是“非贪心的”。“非贪心的”模式匹配搜索到的、尽可能短的字符串，而默认的“贪心的”模式匹配搜索到的、尽可能长的字符串。例如，在字符串“oooo”中，“o+?”只匹配单个“o”，而“o+”匹配所有“o”。</td> 
 </tr> 
 <tr> 
 <td>.</td> 
 <td>匹配除“\n”之外的任何单个字符。若要匹配包括“\n”在内的任意字符，请使用诸如“[\s\S]”之类的模式。</td> 
 </tr> 
 <tr> 
 <td>(pattern)</td> 
 <td>匹配&nbsp;pattern&nbsp;并捕获该匹配的子表达式。可以使用&nbsp; 0… 0 … 9&nbsp;属性从结果“匹配”集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用“&amp;#x201D;&amp;#x6216;&amp;#x8005;&amp;#x201C;” role=”presentation” style=”position: relative;”&gt;”或者“”或者“”。</td> 
 </tr> 
 <tr> 
 <td>(?:pattern)</td> 
 <td>匹配&nbsp;pattern&nbsp;但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用“or”字符 (|) 组合模式部件的情况很有用。例如，’industr(?:y|ies) 是比 ‘industry|industries’ 更经济的表达式。</td> 
 </tr> 
 <tr> 
 <td>(?=pattern)</td> 
 <td>执行正向预测先行搜索的子表达式，该表达式匹配处于匹配&nbsp;pattern&nbsp;的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，’Windows (?=95|98|NT|2000)’ 匹配“Windows 2000”中的“Windows”，但不匹配“Windows 3.1”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。</td> 
 </tr> 
 <tr> 
 <td>(?!pattern)</td> 
 <td>执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配&nbsp;pattern&nbsp;的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，’Windows (?!95|98|NT|2000)’ 匹配“Windows 3.1”中的 “Windows”，但不匹配“Windows 2000”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。</td> 
 </tr> 
 <tr> 
 <td>x|y</td> 
 <td>匹配&nbsp;x&nbsp;或&nbsp;y。例如，’z|food’ 匹配“z”或“food”。’(z|f)ood’ 匹配“zood”或“food”。</td> 
 </tr> 
 <tr> 
 <td>[xyz]</td> 
 <td>字符集。匹配包含的任一字符。例如，“[abc]”匹配“plain”中的“a”。</td> 
 </tr> 
 <tr> 
 <td>[^xyz]</td> 
 <td>反向字符集。匹配未包含的任何字符。例如，“[^abc]”匹配“plain”中的“p”。</td> 
 </tr> 
 <tr> 
 <td>[a-z]</td> 
 <td>字符范围。匹配指定范围内的任何字符。例如，“[a-z]”匹配“a”到“z”范围内的任何小写字母。</td> 
 </tr> 
 <tr> 
 <td>[^a-z]</td> 
 <td>反向范围字符。匹配不在指定的范围内的任何字符。例如，“[^a-z]”匹配任何不在“a”到“z”范围内的任何字符。</td> 
 </tr> 
 <tr> 
 <td>\b</td> 
 <td>匹配一个字边界，即字与空格间的位置。例如，“er\b”匹配“never”中的“er”，但不匹配“verb”中的“er”。</td> 
 </tr> 
 <tr> 
 <td>\B</td> 
 <td>非字边界匹配。“er\B”匹配“verb”中的“er”，但不匹配“never”中的“er”。</td> 
 </tr> 
 <tr> 
 <td>\cx</td> 
 <td>匹配&nbsp;x&nbsp;指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x&nbsp;的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是“c”字符本身。</td> 
 </tr> 
 <tr> 
 <td>\d</td> 
 <td>数字字符匹配。等效于 [0-9]。</td> 
 </tr> 
 <tr> 
 <td>\D</td> 
 <td>非数字字符匹配。等效于 [^0-9]。</td> 
 </tr> 
 <tr> 
 <td>\f</td> 
 <td>换页符匹配。等效于 \x0c 和 \cL。</td> 
 </tr> 
 <tr> 
 <td>\n</td> 
 <td>换行符匹配。等效于 \x0a 和 \cJ。</td> 
 </tr> 
 <tr> 
 <td>\r</td> 
 <td>匹配一个回车符。等效于 \x0d 和 \cM。</td> 
 </tr> 
 <tr> 
 <td>\s</td> 
 <td>匹配任何空白字符，包括空格、制表符、换页符等。与 [&nbsp;\f\n\r\t\v] 等效。</td> 
 </tr> 
 <tr> 
 <td>\S</td> 
 <td>匹配任何非空白字符。与 [^&nbsp;\f\n\r\t\v] 等效。</td> 
 </tr> 
 <tr> 
 <td>\t</td> 
 <td>制表符匹配。与 \x09 和 \cI 等效。</td> 
 </tr> 
 <tr> 
 <td>\v</td> 
 <td>垂直制表符匹配。与 \x0b 和 \cK 等效。</td> 
 </tr> 
 <tr> 
 <td>\w</td> 
 <td>匹配任何字类字符，包括下划线。与“[A-Za-z0-9_]”等效。</td> 
 </tr> 
 <tr> 
 <td>\W</td> 
 <td>与任何非单词字符匹配。与“[^A-Za-z0-9_]”等效。</td> 
 </tr> 
 <tr> 
 <td>\xn</td> 
 <td>匹配&nbsp;n，此处的&nbsp;n&nbsp;是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41”匹配“A”。“\x041”与“\x04”&amp;“1”等效。允许在正则表达式中使用 ASCII 代码。</td> 
 </tr> 
 <tr> 
 <td>\num</td> 
 <td>匹配&nbsp;num，此处的&nbsp;num&nbsp;是一个正整数。到捕获匹配的反向引用。例如，“(.)\1”匹配两个连续的相同字符。</td> 
 </tr> 
 <tr> 
 <td>\n</td> 
 <td>标识一个八进制转义码或反向引用。如果 \n&nbsp;前面至少有&nbsp;n&nbsp;个捕获子表达式，那么&nbsp;n&nbsp;是反向引用。否则，如果&nbsp;n&nbsp;是八进制数 (0-7)，那么&nbsp;n&nbsp;是八进制转义码。</td> 
 </tr> 
 <tr> 
 <td>\nm</td> 
 <td>标识一个八进制转义码或反向引用。如果 \nm&nbsp;前面至少有&nbsp;nm&nbsp;个捕获子表达式，那么&nbsp;nm&nbsp;是反向引用。如果 \nm&nbsp;前面至少有&nbsp;n&nbsp;个捕获，则&nbsp;n&nbsp;是反向引用，后面跟有字符m。如果两种前面的情况都不存在，则 \nm&nbsp;匹配八进制值&nbsp;nm，其中&nbsp;n&nbsp;和&nbsp;m&nbsp;是八进制数字 (0-7)。</td> 
 </tr> 
 <tr> 
 <td>\nml</td> 
 <td>当&nbsp;n&nbsp;是八进制数 (0-3)，m&nbsp;和&nbsp;l&nbsp;是八进制数 (0-7) 时，匹配八进制转义码&nbsp;nml。</td> 
 </tr> 
 <tr> 
 <td>\un</td> 
 <td>匹配&nbsp;n，其中&nbsp;n&nbsp;是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。</td> 
 </tr> 
 </tbody> 
</table>

用户名

/^\[a-z0-9\_-\]\{3,16\}$/

密码

/^\[a-z0-9\_-\]\{6,18\}$/

十六进制值

/^\#?(\[a-f0-9\]\{6\}|\[a-f0-9\]\{3\})$/

电子邮箱

/^(\[wd\_.-\]+)@(\[wd\_-\]+.)+w\{2,4\}$/

/^(\[a-z0-9\_.-\]+)@(\[da-z.-\]+).(\[a-z.\]\{2,6\})$/

/^\[a-zd\]+(.\[a-zd\]+)\*@(\[da-z\](-\[da-z\])?)+(.\{1,2\}\[a-z\]+)+$/

URL

/^(https?://)?(\[da-z.-\]+).(\[a-z.\]\{2,6\})(\[/w .-\]\*)\*/?$/

/^(https?://)?(\[wd\_-\]+.)+w\{2,4\}(/\[wd.?-\_%=&\]+)\*$/

IP 地址

/((2\[0-4\]d|25\[0-5\]|\[01\]?dd?).)\{3\}(2\[0-4\]d|25\[0-5\]|\[01\]?dd?)/

或

/^(?:(?:25\[0-5\]|2\[0-4\]\[0-9\]|\[01\]?\[0-9\]\[0-9\]?).)\{3\}(?:25\[0-5\]|2\[0-4\]\[0-9\]|\[01\]?\[0-9\]\[0-9\]?)$/

HTML 标签

/^<(\[a-z\]+)(\[^<\]+)\*(?:>(.\*)</1>|s+/>)$/

转载[c++ regex  
][c_ regex]

[Link 1]: http://www.cplusplus.com/reference/regex/ECMAScript/
[copycode.gif]: /images/20220514/9a4d32a7a3464bb4aff1cbd2cf0a0fd7.png
[c_ regex]: https://blog.csdn.net/qianpeng4/article/details/78495899