c++ 正则表达式

正则表达式

什么是正则表达式？
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

我们直接从例子入手，如果要规定输入账号，指定账号的长度在5位到11位之间，且不能输入字符等其他字符，只能输入数字，那么你要如何编写C++程序呢？？

c++伪代码：

1. 首先规定长度len，长度大于5位，小于11位，否则重新输入。
2. 然后规定输入数字，如果输入了数字直接重新输入。

regex正则表达式：

void fun()
{
	regex rex{ R"(\d{5,11})" };
	string account;
	smatch sm;
	cout << "请输入账号:";
	while (getline(cin, account))
	{
		if (regex_match(account, sm, rex))
		{
			break;
		}
		cout << "请重新输入:";
	}
	cout << "你的账号是: " << account << endl;
}

怎么样，是不是感觉很高端？ 利用正则表达式还可以写出更加高效的代码，我们在等会给大家演示！

---

基本语句

首先先让我们来初步认识正则表达式的基本语句。
有一篇博客总结的不错，这里我引用以下这个博主所总结的：
正则表达式

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 后向引用、或一个八进制转义符。例如，'n' 匹配字符 "n"。'\n' 匹配一个换行符。序列 ‘\\' 匹配 "\" 而 "\(" 则匹配 "("。
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n' 或 ‘\r' 之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘\n' 或 ‘\r' 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。 * 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 ‘o'，但是能匹配 "food" 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 ‘o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 ‘o+'。'o{0,}' 则等价于 ‘o*'。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。刘， "o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 ‘o?'。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，'o+?' 将匹配单个 "o"，而 ‘o+' 将匹配所有 ‘o'。
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 ‘\n' 在内的任何字符，请使用象 ‘[.\n]‘ 的模式。
(pattern)	匹配pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ‘‘或‘‘或‘'。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， ‘industr(?:y|ies) 就是一个比 ‘industry|industries' 更简略的表达式。
(?=pattern)	正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如， ‘Windows (?=95|98|NT|2000)' 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	负向预查，在任何不匹配Negative lookahead matches the search string at any point where a string not matching pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如'Windows (?!95|98|NT|2000)' 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
x|y	匹配 x 或 y。例如，'z|food' 能匹配 "z" 或 "food"。'(z|f)ood' 则匹配 "zood" 或 "food"。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， ‘[abc]‘ 可以匹配 "plain" 中的 ‘a'。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]‘ 可以匹配 "plain" 中的'p'。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，'[a-z]‘ 可以匹配 ‘a' 到 ‘z' 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，'[^a-z]‘ 可以匹配任何不在 ‘a' 到 ‘z' 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b' 可以匹配"never" 中的 ‘er'，但不能匹配 "verb" 中的 ‘er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 ‘er'，但不能匹配 "never" 中的 ‘er'。
\cx	匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。 x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c' 字符。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]‘。
\W	匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]‘。
\xn	匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如， ‘\x41′ 匹配 "A"。'\x041′ 则等价于 ‘\x04′ & "1"。正则表达式中可以使用 ASCII 编码。.
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1′ 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

regex_match

regex_match可以精准的匹配正则表达式与字符串。

接受参数：

s − 它是一个带有目标序列的字符串。
rgx − 它是要匹配的 basic_regex 对象。
flags − 用于控制 rgx 的匹配方式。
m − 它是 match_results 类型的对象。

返回值：
如果 rgx 与目标序列匹配，则返回 true。 否则为 false 。

• .* ： . 表示输入任意一个字符，* 表示输入任意多个，即在<>的范围内输入任意多个字符

regex myReg1{ "<.*>" };
bool ret1 = regex_match("<1234asd89>", myReg1);
assert(ret1);	//正确

• 一个比较上一个较复杂的例子：第一个<>内输入任意多个字符，然后在外面在接受任意多个字符，之后在最后一个<>内指定输入一个数字（使用转义字符转换为\d）

regex myReg2{ "<.*>.*<(\\d)>" };
bool ret2 = regex_match("abc<5>", myReg2);
assert(ret2);	//正确

• regex_match的另一种版本：

cmatch m;	//一个接受匹配后字符串的类，存储匹配后的字符串
auto ret = regex_match("666", m, regex{ "<(.*)>(.*)" });
if (ret)
{
	cout << m.str() << endl;
	cout << m.length() << endl;
	cout << m.position() << endl;
}

通过cmatch接受const char*类型的字符串，当然通过smatch也可以接受string类型的字符串。我们可以调用它所拥有的方法，比如得到这个字符串：str()，得到长度: length()，得到某个子匹配项在整个大的匹配项中所处的位置。

• 三种方法得到匹配后的字符串：

for (int i = 0	; i < m.size(); i++)
{
	cout << m[i].str() << " " << m.str(i) << endl;
}
cout << " -----------------------" << endl;
for (auto it = m.begin(); it != m.end(); it++)
{
	cout << *it << endl;
}

---

regex_search

搜索：整个字符序列中，是否有部分（或整体）符合匹配模式。

他接受的参数和返回值与regex_match一致。

在s中我们的字符序列在尾部多了一个end，显然与对应的匹配模式不符合，但是search和match不同的是，它只要有部分包含，则就是成功，返回正确匹配的一部分序列。

注意：在字符串前面加 R 表示原生 字符串 ，是防止 转义，否则你就要使用两个 \ 来表示转义。

• \d：表示接受一个数字。
• {3}：表示接受3个数字，与前面合起来则表示：接受 3个数字。
• [0-9]：表示接受任意一个数字，与 \d一个意思
• * 表示接受任意多字符，则表示接受 任意多个数字。

void f3()
{
	//regex_search: 字符串s的格式 在regex中匹配一部分，则返回匹配的部分内容，不必完全匹配
	//string s{ "123456: <1173012900>654321" };
	string s{ "666<1173012900>  end" };
	smatch sm;
	auto ret = regex_search(s, sm, regex{ R"(<(.*)>\d{3}<[0-9]*>)" });
	if (ret)
	{
		//cout << sm.str() << endl;
		for (auto& x : sm)
		{
			cout << x << endl;
		}
		cout << sm.prefix() << endl;	//返回前部分不匹配的
		cout << sm.suffix() << endl;	//返回后部分不匹配的
	}
}

smatch存储了匹配的部分字符序列，666<1173012900>，因此可以得到其前缀：prefix()，得到其后缀：suffix() ，这里的前缀与后缀都是指相对于匹配的这一部分前面的不匹配部分和后面不匹配部分。

regex_token_iterator

使用分词迭代器给字符序列分组：

void f5()
{
	//模板类regex_token_iterator<>提供分词迭代器
	string s{ "[email protected],[email protected],[email protected]" };
	regex rex{ "," };
	sregex_token_iterator pos{ s.begin(),s.end(),rex,-1 };
	decltype(pos) end;
	for (; pos != end; ++pos)
	{
		cout << pos->str() << endl;
	}
}

regex_replace

替换指定的字符

void f6()
{
	string s{ "he....llo. .w..orl...d" };
	regex rex{ "\\." };
	cout << regex_replace(s, rex, "");
}

示例

匹配电话号码

• 电话号码的位数为 11位，第一位一定是1
• 第一位：1
• 后10位：\d{10} 或者 [0-9]{10} 都可以
• ^ 表示序列的开始 $表示序列的结束

void exp1()
{
	string s;
	regex reg{ "^1[0-9]{10}$" };	// "^1\d{10}$"
	smatch sm;
	cout << "输入你的电话号码: ";
	while (getline(cin, s))
	{
		if (regex_match(s,sm, reg))
		{
			break;
		}
		cout << "输入格式错误，请重新输入:";
	}
	cout << "您的电话号码是: " << s << endl;
}

匹配QQ号码

QQ号码的位数可以是5位到11位：

• 第一位：[1-9] 或者 \d
• 后四位到后十位：[0-9]{4,10}

//匹配qq号码
void exp2()
{
	string s;
	regex reg{ "[1-9]\\d{4,10}" };	//5位或者11位 第一位不为0
	smatch sm;
	cout << "输入你的qq号码: ";
	while (getline(cin, s))
	{
		if (regex_match(s, sm, reg))
		{
			break;
		}
		cout << "输入格式错误，请重新输入:";
	}
	cout << "您的qq号码是: " << s << endl;
}

匹配IP地址

IP地址可以有四个数字部分和三个 . 部分如： 127.125.56.254

注意：它的每一位都是 0 - 255的数字，你可能以为 直接 \d{1,3} 输入三位不就好了？但是别忘了不能超过 255最大数字；你可能还会想通过 [0-5]{1,3}不就好了，但是你别忘了只是超过200之后不能超过255，没说小于200的不能超过255，因此，通过简单的表达式无法求出ip地址的匹配，我们可以通过下面的几种情况分类讨论：

1. 第一组： 0 - 9
2. 第二组： 10 - 99
3. 第三组： 100 - 199
4. 第四组： 200 - 249
5. 第五组： 250 - 255

• 通过或把每一种可能性连接起来，表示这五组只要有一组成立就可以，并且用（）把这一个统一的括起来，表示ip地址的第一个数字部分：

([0-9]|[1-9][0-9]|1\\d{2}|2[0-4][0-9]|25[0-5])

• 前三个数字部分后面都带一个点分隔符，直接重复三次，并且使用 ?: 来匹配各个组的统一模式

(?:(?:[0-9]|[1-9][0-9]|1\\d{2}|2[0-4][0-9]|25[0-5])\\.){3}

• 最后一个数字后面没有点，因此单独写一条：别忘了加上 ^与$

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

//匹配ip地址
void exp3()
{
	string s;
	//忽略子匹配内容字符： ?:
	regex reg{ "^(?:(?:[0-9]|[1-9][0-9]|1\\d{2}|2[0-4][0-9]|25[0-5])\\.){3}(?:[0-9]|[1-9][0-9]|1\\d{2}|2[0-4][0-9]|25[0-5])$" };
	smatch sm;
	cout << "输入你的ip号码: ";
	while (getline(cin, s))
	{
		if (regex_match(s, sm, reg))
		{
			break;
		}
		cout << "输入格式错误，请重新输入:";
	}
	cout << "您的ip号码是: " << s << endl;
}