正则表达式是一种用于匹配字符串的工具，可以在文本中查找特定的模式，并且可以快速地对字符串进行搜索和处理。C++ 11 引入了正则表达式标准库，使得 C++ 开发者可以轻松地使用正则表达式的强大功能。
  正则表达式可以应用于各种编程语言和文本处理工具中，如 JavaScript、Python、Java、Perl 等。例如下面的表达式可以检查QQ号是否合法：

std::regex qq_reg("[1-9]\\d{4,11}");
bool ret = std::regex_match(qq, qq_reg);
std::cout << (ret ? "valid" : "invalid") << std::endl;

  是不是非常方便？那么接下来我们就来学习C++ 正则表达式的基础知识，包括如何定义正则表达式，如何进行匹配和替换等操作。同时，我们将提供大量的实例来帮助您深入理解。

1 正则表达式语法

  正则表达式是由一系列字符和特殊字符组成的模式，用于描述一类字符串。正则表达式的语法非常灵活，不同的字符和组合可以匹配不同的字符串。std::regex默认使用是ECMAScript文法，这种文法比较好用，且威力强大。下面以该文法为准，介绍常见的正则表达式语法。

1.1 字符和特殊字符

  字符表示匹配自身，例如匹配字母 a 就是一个普通字符 a。
  除了普通字符，正则表达式还包含以下特殊字符。

符号	意义
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \. 。
[…]	匹配[]中的任意一个字符,要匹配 {，请使用 \{。
(…)	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)。
\	转义字符，要匹配’\’ ，请使用"\\"。
\d	匹配数字[0-9]。
\D	\d 取反。
\w	匹配字母[a-z]，数字，下划线。
\W	\w 取反。
\s	匹配空格。
\S	\s 取反。
|	指明两项之间的一个选择。要匹配 |，请使用 \|。

1.2 限定符

  限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。详细说明如下。

符号	意义
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用\*。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?。
{n}	前面的元素重复n次，要匹配 {，请使用 \{。
{n,}	前面的元素重复至少n次，要匹配 {，请使用 \{。
{n,m}	前面的元素重复至少n次，至多m次，要匹配 {，请使用 \{。

  以下正则表达式匹配一个正整数，[1-9]设置第一个数字不是 0，[0-9]* 表示任意多个数字：

[1-9][0-9]*

  * 和 + 限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个 ? 就可以实现非贪婪或最小匹配。
  例如，您可能搜索 HTML 文档，以查找在 h1 标签内的内容。HTML 代码如下：

<h1>Hello Santiago</h1>

  贪婪：下面的表达式匹配从开始小于符号 (<) 到关闭 h1 标记的大于符号 (>) 之间的所有内容。

  非贪婪：如果您只需要匹配开始和结束 h1 标签，下面的非贪婪表达式只匹配 <h1> 。

  也可以使用以下正则表达式来匹配 h1 标签，表达式则是：

  通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从"贪婪"表达式转换为"非贪婪"表达式或者最小匹配。

1.3 定位符

  定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b 描述单词的前或后边界，\B 表示非单词边界。定位符详细说明见下表。

符号	意义
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 \^。
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 \$。
\b	匹配一个单词边界，即字与空格间的位置。
\B	非单词边界匹配。

  注意：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。
  下面的正则表达式匹配一个章节标题，该标题只包含两个尾随数字，并且出现在行首：

^Chapter [1-9][0-9]{0,1}

  真正的章节标题不仅出现行的开始处，而且它还是该行中仅有的文本。它既出现在行首又出现在同一行的结尾。下面的表达式能确保指定的匹配只匹配章节而不匹配交叉引用。通过创建只匹配一行文本的开始和结尾的正则表达式，就可做到这一点。

^Chapter [1-9][0-9]{0,1}$

  匹配单词边界稍有不同，但向正则表达式添加了很重要的能力。单词边界是单词和空格之间的位置。非单词边界是任何其他位置。下面的表达式匹配单词 Chapter 的开头三个字符，因为这三个字符出现在单词边界后面：

\bCha

  \b 字符的位置是非常重要的。如果它位于要匹配的字符串的开始，它在单词的开始处查找匹配项。如果它位于字符串的结尾，它在单词的结尾处查找匹配项。例如，下面的表达式匹配单词 Chapter 中的字符串 ter，因为它出现在单词边界的前面：

ter\b

  下面的表达式匹配 Chapter 中的字符串 apt，但不匹配 aptitude 中的字符串 apt：

\Bapt

  字符串 apt 出现在单词 Chapter 中的非单词边界处，但出现在单词 aptitude 中的单词边界处。对于 \B 非单词边界运算符，不可以匹配单词的开头或结尾，如果是下面的表达式，就不匹配 Chapter 中的 Cha：

\BCha

  下面一个例子可以匹配类似“123abc”、“1abc”的字符串，但是不匹配“1bc”,"abcd"这样的字符串。

^[0-9]+abc$

• ^ 为匹配输入字符串的开始位置。
• [0-9]+ 匹配多个数字， [0-9] 匹配单个数字，+ 匹配一个或者多个。
• abc$ 匹配字母 abc 并以 abc 结尾，$ 为匹配输入字符串的结束位置。

1.4 选择和反向引用

  对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。
  反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。以下面的句子为例：

Is is the cost of of gasoline going up up?

  上面的句子很显然有多个重复的单词。如果能设计一种方法定位该句子，而不必查找每个单词的重复出现，那该有多好。下面的正则表达式使用单个子表达式来实现这一点：

  第1个捕获的表达式（位于小括号内），正如 [a-z]+ 指定的，包括一个或多个字母。正则表达式的第二部分是对以前捕获的子匹配项的引用，即，单词的第二个匹配项正好由括号表达式匹配。\1 指定第一个子匹配项。
  单词边界元字符确保只检测整个单词。否则，诸如 “is issued” 或 “this is” 之类的词组将不能正确地被此表达式识别。

2 C++正则表达式标准库常用接口

（1）基本类

  为了支持宽字符和窄字符，所以正则表达式的类基本上是通过类模板来实现的。

typedef basic_regex<char> regex;					  // 正则表达式对象 
typedef basic_regex<wchar_t> wregex;
typedef match_results<const char *> cmatch;			  // 标识一个正则表达式匹配，包含所有子表达式匹配(字符指针） 
typedef match_results<const wchar_t *> wcmatch;
typedef match_results<string::const_iterator> smatch; // 标识一个正则表达式匹配，包含所有子表达式匹配(字符串） 
typedef match_results<wstring::const_iterator> wsmatch;
typedef sub_match<const char *> csub_match;		      // 标识子表达式所匹配的字符序列 
typedef sub_match<const wchar_t *> wcsub_match;

（2）算法
  算法将封装于 regex 的正则表达式应用到字符的目标序列，算法主要是由函数模板来实现的。

• regex_match，试图匹配正则表达式到整个字符序列 。
• regex_search，试图匹配正则表达式到字符序列的任何部分 。
• regex_replace，以格式化的替换文本来替换正则表达式匹配的出现位置 。

（3）迭代器
  迭代器用于遍历在序列中找到的匹配正则表达式的整个集合。

• regex_iterator，在字符序列中通过所有正则表达式匹配迭代 。
• regex_token_iterator，通过在给定的字符串中所有正则表达式匹配中的指定子表达式，或通过不匹配的子串迭代 。

（4）异常
  regex_error定义一个对象抛出来自正则表达式库 的异常。

3 C++正则表达式模板的使用

  C++ 的正则表达式标准库提供了多种操作，可以对字符串进行匹配、替换、搜索等操作。下面是一些常见的操作。

3.1 匹配（Match）

  字符串处理常用的一个操作是匹配，即字符串和规则恰好对应，而用于匹配的函数为std::regex_match()，它是个函数模板，要求整个字符串符合匹配规则，返回true或false。
（1）测试是否匹配
  我们直接来看例子：

std::regex reg("<.*>.*</.*>");
bool ret = std::regex_match("<html>value</html>", reg);
assert(ret);

ret = std::regex_match("<xml>value<xml>", reg);
assert(!ret);

std::regex reg1("<(.*)>.*</\\1>");
ret = std::regex_match("<xml>value</xml>", reg1);
assert(ret);

ret = std::regex_match("<header>value</header>", std::regex("<(.*)>value</\\1>"));
assert(ret);

  这个小例子使用regex_match()来匹配xml格式（或是html格式）的字符串，匹配成功则会返回true。
  我们以下面语句为例进行讲解

std::regex reg("<.*>.*</.*>");
bool ret = std::regex_match("<html>value</html>", reg);

  代码第一行构造了一个正则表达式std::regex对象reg，实际上std::regex是class std::basic_regex<>针对char类型的一个特化，还有一个针对wchar_t类型的特化为std::wregex。

typedef basic_regex regex;
typedef basic_regex<wchar_t> wregex;

  我们使用针对char类型的特化版本，因此，接下来的测试字符串都应该是窄字符char*类型。
  reg要求字符串规则为：“<” + 任意个字符 + “>” + 任意个字符 +“</” + 任意个字符 + “>”，因此成功匹配了字符串 “<html>value</html>”。
  再看下面两句：

std::regex reg1("<(.*)>.*</\\1>");
ret = std::regex_match("<xml>value</xml>", reg1);

  请注意第1行的“<(.*)>”，它将字符串首个<>括号中的内容作为子匹配放入缓冲区中，编号为1。而 “</\\1>” 中的"\\1"实际代表"\1"（因为 \ 需要转义），表示引用第1个缓冲区的内容。
  C++11以后支持原生字符，所以也可以这样使用：

std::regex reg1(R"(<(.*)>.*</\1>)");
auto ret = std::regex_match("<xml>value</xml>", reg1);
assert(ret);

（2） 获取匹配结果
  若是想得到匹配的结果，可以使用regex_match()的另一个重载形式：

std::cmatch m;
auto ret = std::regex_match("<xml>value</xml>", m, std::regex("<(.*)>(.*)</(\\1)>"));
if (ret)
{
    
	std::cout << m.str() << std::endl;
	std::cout << m.length() << std::endl;
	std::cout << m.position() << std::endl;
}

std::cout << "----------------" << std::endl;

// 遍历匹配内容
for (auto i = 0; i < m.size(); ++i)
{
    
	// 两种方式都可以
	std::cout << m[i].str() << " " << m.str(i) << std::endl;
}

std::cout << "----------------" << std::endl;

// 使用迭代器遍历
for (auto pos = m.begin(); pos != m.end(); ++pos)
{
    
	std::cout << *pos << std::endl;
}

  输出结果为：

<xml>value</xml>
16
0
----------------
<xml>value</xml> <xml>value</xml>
xml xml
value value
xml xml
----------------
<xml>value</xml>
xml
value
xml

  cmatch是class template std::match_result<>针对C字符的一个特化版本，若是string，便得用针对string的特化版本smatch。同时还支持其相应的宽字符版本wcmatch和wsmatch。
  在regex_match()的第二个参数传入match_result便可获取匹配的结果，在例子中便将结果储存到了cmatch中，而cmatch又提供了许多函数可以对这些结果进行操作，大多方法都和string的方法类似，所以使用起来比较容易。
  m[0]保存着匹配结果的所有字符，若想在匹配结果中保存有子串，则得在正则表达式中用()标出子串，所以这里多加了几个括号：

std::regex("<(.*)>(.*)</(\\1)>")

  这样这些子串就会依次保存在m[0]的后面，即可通过m[1],m[2],…依次访问到各个子串。

3.2 搜索（Search）

  搜索与匹配非常相像，其对应的函数为std::regex_search，也是个函数模板，用法和regex_match一样，不同之处在于搜索只要字符串中有目标出现就会返回，而非完全匹配。

	std::regex regSearch("<(.*)>(.*)</(\\1)>");
	std::cmatch mSearch;
	bool ret2 = std::regex_search("123<xml>value</xml>456<test>something</test>", mSearch, regSearch);
	if (ret2)
	{
    
		for (auto& elem : mSearch)
			std::cout << elem << std::endl;
	}
	std::cout << "prefix:" << mSearch.prefix() << std::endl;
	std::cout << "suffix:" << mSearch.suffix() << std::endl;

  输出为：

<xml>value</xml>
xml
value
xml
prefix:123
suffix:456<test>something</test>

  这儿若换成regex_match匹配就会失败，因为regex_match是完全匹配的，而此处字符串前后却多加了几个字符。
  对于搜索，在匹配结果中可以分别通过prefix和suffix来获取前缀和后缀，前缀即是匹配内容前面的内容，后缀则是匹配内容后面的内容。
  另外，请注意，搜索仅仅是搜到第1个符合要求的子串就返回。
  那么若有多组符合条件的内容又如何得到其全部信息呢？这里依旧通过一个小例子来看：

	std::regex regSearch2("<(.*)>(.*)</(\\1)>");
	std::string content("123<xml>value</xml>456<widget>center</widget>hahaha<vertical>window</vertical>the end");
	std::smatch mSearch2;
	auto pos = content.cbegin();
	auto end = content.cend();
	for (; std::regex_search(pos, end, mSearch2, regSearch2); pos = mSearch2.suffix().first)
	{
    
		std::cout << "----------------" << std::endl;
		std::cout << mSearch2.str() << std::endl;
		std::cout << mSearch2.str(1) << std::endl;
		std::cout << mSearch2.str(2) << std::endl;
		std::cout << mSearch2.str(3) << std::endl;
	}

  输出结果为：

----------------
<xml>value</xml>
xml
value
xml
----------------
<widget>center</widget>
widget
center
widget
----------------
<vertical>window</vertical>
vertical
window
vertical

  此处使用了regex_search函数的另一个重载形式（regex_match函数亦有同样的重载形式），实际上所有的子串对象都是从std::pair<>派生的，其first（即此处的prefix）即为第一个字符的位置，second（即此处的suffix）则为最末字符的下一个位置。
  一组查找完成后，便可从suffix处接着查找，这样就能获取到所有符合内容的信息了。

3.3 分词（Tokenize）

  还有一种操作叫做切割，例如有一组数据保存着许多邮箱账号，并以逗号分隔，那就可以指定以逗号为分割符来切割这些内容，从而得到每个账号。
  而在C++的正则中，把这种操作称为Tokenize，用模板类regex_token_iterator<>提供分词迭代器，依旧通过例子来看：

	std::string mail("[email protected],[email protected],[email protected],[email protected]");
	std::regex regToken(",");
	std::sregex_token_iterator itPos(mail.begin(), mail.end(), regToken, -1);
	decltype(itPos) itEnd;
	for (; itPos != itEnd; ++itPos)
	{
    
		std::cout << itPos->str() << std::endl;
	}

  这样，就能通过逗号分割得到所有的邮箱：

123@qq.vip.com
456@gmail.com
789@163.com
abcd@my.com

  sregex_token_iterator是针对string类型的特化，需要注意的是最后一个参数，这个参数可以指定一系列整数值，用来表示你感兴趣的内容，此处的-1表示对于匹配的正则表达式之前的子序列感兴趣；而若指定0，则表示对于匹配的正则表达式感兴趣，这里就会得到“,"；还可对正则表达式进行分组，之后便能输入任意数字对应指定的分组。

3.4 替换（Replace）

  替换，即将正则表达式内容替换为指定内容，regex库用模板函数std::regex_replace提供替换操作。
  现在，给定一个数据为"he…ll…o, worl…d!"， 思考一下，如何去掉其中误敲的“.”？
  有思路了吗？来看看正则的解法：

	char data[] = "he...ll..o, worl..d!";
	std::regex regReplace("\\.");
	// output: hello, world!
	std::cout << std::regex_replace(data, regReplace, "");

  我们还可以使用分组功能：

char data[] = "001-Neo,002-Lucia";
std::regex reg("(\\d+)-(\\w+)");
// output: 001 name=Neo,002 name=Lucia
std::cout << std::regex_replace(data, reg, "$1 name=$2");

  当使用分组功能后，可以通过$N来得到分组内容，这个功能挺有用的。

3.5 异常（Exception）

  正则表达式一写错，就容易导致崩溃，所以针对一些由用户编写正则表达式的情况，需要添加异常处理，防止崩溃。

	try
	{
    
		// 正则表达式错误导致异常,需要捕获,否则会程序会崩溃
		std::regex re("[a-b][a");
	}
	catch (const std::regex_error& e)
	{
    
		std::cout << "regex error caught:" << e.what() << std::endl;
		if (e.code() == std::regex_constants::error_brack)
		{
    
			std::cout << "The code was error!\n";
		}
	}

4 正则表达式综合案例

  下面一个综合案例能够匹配邮箱字符串：

	std::string str = "[email protected], \
	       [email protected], \
           [email protected], \
           [email protected], \
           [email protected] \
           [email protected]";
	std::regex regMail("[\\w.%+-]+@[\\w.-]+(\\.[a-zA-Z]+){1,3}");

	std::sregex_iterator posMail(str.cbegin(), str.cend(), regMail);
	decltype(posMail) endMail;
	for (; posMail != endMail; ++posMail)
	{
    
		std::cout << posMail->str() << std::endl;
	}

  这里使用了另外一种遍历正则查找的方法，这种方法使用regex iterator来迭代，效率要比使用match高。而正则表达式的含义如下：

  最后的输出结果为：

123@qq.vip.com
456@gmail.com
789@163.com.cn.mail
abcd@my.com
haha@163.com.cn.com.cn

  至此，你已经初步学习了C++正则表达式的主要内容，如果喜欢请收藏点赞！

参考文章

https://www.cnblogs.com/coolcpp/p/cpp-regex.html（此文章写的相当精彩，本博客代码大多来自于此，大家可以点击阅读！）
https://www.runoob.com/regexp/regexp-tutorial.html（菜鸟学堂详尽描述了正则表达式的语法，值得一读！）
https://blog.csdn.net/qq_28087491/article/details/107608569
https://blog.csdn.net/feihe0755/article/details/89004783
https://www.codeproject.com/Articles/26285/Quick-Start-for-C-TR-Regular-Expressions