std::regex_match

 

C++

编译器支持

独立和托管

语言

标准库

标准库头文件

命名需求

特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用实用程序库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

执行支持库 (C++26)

技术规范

符号索引

外部库

 

正则表达式库

类

basic_regex (C++11)

sub_match (C++11)

match_results (C++11)

算法

regex_match (C++11)

regex_search (C++11)

regex_replace (C++11)

迭代器

regex_iterator (C++11)

regex_token_iterator (C++11)

异常

regex_error (C++11)

特性

regex_traits (C++11)

常量

syntax_option_type (C++11)

match_flag_type (C++11)

error_type (C++11)

正则表达式语法

修改后的 ECMAScript-262 (C++11)

 

定义在头文件 <regex> 中
template< class BidirIt,           class Alloc, class CharT, class Traits > bool regex_match( BidirIt first, BidirIt last,                   std::match_results<BidirIt, Alloc>& m,                   const std::basic_regex<CharT, Traits>& e,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default );	(1)	(自 C++11 起)
template< class BidirIt,           class CharT, class Traits > bool regex_match( BidirIt first, BidirIt last,                   const std::basic_regex<CharT, Traits>& e,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default );	(2)	(自 C++11 起)
template< class CharT, class Alloc, class Traits > bool regex_match( const CharT* str,                   std::match_results<const CharT*, Alloc>& m,                   const std::basic_regex<CharT, Traits>& e,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default );	(3)	(自 C++11 起)
template< class STraits, class SAlloc,           class Alloc, class CharT, class Traits > bool regex_match( const std::basic_string<CharT, STraits, SAlloc>& s,                   std::match_results<                       typename std::basic_string<CharT, STraits, SAlloc>::                           const_iterator,                       Alloc>& m,                   const std::basic_regex<CharT, Traits>& e,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default );	(4)	(自 C++11 起)
template< class CharT, class Traits > bool regex_match( const CharT* str,                   const std::basic_regex<CharT, Traits>& e,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default );	(5)	(自 C++11 起)
template< class STraits, class SAlloc,           class CharT, class Traits > bool regex_match( const std::basic_string<CharT, STraits, SAlloc>& s,                   const std::basic_regex<CharT, Traits>& e,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default );	(6)	(自 C++11 起)
template< class STraits, class SAlloc,           class Alloc, class CharT, class Traits > bool regex_match( const std::basic_string<CharT, STraits, SAlloc>&&,                   std::match_results<                       typename std::basic_string<CharT, STraits, SAlloc>::                           const_iterator,                       Alloc>&,                   const std::basic_regex<CharT, Traits>&,                   std::regex_constants::match_flag_type flags =                       std::regex_constants::match_default ) = delete;	(7)	(自 C++11 起)

确定正则表达式 e 是否与整个目标字符序列匹配，目标字符序列可以指定为 std::string、C 字符串或迭代器对。

1) 确定正则表达式 e 与整个目标字符序列 [first, last) 之间是否存在匹配，同时考虑 flags 的影响。在确定是否存在匹配时，只考虑与整个字符序列匹配的潜在匹配。匹配结果返回到 m 中。

2) 与上述 (1) 相同，省略匹配结果。

3) 返回 std::regex_match(str, str + std::char_traits<CharT>::length(str), m, e, flags).

4) 返回 std::regex_match(s.begin(), s.end(), m, e, flags).

5) 返回 std::regex_match(str, str + std::char_traits<CharT>::length(str), e, flags).

6) 返回 std::regex_match(s.begin(), s.end(), e, flags).

7) 重载 (4) 被禁止接受临时字符串，否则此函数将使用字符串迭代器填充 match_results m，这些迭代器会立即失效。

请注意，regex_match 只能成功将正则表达式与整个字符序列匹配，而 std::regex_search 可以成功匹配子序列。

参数

first, last	-	作为迭代器给出的目标字符范围，用于应用正则表达式。
m	-	匹配结果
str	-	作为以空字符结尾的 C 样式字符串给出的目标字符串
s	-	作为 std::basic_string 给出的目标字符串
e	-	正则表达式
flags	-	用于确定匹配方式的标志
类型要求
- BidirIt 必须满足 LegacyBidirectionalIterator 的要求。

返回值

如果存在匹配，则返回 true，否则返回 false。在任一情况下，对象 m 都将更新，如下所示：

如果匹配不存在

m.ready() == true

m.empty() == true

m.size() == 0

如果匹配存在

m.ready()	true
m.empty()	false
m.size()	标记的子表达式的数量 加 1，即 1 + e.mark_count()
m.prefix().first	first
m.prefix().second	first
m.prefix().matched	false (匹配前缀为空)
m.suffix().first	last
m.suffix().second	last
m.suffix().matched	false (匹配后缀为空)
m[0].first	first
m[0].second	last
m[0].matched	true (整个序列匹配)
m[n].first	与标记的子表达式 n 匹配的序列的开头，或者如果子表达式没有参与匹配，则为 last
m[n].second	与标记的子表达式 n 匹配的序列的结尾，或者如果子表达式没有参与匹配，则为 last
m[n].matched	如果子表达式 n 参与匹配，则为 true，否则为 false

备注

因为 regex_match 只考虑完全匹配，所以相同的正则表达式在 regex_match 和 std::regex_search 中可能会产生不同的匹配结果。

std::regex re("Get|GetValue");
std::cmatch m;
std::regex_search("GetValue", m, re);  // returns true, and m[0] contains "Get"
std::regex_match ("GetValue", m, re);  // returns true, and m[0] contains "GetValue"
std::regex_search("GetValues", m, re); // returns true, and m[0] contains "Get"
std::regex_match ("GetValues", m, re); // returns false

示例

运行这段代码

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
 
int main()
{
    // Simple regular expression matching
    const std::string fnames[] = {"foo.txt", "bar.txt", "baz.dat", "zoidberg"};
    const std::regex txt_regex("[a-z]+\\.txt");
 
    for (const auto& fname : fnames)
        std::cout << fname << ": " << std::regex_match(fname, txt_regex) << '\n';
 
    // Extraction of a sub-match
    const std::regex base_regex("([a-z]+)\\.txt");
    std::smatch base_match;
 
    for (const auto& fname : fnames)
        if (std::regex_match(fname, base_match, base_regex))
            // The first sub_match is the whole string; the next
            // sub_match is the first parenthesized expression.
            if (base_match.size() == 2)
            {
                std::ssub_match base_sub_match = base_match[1];
                std::string base = base_sub_match.str();
                std::cout << fname << " has a base of " << base << '\n';
            }
 
    // Extraction of several sub-matches
    const std::regex pieces_regex("([a-z]+)\\.([a-z]+)");
    std::smatch pieces_match;
 
    for (const auto& fname : fnames)
        if (std::regex_match(fname, pieces_match, pieces_regex))
        {
            std::cout << fname << '\n';
            for (std::size_t i = 0; i < pieces_match.size(); ++i)
            {
                std::ssub_match sub_match = pieces_match[i];
                std::string piece = sub_match.str();
                std::cout << "  submatch " << i << ": " << piece << '\n';
            }
        }
}

输出

foo.txt: 1
bar.txt: 1
baz.dat: 0
zoidberg: 0
foo.txt has a base of foo
bar.txt has a base of bar
foo.txt
  submatch 0: foo.txt
  submatch 1: foo
  submatch 2: txt
bar.txt
  submatch 0: bar.txt
  submatch 1: bar
  submatch 2: txt
baz.dat
  submatch 0: baz.dat
  submatch 1: baz
  submatch 2: dat

缺陷报告

以下行为改变的缺陷报告已追溯应用到先前发布的 C++ 标准。

DR	应用于	已发布的行为	正确行为
LWG 2329	C++11	接受 basic_string 右值，这很可能导致悬空迭代器	通过删除的重载被拒绝

另请参阅

basic_regex (C++11)	正则表达式对象 (类模板)
match_results (C++11)	识别一个正则表达式匹配，包括所有子表达式匹配 (类模板)
regex_search (C++11)	尝试将正则表达式与字符序列的任何部分匹配 (函数模板)