C++

参考

<regex>

function template
<regex>

std::regex_match

C-strings (1)
template <class charT, class traits>  bool regex_match (const charT* s, const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
strings (2)
template <class ST, class SA, char charT, class traits>  bool regex_match (const basic_string<charT,ST,SA>& s,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
ranges (3)
template <class BidirectionalIterator, class charT, class traits>  bool regex_match (BidirectionalIterator first, BidirectionalIterator last,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
with match_results (4,5,6)
template <class charT, class Alloc, class traits>  bool regex_match (const charT* s, match_results<const charT*, Alloc>& m,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);template <class ST, class SA, class Alloc, class charT, class traits>  bool regex_match (const basic_string<charT,ST,SA>& s,          match_results<typename basic_string<charT,ST,SA>::const_iterator,Alloc>& m,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);template <class BidirectionalIterator, class Alloc, class charT, class traits>  bool regex_match (BidirectionalIterator first, BidirectionalIterator last,          match_results<BidirectionalIterator, Alloc>& m,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
C-strings (1)
template <class charT, class traits>  bool regex_match (const charT* s, const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
strings (2)
template <class ST, class SA, char charT, class traits>  bool regex_match (const basic_string<charT,ST,SA>& s,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
ranges (3)
template <class BidirectionalIterator, class charT, class traits>  bool regex_match (BidirectionalIterator first, BidirectionalIterator last,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
with match_results (4,5,6)
template <class charT, class Alloc, class traits>  bool regex_match (const charT* s, match_results<const charT*, Alloc>& m,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);template <class ST, class SA, class Alloc, class charT, class traits>  bool regex_match (const basic_string<charT,ST,SA>& s,          match_results<typename basic_string<charT,ST,SA>::const_iterator,Alloc>& m,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);template <class BidirectionalIterator, class Alloc, class charT, class traits>  bool regex_match (BidirectionalIterator first, BidirectionalIterator last,          match_results<BidirectionalIterator, Alloc>& m,          const basic_regex<charT,traits>& rgx,          regex_constants::match_flag_type flags = regex_constants::match_default);
moving string (deleted) (7)
template <class ST, class SA, class Alloc, class charT, class traits>  bool regex_match (const basic_string<charT,ST,SA>&&,          match_results<typename basic_string<charT,ST,SA>::const_iterator,Alloc>&,          const basic_regex<charT,traits>&,          regex_constants::match_flag_type=regex_constants::match_default) = delete;
Match sequence
返回正则表达式rgx是否与目标序列匹配。目标序列根据所使用的版本，可以是s，也可以是first和last之间的字符序列。

版本4、5和6分别与1、2和3相同，只是它们接受一个match_results类型的对象作为参数，该对象被填充了匹配结果的信息。

删除带有移动字符串 (7)的签名会阻止使用临时string对象进行构造。

可选参数flags允许指定匹配表达式的选项。

为了使此函数返回true（即，在匹配前后没有任何额外的字符），整个目标序列必须与正则表达式匹配。对于一个在匹配仅是序列的一部分时返回的函数，请参阅 regex_search。truewhen the match is only part of the sequence, see regex_search.

参数

s
一个包含目标序列（主题）的字符串，正则表达式将与之匹配。
rgx
一个basic_regex对象（模式）进行匹配。
标志
用于控制rgx如何匹配的标志。
可以将一个或多个这些常量组合（使用按位或运算符 |）形成一个类型为regex_constants::match_flag_type:
flag*effects on match说明
match_defaultDefault默认匹配行为。
此常量的值为零**。
match_not_bolNot Beginning-Of-Line第一个字符不被视为行首（"^"不匹配）。
match_not_eolNot End-Of-Line最后一个字符不被视为行尾（"$"不匹配）。
match_not_bowNot Beginning-Of-Word转义序列"\b"不匹配为单词开头。
match_not_eowNot End-Of-Word转义序列"\b"不匹配为单词结尾。
match_anyAny match如果可能存在多个匹配，则任何一个匹配都可以接受。
match_not_nullNot null空序列不匹配。
match_continuousContinuous表达式必须匹配从第一个字符开始的子序列。
子序列必须从第一个字符开始才能匹配。
match_prev_availPrevious Available第一个字符之前存在一个或多个字符。（match_not_bol和match_not_bow被忽略）
format_defaultDefaultSame asmatch_default.
此常量的值为零**。
format_sed无此函数忽略。
有关更多信息，请参阅 regex_constants。
format_no_copy
format_first_only
* 这些位掩码标志名称可在std::regex_constants命名空间中使用（有关更多详细信息，请参阅 regex_constants）。
** 值为零的常量在设置了其他标志时会被忽略。
match_flag_type是可在std::regex_constants命名空间内定义。
first, last
Bidirectional iterators 指向用作匹配目标序列的字符范围的起始和结束位置。使用的范围是[first,last)，其中包括first和last之间的所有字符，包括first指向的字符，但不包括last指向的字符。
函数模板类型可以是任何指向字符的双向迭代器。
m
一个match_results类型的对象（例如cmatch或smatch），该函数将用匹配结果和任何找到的子匹配的信息来填充它。
match_results对象的类型应使用适当的迭代器类型进行实例化，以迭代遍历字符序列s（或begin和end之间的字符）。

返回值

true如果rgx与目标序列匹配。false否则为 false。

示例

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
39
40
41
42
43
44
 
// regex_match example
#include <iostream>
#include <string>
#include <regex>

int main ()
{

  if (std::regex_match ("subject", std::regex("(sub)(.*)") ))
    std::cout << "string literal matched\n";

  const char cstr[] = "subject";
  std::string s ("subject");
  std::regex e ("(sub)(.*)");

  if (std::regex_match (s,e))
    std::cout << "string object matched\n";

  if ( std::regex_match ( s.begin(), s.end(), e ) )
    std::cout << "range matched\n";

  std::cmatch cm;    // same as std::match_results<const char*> cm;
  std::regex_match (cstr,cm,e);
  std::cout << "string literal with " << cm.size() << " matches\n";

  std::smatch sm;    // same as std::match_results<string::const_iterator> sm;
  std::regex_match (s,sm,e);
  std::cout << "string object with " << sm.size() << " matches\n";

  std::regex_match ( s.cbegin(), s.cend(), sm, e);
  std::cout << "range with " << sm.size() << " matches\n";

  // using explicit flags:
  std::regex_match ( cstr, cm, e, std::regex_constants::match_default );

  std::cout << "the matches were: ";
  for (unsigned i=0; i<cm.size(); ++i) {
    std::cout << "[" << cm[i] << "] ";
  }

  std::cout << std::endl;

  return 0;
}

输出
string literal matched
string object matched
range matched
string literal with 3 matches
string object with 3 matches
range with 3 matches
the matches were: [subject] [sub] [ject]


另见

regex_search
搜索序列 (函数模板)
regex_replace
替换匹配的序列 (函数模板)
regex_iterator
正则表达式迭代器 (类模板)
match_results
匹配结果 (类模板)