标准库标头 <regex>

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏(C++20)

语言支持库

概念库(C++20)

诊断库

内存管理库

元编程库(C++11)

通用工具库

容器库

迭代器库

范围库(C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库(C++17)

并发支持库(C++11)

执行控制库(C++26)

技术规范

符号索引

外部库

 

标准库头

语言支持 <cfloat> <climits> <compare>(C++20) <contracts>(C++26) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) 概念 <concepts>(C++20) 诊断 <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) 内存管理 <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) 元编程 <type_traits>(C++11) <ratio>(C++11)

通用工具 <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <stdbit.h>(C++26) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) 容器 <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <hive>(C++26) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> 迭代器 <iterator> 范围 <generator>(C++23) <ranges>(C++20)

算法 <algorithm> <numeric> 字符串 <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> 文本处理 <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    cpp/header#数值库数值 <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <stdckdint.h>(C++26) <valarray> 时间 <chrono>(C++11) <ctime> C 兼容性 <ccomplex>(C++11/17/20*) <ciso646>(C++20 前) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

输入/输出 <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) 并发支持 <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) 执行支持 <execution>(C++17)

 

此标头是文本处理库的一部分。

包含
<compare> (C++20)	三路比较运算符支持
<initializer_list> (C++11)	std::initializer_list 类模板
类
basic_regex (C++11)	正则表达式对象 (类模板)
std::regex	std::basic_regex<char>(typedef)
std::wregex	std::basic_regex<wchar_t>(typedef)
sub_match (C++11)	标识子表达式所匹配的字符序列 (类模板)
std::csub_match	std::sub_match<constchar*>(typedef)
std::wcsub_match	std::sub_match<constwchar_t*>(typedef)
std::ssub_match	std::sub_match<std::string::const_iterator>(typedef)
std::wssub_match	std::sub_match<std::wstring::const_iterator>(typedef)
match_results (C++11)	标识一个正则表达式匹配，包含所有子表达式匹配 (类模板)
std::cmatch	std::match_results<constchar*>(typedef)
std::wcmatch	std::match_results<constwchar_t*>(typedef)
std::smatch	std::match_results<std::string::const_iterator>(typedef)
std::wsmatch	std::match_results<std::wstring::const_iterator>(typedef)
regex_iterator (C++11)	迭代一个字符序列中的所有正则表达式匹配 (类模板)
std::cregex_iterator	std::regex_iterator<constchar*>(typedef)
std::wcregex_iterator	std::regex_iterator<constwchar_t*>(typedef)
std::sregex_iterator	std::regex_iterator<std::string::const_iterator>(typedef)
std::wsregex_iterator	std::regex_iterator<std::wstring::const_iterator>(typedef)
regex_token_iterator (C++11)	迭代给定字符串中的所有正则表达式匹配中的指定子表达式，或迭代未匹配的子字符串 (类模板)
std::cregex_token_iterator	std::regex_token_iterator<constchar*>(typedef)
std::wcregex_token_iterator	std::regex_token_iterator<constwchar_t*>(typedef)
std::sregex_token_iterator	std::regex_token_iterator<std::string::const_iterator>(typedef)
std::wsregex_token_iterator	std::regex_token_iterator<std::wstring::const_iterator>(typedef)
regex_error (C++11)	报告正则表达式库生成的错误 (类)
regex_traits (C++11)	提供正则表达式库所需的关于字符类型的元信息 (类模板)
regex 常量类型
在命名空间 std::regex_constants 定义
syntax_option_type (C++11)	控制正则表达式行为的通用选项 (typedef)
match_flag_type (C++11)	特定于匹配的选项 (typedef)
error_type (C++11)	描述不同类型的匹配错误 (typedef)
函数
算法
regex_match (C++11)	尝试匹配一个正则表达式到整个字符序列 (函数模板)
regex_search (C++11)	尝试匹配一个正则表达式到字符序列的任何部分 (函数模板)
regex_replace (C++11)	以格式化的替换文本来替换正则表达式匹配的出现位置 (函数模板)
非成员操作
std::swap(std::basic_regex) (C++11)	特化 std::swap 算法 (函数模板)
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20 移除)(C++20 移除)(C++20 移除)(C++20 移除)(C++20 移除)(C++20)	比较一个 sub_match 与另一 sub_match 、字符串或字符 (函数模板)
operator<<	输出匹配的字符子序列 (函数模板)
operator==operator!= (C++20 移除)	以字典序比较两个匹配结果的值 (函数模板)
std::swap(std::match_results) (C++11)	特化 std::swap 算法 (函数模板)
范围访问
begincbegin (C++11)(C++14)	返回指向容器或数组起始的迭代器 (函数模板)
endcend (C++11)(C++14)	返回指向容器或数组结尾的迭代器 (函数模板)
rbegincrbegin (C++14)	返回指向一个容器或数组的逆向迭代器 (函数模板)
rendcrend (C++14)	返回容器或数组的逆向尾迭代器 (函数模板)
sizessize (C++17)(C++20)	返回容器或数组的大小 (函数模板)
empty (C++17)	检查容器是否为空 (函数模板)
data (C++17)	获得指向底层数组的指针 (函数模板)

概要

#include <compare>#include <initializer_list>   namespace std {// regex 常量namespace regex_constants {using syntax_option_type =/*T1*/;using match_flag_type =/*T2*/;using error_type =/*T3*/;}   // 类 regex_­errorclass regex_error;   // 类模板 regex_traitstemplate<class CharT>struct regex_traits;   // 类模板 basic_­regextemplate<class CharT, class Traits = regex_traits<CharT>>class basic_regex;   using regex = basic_regex<char>;using wregex = basic_regex<wchar_t>;   // basic_­regex 交换template<class CharT, class Traits>void swap(basic_regex<CharT, Traits>& e1, basic_regex<CharT, Traits>& e2);   // 类模板 sub_­matchtemplate<class BiIt>class sub_match;   using csub_match = sub_match<constchar*>;using wcsub_match = sub_match<constwchar_t*>;using ssub_match = sub_match<string::const_iterator>;using wssub_match = sub_match<wstring::const_iterator>;   // sub_­match 非成员运算符template<class BiIt>bool operator==(const sub_match<BiIt>& lhs, const sub_match<BiIt>& rhs);template<class BiIt>auto operator<=>(const sub_match<BiIt>& lhs, const sub_match<BiIt>& rhs);   template<class BiIt, class ST, class SA>bool operator==(const sub_match<BiIt>& lhs, const basic_string<typename iterator_traits<BiIt>::value_type, ST, SA>& rhs);template<class BiIt, class ST, class SA>auto operator<=>(const sub_match<BiIt>& lhs, const basic_string<typename iterator_traits<BiIt>::value_type, ST, SA>& rhs);   template<class BiIt>bool operator==(const sub_match<BiIt>& lhs, consttypename iterator_traits<BiIt>::value_type* rhs);template<class BiIt>auto operator<=>(const sub_match<BiIt>& lhs, consttypename iterator_traits<BiIt>::value_type* rhs);   template<class BiIt>bool operator==(const sub_match<BiIt>& lhs, consttypename iterator_traits<BiIt>::value_type& rhs);template<class BiIt>auto operator<=>(const sub_match<BiIt>& lhs, consttypename iterator_traits<BiIt>::value_type& rhs);   template<class CharT, class ST, class BiIt> basic_ostream<CharT, ST>& operator<<(basic_ostream<CharT, ST>& os, const sub_match<BiIt>& m);   // 类模板 match_­resultstemplate<class BiIt, class Allocator = allocator<sub_match<BiIt>>>class match_results;   using cmatch = match_results<constchar*>;using wcmatch = match_results<constwchar_t*>;using smatch = match_results<string::const_iterator>;using wsmatch = match_results<wstring::const_iterator>;   // match_­results 比较template<class BiIt, class Allocator>bool operator==(const match_results<BiIt, Allocator>& m1, const match_results<BiIt, Allocator>& m2);   // match_­results 交换template<class BiIt, class Allocator>void swap(match_results<BiIt, Allocator>& m1, match_results<BiIt, Allocator>& m2);   // 函数模板 regex_­matchtemplate<class BiIt, class Allocator, class CharT, class Traits>bool regex_match(BiIt first, BiIt last, match_results<BiIt, Allocator>& m, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class BiIt, class CharT, class Traits>bool regex_match(BiIt first, BiIt last, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class CharT, class Allocator, class Traits>bool regex_match(const CharT* str, match_results<const CharT*, Allocator>& m, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class ST, class SA, class Allocator, class CharT, class Traits>bool regex_match(const basic_string<CharT, ST, SA>& s, match_results<typename basic_string<CharT, ST, SA>::const_iterator, Allocator>& m, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class ST, class SA, class Allocator, class CharT, class Traits>bool regex_match(const basic_string<CharT, ST, SA>&&, match_results<typename basic_string<CharT, ST, SA>::const_iterator, Allocator>&, const basic_regex<CharT, Traits>&, regex_constants::match_flag_type= regex_constants::match_default)= delete;template<class CharT, class Traits>bool regex_match(const CharT* str, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class ST, class SA, class CharT, class Traits>bool regex_match(const basic_string<CharT, ST, SA>& s, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);   // 函数模板 regex_­searchtemplate<class BiIt, class Allocator, class CharT, class Traits>bool regex_search(BiIt first, BiIt last, match_results<BiIt, Allocator>& m, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class BiIt, class CharT, class Traits>bool regex_search(BiItfirst, BiIt last, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class CharT, class Allocator, class Traits>bool regex_search(const CharT* str, match_results<const CharT*, Allocator>& m, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class CharT, class Traits>bool regex_search(const CharT* str, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class ST, class SA, class CharT, class Traits>bool regex_search(const basic_string<CharT, ST, SA>& s, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class ST, class SA, class Allocator, class CharT, class Traits>bool regex_search(const basic_string<CharT, ST, SA>& s, match_results<typename basic_string<CharT, ST, SA>::const_iterator, Allocator>& m, const basic_regex<CharT, Traits>& e, regex_constants::match_flag_type flags = regex_constants::match_default);template<class ST, class SA, class Allocator, class CharT, class Traits>bool regex_search(const basic_string<CharT, ST, SA>&&, match_results<typename basic_string<CharT, ST, SA>::const_iterator, Allocator>&, const basic_regex<CharT, Traits>&, regex_constants::match_flag_type= regex_constants::match_default)= delete;   // 函数模板 regex_­replacetemplate<class OutputIt, class BiIt, class Traits, class CharT, class ST, class SA> OutputIt regex_replace(OutputIt out, BiIt first, BiIt last, const basic_regex<CharT, Traits>& e, const basic_string<CharT, ST, SA>& fmt, regex_constants::match_flag_type flags = regex_constants::match_default);template<class OutputIt, class BiIt, class Traits, class CharT> OutputIt regex_replace(OutputIt out, BiIt first, BiIt last, const basic_regex<CharT, Traits>& e, const CharT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default);template<class Traits, class CharT, class ST, class SA, class FST, class FSA> basic_string<CharT, ST, SA> regex_replace(const basic_string<CharT, ST, SA>& s, const basic_regex<CharT, Traits>& e, const basic_string<CharT, FST, FSA>& fmt, regex_constants::match_flag_type flags = regex_constants::match_default);template<class Traits, class CharT, class ST, class SA> basic_string<CharT, ST, SA> regex_replace(const basic_string<CharT, ST, SA>& s, const basic_regex<CharT, Traits>& e, const CharT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default);template<class Traits, class CharT, class ST, class SA> basic_string<CharT> regex_replace(const CharT* s, const basic_regex<CharT, Traits>& e, const basic_string<CharT, ST, SA>& fmt, regex_constants::match_flag_type flags = regex_constants::match_default);template<class Traits, class CharT> basic_string<CharT> regex_replace(const CharT* s, const basic_regex<CharT, Traits>& e, const CharT* fmt, regex_constants::match_flag_type flags = regex_constants::match_default);   // 类模板 regex_­iteratortemplate<class BiIt, class CharT =typename iterator_traits<BiIt>::value_type, class Traits = regex_traits<CharT>>class regex_iterator;   using cregex_iterator = regex_iterator<constchar*>;using wcregex_iterator = regex_iterator<constwchar_t*>;using sregex_iterator = regex_iterator<string::const_iterator>;using wsregex_iterator = regex_iterator<wstring::const_iterator>;   // 类模板 regex_­token_­iteratortemplate<class BiIt, class CharT =typename iterator_traits<BiIt>::value_type, class Traits = regex_traits<CharT>>class regex_token_iterator;   using cregex_token_iterator = regex_token_iterator<constchar*>;using wcregex_token_iterator = regex_token_iterator<constwchar_t*>;using sregex_token_iterator = regex_token_iterator<string::const_iterator>;using wsregex_token_iterator = regex_token_iterator<wstring::const_iterator>;   namespace pmr {template<class BiIt>using match_results =std::match_results<BiIt, polymorphic_allocator<sub_match<BiIt>>>;   using cmatch = match_results<constchar*>;using wcmatch = match_results<constwchar_t*>;using smatch = match_results<string::const_iterator>;using wsmatch = match_results<wstring::const_iterator>;}}

位掩码类型 std::regex_constants::syntax_option_type

namespace std::regex_constants{using syntax_option_type =/*T1*/;inlineconstexpr syntax_option_type icase =/* 未指明 */;inlineconstexpr syntax_option_type nosubs =/* 未指明 */;inlineconstexpr syntax_option_type optimize =/* 未指明 */;inlineconstexpr syntax_option_type collate =/* 未指明 */;inlineconstexpr syntax_option_type ECMAScript =/* 未指明 */;inlineconstexpr syntax_option_type basic =/* 未指明 */;inlineconstexpr syntax_option_type extended =/* 未指明 */;inlineconstexpr syntax_option_type awk =/* 未指明 */;inlineconstexpr syntax_option_type grep =/* 未指明 */;inlineconstexpr syntax_option_type egrep =/* 未指明 */;inlineconstexpr syntax_option_type multiline =/* 未指明 */;}

位掩码类型 std::regex_constants::match_flag_type

namespace std::regex_constants{using match_flag_type =/*T2*/;inlineconstexpr match_flag_type match_­default={};inlineconstexpr match_flag_type match_­not_­bol =/* 未指明 */;inlineconstexpr match_flag_type match_­not_­eol =/* 未指明 */;inlineconstexpr match_flag_type match_­not_­bow =/* 未指明 */;inlineconstexpr match_flag_type match_­not_­eow =/* 未指明 */;inlineconstexpr match_flag_type match_­any =/* 未指明 */;inlineconstexpr match_flag_type match_­not_­null =/* 未指明 */;inlineconstexpr match_flag_type match_­continuous =/* 未指明 */;inlineconstexpr match_flag_type match_­prev_­avail =/* 未指明 */;inlineconstexpr match_flag_type format_­default={};inlineconstexpr match_flag_type format_­sed =/* 未指明 */;inlineconstexpr match_flag_type format_­no_­copy =/* 未指明 */;inlineconstexpr match_flag_type format_­first_­only =/* 未指明 */;}

被枚举类型 std::regex_constants::error_type

namespace std::regex_constants{using error_type =/*T3*/;inlineconstexpr error_type error_collate =/* 未指明 */;inlineconstexpr error_type error_ctype =/* 未指明 */;inlineconstexpr error_type error_escape =/* 未指明 */;inlineconstexpr error_type error_backref =/* 未指明 */;inlineconstexpr error_type error_brack =/* 未指明 */;inlineconstexpr error_type error_paren =/* 未指明 */;inlineconstexpr error_type error_brace =/* 未指明 */;inlineconstexpr error_type error_badbrace =/* 未指明 */;inlineconstexpr error_type error_range =/* 未指明 */;inlineconstexpr error_type error_space =/* 未指明 */;inlineconstexpr error_type error_badrepeat =/* 未指明 */;inlineconstexpr error_type error_complexity =/* 未指明 */;inlineconstexpr error_type error_stack =/* 未指明 */;}

类 std::regex_error

namespace std {class regex_error :public runtime_error {public:explicit regex_error(regex_constants::error_type ecode); regex_constants::error_type code()const;};}

类模板 std::regex_traits

namespace std {template<class CharT>struct regex_traits {using char_type = CharT;using string_type = basic_string<char_type>;using locale_type = locale;using char_class_type =/* 位掩码类型 */;   regex_traits();static size_t length(const char_type* p); CharT translate(CharT c)const; CharT translate_nocase(CharT c)const;template<class ForwardIt> string_type transform(ForwardIt first, ForwardIt last)const;template<class ForwardIt> string_type transform_primary(ForwardIt first, ForwardIt last)const;template<class ForwardIt> string_type lookup_collatename(ForwardIt first, ForwardIt last)const;template<class ForwardIt> char_class_type lookup_classname(ForwardIt first, ForwardIt last, bool icase =false)const;bool isctype(CharT c, char_class_type f)const;int value(CharT ch, int radix)const; locale_type imbue(locale_type l); locale_type getloc()const;};}

类模板 std::basic_regex

namespace std {template<class CharT, class Traits = regex_traits<CharT>>class basic_regex {public:// 类型using value_type = CharT;using Traits_type = Traits;using string_type =typename Traits::string_type;using flag_type = regex_constants::syntax_option_type;using locale_type =typename Traits::locale_type;   // 常量staticconstexpr flag_type icase = regex_constants::icase;staticconstexpr flag_type nosubs = regex_constants::nosubs;staticconstexpr flag_type optimize = regex_constants::optimize;staticconstexpr flag_type collate = regex_constants::collate;staticconstexpr flag_type ECMAScript = regex_constants::ECMAScript;staticconstexpr flag_type basic = regex_constants::basic;staticconstexpr flag_type extended = regex_constants::extended;staticconstexpr flag_type awk = regex_constants::awk;staticconstexpr flag_type grep = regex_constants::grep;staticconstexpr flag_type egrep = regex_constants::egrep;staticconstexpr flag_type multiline = regex_constants::multiline;   // 构造/复制/销毁 basic_regex();explicit basic_regex(const CharT* p, flag_type f = regex_constants::ECMAScript); basic_regex(const CharT* p, size_t len, flag_type f = regex_constants::ECMAScript); basic_regex(const basic_regex&); basic_regex(basic_regex&&)noexcept;template<class ST, class SA>explicit basic_regex(const basic_string<CharT, ST, SA>& s, flag_type f = regex_constants::ECMAScript);template<class ForwardIt> basic_regex(ForwardIt first, ForwardIt last, flag_type f = regex_constants::ECMAScript); basic_regex(initializer_list<CharT> il, flag_type f = regex_constants::ECMAScript);   ~basic_regex();   // 赋值 basic_regex& operator=(const basic_regex& e); basic_regex& operator=(basic_regex&& e)noexcept; basic_regex& operator=(const CharT* p); basic_regex& operator=(initializer_list<CharT> il);template<class ST, class SA> basic_regex& operator=(const basic_string<CharT, ST, SA>& s);   basic_regex& assign(const basic_regex& e); basic_regex& assign(basic_regex&& e)noexcept; basic_regex& assign(const CharT* p, flag_type f = regex_constants::ECMAScript); basic_regex& assign(const CharT* p, size_t len, flag_type f = regex_constants::ECMAScript);template<class ST, class SA> basic_regex& assign(const basic_string<CharT, ST, SA>& s, flag_type f = regex_constants::ECMAScript);template<class InputIt> basic_regex& assign(InputIt first, InputIt last, flag_type f = regex_constants::ECMAScript); basic_regex& assign(initializer_list<CharT>, flag_type f = regex_constants::ECMAScript);   // const 操作unsigned mark_count()const; flag_type flags()const;   // 本地环境 locale_type imbue(locale_type loc); locale_type getloc()const;   // 交换void swap(basic_regex&);};   template<class ForwardIt> basic_regex(ForwardIt, ForwardIt, regex_constants::syntax_option_type= regex_constants::ECMAScript)-> basic_regex<typename iterator_traits<ForwardIt>::value_type>;}

类模板 std::sub_match

namespace std {template<class BiIt>class sub_match :public pair<BiIt, BiIt>{public:using value_type =typename iterator_traits<BiIt>::value_type;using difference_type =typename iterator_traits<BiIt>::difference_type;using iterator = BiIt;using string_type = basic_string<value_type>;   bool matched;   constexpr sub_match();   difference_type length()const; operator string_type()const; string_type str()const;   int compare(const sub_match& s)const;int compare(const string_type& s)const;int compare(const value_type* s)const;   void swap(sub_match& s)noexcept(/* 见描述 */);};}

类模板 std::match_results

namespace std {template<class BiIt, class Allocator = allocator<sub_match<BiIt>>>class match_results {public:using value_type = sub_match<BiIt>;using const_reference =const value_type&;using reference = value_type&;using const_iterator =/* 由实现定义 */;using iterator = const_iterator;using difference_type =typename iterator_traits<BiIt>::difference_type;using size_type =typename allocator_traits<Allocator>::size_type;using allocator_type = Allocator;using char_type =typename iterator_traits<BiIt>::value_type;using string_type = basic_string<char_type>;   // 构造/复制/销毁 match_results(): match_results(Allocator()){}explicit match_results(const Allocator& a); match_results(const match_results& m); match_results(const match_results& m, const Allocator& a); match_results(match_results&& m)noexcept; match_results(match_results&& m, const Allocator& a); match_results& operator=(const match_results& m); match_results& operator=(match_results&& m); ~match_results();   // 状态bool ready()const;   // 大小 size_type size()const; size_type max_size()const;bool empty()const;   // 元素访问 difference_type length(size_type sub =0)const; difference_type position(size_type sub =0)const; string_type str(size_type sub =0)const; const_reference operator[](size_type n)const;   const_reference prefix()const; const_reference suffix()const; const_iterator begin()const; const_iterator end()const; const_iterator cbegin()const; const_iterator cend()const;   // 格式template<class OutputIt> OutputIt format(OutputIt out, const char_type* fmt_first, const char_type* fmt_last, regex_constants::match_flag_type flags = regex_constants::format_default)const;template<class OutputIt, class ST, class SA> OutputIt format(OutputIt out, const basic_string<char_type, ST, SA>& fmt, regex_constants::match_flag_type flags = regex_constants::format_default)const;template<class ST, class SA> basic_string<char_type, ST, SA> format(const basic_string<char_type, ST, SA>& fmt, regex_constants::match_flag_type flags = regex_constants::format_default)const; string_type format(const char_type* fmt, regex_constants::match_flag_type flags = regex_constants::format_default)const;   // 分配器 allocator_type get_allocator()const;   // 交换void swap(match_results& that);};}