Working Draft, Standard for Programming Language C++ (N4713, 2017 year) - page 40
template<class BiIter, class ST, class SA>
bool operator==(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>&
rhs);
template<class BiIter, class ST, class SA>
bool operator!=(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>&
rhs);
template<class BiIter, class ST, class SA>
bool operator<(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>&
rhs);
template<class BiIter, class ST, class SA>
bool operator>(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>&
rhs);
template<class BiIter, class ST, class SA>
bool operator>=(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>&
rhs);
template<class BiIter, class ST, class SA>
bool operator<=(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>&
rhs);
template<class BiIter>
bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator==(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
template<class BiIter>
bool operator!=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
template<class BiIter>
bool operator<(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
template<class BiIter>
bool operator>(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
template<class BiIter>
bool operator>=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
template<class BiIter>
bool operator<=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
§ 31.4
1162
template<class BiIter>
bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
template<class BiIter>
bool operator==(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
template<class BiIter>
bool operator!=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
template<class BiIter>
bool operator<(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
template<class BiIter>
bool operator>(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
template<class BiIter>
bool operator>=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
template<class BiIter>
bool operator<=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
template<class charT, class ST, class BiIter>
basic_ostream<charT, ST>&
operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
// 31.10, class template match_results
template<class BidirectionalIterator,
class Allocator = allocator<sub_match<BidirectionalIterator>>>
class match_results;
using cmatch
= match_results<const char*>;
using wcmatch = match_results<const wchar_t*>;
using smatch
= match_results<string::const_iterator>;
using wsmatch = match_results<wstring::const_iterator>;
// match_results comparisons
template<class BidirectionalIterator, class Allocator>
bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
template<class BidirectionalIterator, class Allocator>
bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
// 31.10.7, match_results swap
template<class BidirectionalIterator, class Allocator>
void swap(match_results<BidirectionalIterator, Allocator>& m1,
match_results<BidirectionalIterator, Allocator>& m2);
§
31.4
1163
// 31.11.2, function template regex_match
template<class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template<class BidirectionalIterator, class charT, class traits>
bool regex_match(BidirectionalIterator first, BidirectionalIterator 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);
// 31.11.3, function template regex_search
template<class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
template<class BidirectionalIterator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator 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);
§
31.4
1164
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;
// 31.11.4, function template regex_replace
template<class OutputIterator, class BidirectionalIterator,
class traits, class charT, class ST, class SA>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator 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 OutputIterator, class BidirectionalIterator, class traits, class charT>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator 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);
// 31.12.1, class template regex_iterator
template<class BidirectionalIterator,
class charT = typename iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT>>
class regex_iterator;
using cregex_iterator
= regex_iterator<const char*>;
using wcregex_iterator = regex_iterator<const wchar_t*>;
using sregex_iterator
= regex_iterator<string::const_iterator>;
using wsregex_iterator = regex_iterator<wstring::const_iterator>;
// 31.12.2, class template regex_token_iterator
template<class BidirectionalIterator,
class charT = typename iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT>>
§
31.4
1165
class regex_token_iterator;
using cregex_token_iterator
= regex_token_iterator<const char*>;
using wcregex_token_iterator = regex_token_iterator<const wchar_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 BidirectionalIterator>
using match_results =
std::match_results<BidirectionalIterator,
polymorphic_allocator<sub_match<BidirectionalIterator>>>;
using cmatch
= match_results<const char*>;
using wcmatch = match_results<const wchar_t*>;
using smatch
= match_results<string::const_iterator>;
using wsmatch = match_results<wstring::const_iterator>;
}
}
31.5
Namespace std::regex_constants
[re.const]
1
The namespace std::regex_constants holds symbolic constants used by the regular expression library.
This namespace provides three types, syntax_option_type, match_flag_type, and error_type, along with
several constants of these types.
31.5.1
Bitmask type syntax_option_type
[re.synopt]
namespace std::regex_constants {
using syntax_option_type = T1 ;
inline constexpr syntax_option_type icase = unspecified ;
inline constexpr syntax_option_type nosubs = unspecified ;
inline constexpr syntax_option_type optimize = unspecified ;
inline constexpr syntax_option_type collate = unspecified ;
inline constexpr syntax_option_type ECMAScript = unspecified ;
inline constexpr syntax_option_type basic = unspecified ;
inline constexpr syntax_option_type extended = unspecified ;
inline constexpr syntax_option_type awk = unspecified ;
inline constexpr syntax_option_type grep = unspecified ;
inline constexpr syntax_option_type egrep = unspecified ;
inline constexpr syntax_option_type multiline = unspecified ;
}
1
The type syntax_option_type is an implementation-defined bitmask type (20.4.2.1.4). Setting its elements
has the effects listed in Table 130. A valid value of type syntax_option_type shall have at most one of the
grammar elements ECMAScript, basic, extended, awk, grep, egrep, set. If no grammar element is set, the
default grammar is ECMAScript.
31.5.2
Bitmask type match_flag_type
[re.matchflag]
namespace std::regex_constants {
using match_flag_type = T2 ;
inline constexpr match_flag_type match_default = {};
inline constexpr match_flag_type match_not_bol = unspecified ;
inline constexpr match_flag_type match_not_eol = unspecified ;
inline constexpr match_flag_type match_not_bow = unspecified ;
inline constexpr match_flag_type match_not_eow = unspecified ;
inline constexpr match_flag_type match_any = unspecified ;
inline constexpr match_flag_type match_not_null = unspecified ;
inline constexpr match_flag_type match_continuous = unspecified ;
inline constexpr match_flag_type match_prev_avail = unspecified ;
inline constexpr match_flag_type format_default = {};
inline constexpr match_flag_type format_sed = unspecified ;
inline constexpr match_flag_type format_no_copy = unspecified ;
inline constexpr match_flag_type format_first_only = unspecified ;
}
§ 31.5.2
1166
Table 130 — syntax_option_type effects
Element
Effect(s) if set
icase
Specifies that matching of regular expressions against a character container
sequence shall be performed without regard to case.
nosubs
Specifies that no sub-expressions shall be considered to be marked, so that
when a regular expression is matched against a character container sequence,
no sub-expression matches shall be stored in the supplied match_results
structure.
optimize
Specifies that the regular expression engine should pay more attention to
the speed with which regular expressions are matched, and less to the speed
with which regular expression objects are constructed. Otherwise it has no
detectable effect on the program output.
collate
Specifies that character ranges of the form "[a-b]" shall be locale sensitive.
ECMAScript
Specifies that the grammar recognized by the regular expression engine shall
be that used by ECMAScript in ECMA-262, as modified in 31.13.
basic
Specifies that the grammar recognized by the regular expression engine shall
be that used by basic regular expressions in POSIX, Base Definitions and
Headers, Section 9, Regular Expressions.
extended
Specifies that the grammar recognized by the regular expression engine shall
be that used by extended regular expressions in POSIX, Base Definitions
and Headers, Section 9, Regular Expressions.
awk
Specifies that the grammar recognized by the regular expression engine shall
be that used by the utility awk in POSIX.
grep
Specifies that the grammar recognized by the regular expression engine shall
be that used by the utility grep in POSIX.
egrep
Specifies that the grammar recognized by the regular expression engine shall
be that used by the utility grep when given the -E option in POSIX.
multiline
Specifies that ˆ shall match the beginning of a line and $ shall match the
end of a line, if the ECMAScript engine is selected.
1
The type match_flag_type is an implementation-defined bitmask type (20.4.2.1.4). The constants of
that type, except for match_default and format_default, are bitmask elements. The match_default
and format_default constants are empty bitmasks. Matching a regular expression against a sequence of
characters [first, last) proceeds according to the rules of the grammar specified for the regular expression
object, modified according to the effects listed in Table 131 for any bitmask elements set.
Table 131 — regex_constants::match_flag_type effects when
obtaining a match against a character container sequence [first,
last).
Element
Effect(s) if set
match_not_bol
The first character in the sequence [first, last) shall be treated as
though it is not at the beginning of a line, so the character ^ in the regular
expression shall not match [first, first).
match_not_eol
The last character in the sequence [first, last) shall be treated as though
it is not at the end of a line, so the character "$" in the regular expression
shall not match [last, last).
match_not_bow
The expression "\\b" shall not match the sub-sequence [first, first).
match_not_eow
The expression "\\b" shall not match the sub-sequence [last, last).
match_any
If more than one match is possible then any match is an acceptable result.
match_not_null
The expression shall not match an empty sequence.
match_continuous
The expression shall only match a sub-sequence that begins at first.
match_prev_avail
--first is a valid iterator position. When this flag is set the flags match_-
not_bol and match_not_bow shall be ignored by the regular expression
algorithms (31.11) and iterators (31.12).
§ 31.5.2
1167
Table 131 — regex_constants::match_flag_type effects when
obtaining a match against a character container sequence [first,
last). (continued)
Element
Effect(s) if set
format_default
When a regular expression match is to be replaced by a new string, the new
string shall be constructed using the rules used by the ECMAScript replace
function in ECMA-262, part 15.5.4.11 String.prototype.replace. In addition,
during search and replace operations all non-overlapping occurrences of the
regular expression shall be located and replaced, and sections of the input
that did not match the expression shall be copied unchanged to the output
string.
format_sed
When a regular expression match is to be replaced by a new string, the new
string shall be constructed using the rules used by the sed utility in POSIX.
format_no_copy
During a search and replace operation, sections of the character container
sequence being searched that do not match the regular expression shall not
be copied to the output string.
format_first_only When specified during a search and replace operation, only the first occur-
rence of the regular expression shall be replaced.
31.5.3
Implementation-defined error_type
[re.err]
namespace std::regex_constants {
using error_type = T3 ;
inline constexpr error_type error_collate = unspecified ;
inline constexpr error_type error_ctype = unspecified ;
inline constexpr error_type error_escape = unspecified ;
inline constexpr error_type error_backref = unspecified ;
inline constexpr error_type error_brack = unspecified ;
inline constexpr error_type error_paren = unspecified ;
inline constexpr error_type error_brace = unspecified ;
inline constexpr error_type error_badbrace = unspecified ;
inline constexpr error_type error_range = unspecified ;
inline constexpr error_type error_space = unspecified ;
inline constexpr error_type error_badrepeat = unspecified ;
inline constexpr error_type error_complexity = unspecified ;
inline constexpr error_type error_stack = unspecified ;
}
1
The type error_type is an implementation-defined enumerated type (20.4.2.1.3). Values of type error_type
represent the error conditions described in Table 132:
Table 132 — error_type values in the C locale
Value
Error condition
error_collate
The expression contained an invalid collating element name.
error_ctype
The expression contained an invalid character class name.
error_escape
The expression contained an invalid escaped character, or a trailing escape.
error_backref
The expression contained an invalid back reference.
error_brack
The expression contained mismatched [ and ].
error_paren
The expression contained mismatched ( and ).
error_brace
The expression contained mismatched { and }
error_badbrace
The expression contained an invalid range in a {} expression.
error_range
The expression contained an invalid character range, such as [b-a] in most
encodings.
error_space
There was insufficient memory to convert the expression into a finite state
machine.
error_badrepeat One of *?+{ was not preceded by a valid regular expression.
error_complexity The complexity of an attempted match against a regular expression exceeded
a pre-set level.
§ 31.5.3
1168
Table 132 — error_type values in the C locale (continued)
Value
Error condition
error_stack
There was insufficient memory to determine whether the regular expression
could match the specified character sequence.
31.6
Class regex_error
[re.badexp]
class regex_error : public runtime_error {
public:
explicit regex_error(regex_constants::error_type ecode);
regex_constants::error_type code() const;
};
1
The class regex_error defines the type of objects thrown as exceptions to report errors from the regular
expression library.
regex_error(regex_constants::error_type ecode);
2
Effects: Constructs an object of class regex_error.
3
Postconditions: ecode == code().
regex_constants::error_type code() const;
4
Returns: The error code that was passed to the constructor.
31.7
Class template regex_traits
[re.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 = bitmask_type;
regex_traits();
static size_t length(const char_type* p);
charT translate(charT c) const;
charT translate_nocase(charT c) const;
template<class ForwardIterator>
string_type transform(ForwardIterator first, ForwardIterator
last)
const;
template<class ForwardIterator>
string_type transform_primary(
ForwardIterator first, ForwardIterator last) const;
template<class ForwardIterator>
string_type lookup_collatename(
ForwardIterator first, ForwardIterator last) const;
template<class ForwardIterator>
char_class_type lookup_classname(
ForwardIterator first, ForwardIterator 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;
};
}
1
The specializations regex_traits<char> and regex_traits<wchar_t> shall be valid and shall satisfy the
requirements for a regular expression traits class (31.3).
using char_class_type = bitmask_type ;
2
The type char_class_type is used to represent a character classification and is capable of holding an
implementation specific set returned by lookup_classname.
§ 31.7
1169
static size_t length(const char_type* p);
3
Returns: char_traits<charT>::length(p).
charT translate(charT c) const;
4
Returns: c.
charT translate_nocase(charT c) const;
5
Returns: use_facet<ctype<charT>>(getloc()).tolower(c).
template<class ForwardIterator>
string_type transform(ForwardIterator first, ForwardIterator last) const;
6
Effects: As if by:
string_type str(first, last);
return use_facet<collate<charT>>(
getloc()).transform(&*str.begin(), &*str.begin() + str.length());
template<class ForwardIterator>
string_type transform_primary(ForwardIterator first, ForwardIterator last) const;
7
Effects: If
typeid(use_facet<collate<charT>>) == typeid(collate_byname<charT>)
and the form of the sort key returned by collate_byname<charT>::transform(first,
last) is
known and can be converted into a primary sort key then returns that key, otherwise returns an empty
string.
template<class ForwardIterator>
string_type lookup_collatename(ForwardIterator first, ForwardIterator last) const;
8
Returns: A sequence of one or more characters that represents the collating element consisting of the
character sequence designated by the iterator range [first, last). Returns an empty string if the
character sequence is not a valid collating element.
template<class ForwardIterator>
char_class_type lookup_classname(
ForwardIterator first, ForwardIterator last, bool icase = false) const;
9
Returns: An unspecified value that represents the character classification named by the character
sequence designated by the iterator range [first, last). If the parameter icase is true then the
returned mask identifies the character classification without regard to the case of the characters being
matched, otherwise it does honor the case of the characters being matched.332 The value returned shall
be independent of the case of the characters in the character sequence. If the name is not recognized
then returns char_class_type().
10
Remarks: For regex_traits<char>, at least the narrow character names in Table 133 shall be
recognized. For regex_traits<wchar_t>, at least the wide character names in Table 133 shall be
recognized.
bool isctype(charT c, char_class_type f) const;
11
Effects: Determines if the character c is a member of the character classification represented by f.
12
Returns: Given the following function declaration:
// for exposition only
template<class C>
ctype_base::mask convert(typename regex_traits<C>::char_class_type f);
that returns a value in which each ctype_base::mask value corresponding to a value in f named in
Table 133 is set, then the result is determined as if by:
ctype_base::mask m = convert<charT>(f);
const ctype<charT>& ct = use_facet<ctype<charT>>(getloc());
332) For example, if the parameter icase is true then [[:lower:]] is the same as [[:alpha:]].
§ 31.7
1170
if (ct.is(m, c)) {
return true;
} else if (c == ct.widen(’_’)) {
charT w[1] = { ct.widen(’w’) };
char_class_type x = lookup_classname(w, w+1);
return (f&x) == x;
} else {
return false;
}
[ Example:
regex_traits<char> t;
string d("d");
string u("upper");
regex_traits<char>::char_class_type f;
f = t.lookup_classname(d.begin(), d.end());
f |= t.lookup_classname(u.begin(), u.end());
ctype_base::mask m = convert<char>(f); // m == ctype_base::digit|ctype_base::upper
— end example ] [ Example:
regex_traits<char> t;
string w("w");
regex_traits<char>::char_class_type f;
f = t.lookup_classname(w.begin(), w.end());
t.isctype(’A’, f); // returns true
t.isctype(’_’, f); // returns true
t.isctype(’ ’, f); // returns false
— end example ]
int
value(charT ch, int radix) const;
13
Requires: The value of radix shall be 8, 10, or 16.
14
Returns: The value represented by the digit ch in base radix if the character ch is a valid digit in base
radix; otherwise returns -1.
locale_type imbue(locale_type loc);
15
Effects: Imbues this with a copy of the locale loc. [ Note: Calling imbue with a different locale than
the one currently in use invalidates all cached data held by *this.
— end note ]
16
Returns: If no locale has been previously imbued then a copy of the global locale in effect at the time
of construction of *this, otherwise a copy of the last argument passed to imbue.
17
Postconditions: getloc() == loc.
locale_type getloc() const;
18
Returns: If no locale has been imbued then a copy of the global locale in effect at the time of construction
of *this, otherwise a copy of the last argument passed to imbue.
31.8
Class template basic_regex
[re.regex]
1
For a char-like type charT, specializations of class template basic_regex represent regular expressions
constructed from character sequences of charT characters. In the rest of 31.8, charT denotes a given char-like
type. Storage for a regular expression is allocated and freed as necessary by the member functions of class
basic_regex.
2
Objects of type specialization of basic_regex are responsible for converting the sequence of charT objects
to an internal representation. It is not specified what form this representation takes, nor how it is accessed by
algorithms that operate on regular expressions. [ Note: Implementations will typically declare some function
templates as friends of basic_regex to achieve this — end note ]
3
The functions described in this Clause report errors by throwing exceptions of type regex_error.
namespace std {
template<class charT, class traits = regex_traits<charT>>
class basic_regex {
public:
§ 31.8
1171
Table 133 — Character class names and corresponding ctype masks
Narrow character name Wide character name Corresponding ctype_base::mask value
"alnum"
L"alnum"
ctype_base::alnum
"alpha"
L"alpha"
ctype_base::alpha
"blank"
L"blank"
ctype_base::blank
"cntrl"
L"cntrl"
ctype_base::cntrl
"digit"
L"digit"
ctype_base::digit
"d"
L"d"
ctype_base::digit
"graph"
L"graph"
ctype_base::graph
"lower"
L"lower"
ctype_base::lower
"print"
L"print"
ctype_base::print
"punct"
L"punct"
ctype_base::punct
"space"
L"space"
ctype_base::space
"s"
L"s"
ctype_base::space
"upper"
L"upper"
ctype_base::upper
"w"
L"w"
ctype_base::alnum
"xdigit"
L"xdigit"
ctype_base::xdigit
// types
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;
// 31.8.1, constants
static constexpr regex_constants::syntax_option_type
icase = regex_constants::icase;
static constexpr regex_constants::syntax_option_type
nosubs = regex_constants::nosubs;
static constexpr regex_constants::syntax_option_type
optimize = regex_constants::optimize;
static constexpr regex_constants::syntax_option_type
collate = regex_constants::collate;
static constexpr regex_constants::syntax_option_type
ECMAScript = regex_constants::ECMAScript;
static constexpr regex_constants::syntax_option_type
basic = regex_constants::basic;
static constexpr regex_constants::syntax_option_type
extended = regex_constants::extended;
static constexpr regex_constants::syntax_option_type
awk = regex_constants::awk;
static constexpr regex_constants::syntax_option_type
grep = regex_constants::grep;
static constexpr regex_constants::syntax_option_type
egrep = regex_constants::egrep;
static constexpr regex_constants::syntax_option_type
multiline = regex_constants::multiline;
// 31.8.2, construct/copy/destroy
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>& p,
flag_type f = regex_constants::ECMAScript);
§ 31.8
1172
template<class ForwardIterator>
basic_regex(ForwardIterator first, ForwardIterator last,
flag_type f = regex_constants::ECMAScript);
basic_regex(initializer_list<charT>, flag_type = regex_constants::ECMAScript);
~basic_regex();
basic_regex& operator=(const basic_regex&);
basic_regex& operator=(basic_regex&&) noexcept;
basic_regex& operator=(const charT* ptr);
basic_regex& operator=(initializer_list<charT> il);
template<class ST, class SA>
basic_regex& operator=(const basic_string<charT, ST, SA>& p);
// 31.8.3, assign
basic_regex& assign(const basic_regex& that);
basic_regex& assign(basic_regex&& that) noexcept;
basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
basic_regex& assign(const charT* p, size_t len, flag_type f);
template<class string_traits, class A>
basic_regex& assign(const basic_string<charT, string_traits, A>& s,
flag_type f = regex_constants::ECMAScript);
template<class InputIterator>
basic_regex& assign(InputIterator first, InputIterator last,
flag_type f = regex_constants::ECMAScript);
basic_regex& assign(initializer_list<charT>,
flag_type = regex_constants::ECMAScript);
// 31.8.4, const operations
unsigned mark_count() const;
flag_type flags() const;
// 31.8.5, locale
locale_type imbue(locale_type loc);
locale_type getloc() const;
// 31.8.6, swap
void swap(basic_regex&);
};
template<class ForwardIterator>
basic_regex(ForwardIterator, ForwardIterator,
regex_constants::syntax_option_type = regex_constants::ECMAScript)
-> basic_regex<typename iterator_traits<ForwardIterator>::value_type>;
}
31.8.1
basic_regex constants
[re.regex.const]
static constexpr regex_constants::syntax_option_type icase = regex_constants::icase;
static constexpr regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
static constexpr regex_constants::syntax_option_type optimize = regex_constants::optimize;
static constexpr regex_constants::syntax_option_type collate = regex_constants::collate;
static constexpr regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
static constexpr regex_constants::syntax_option_type basic = regex_constants::basic;
static constexpr regex_constants::syntax_option_type extended = regex_constants::extended;
static constexpr regex_constants::syntax_option_type awk = regex_constants::awk;
static constexpr regex_constants::syntax_option_type grep = regex_constants::grep;
static constexpr regex_constants::syntax_option_type egrep = regex_constants::egrep;
static constexpr regex_constants::syntax_option_type multiline = regex_constants::multiline;
1
The static constant members are provided as synonyms for the constants declared in namespace regex_-
constants.
§ 31.8.1
1173
31.8.2
basic_regex constructors
[re.regex.construct]
basic_regex();
1
Effects: Constructs an object of class basic_regex that does not match any character sequence.
explicit basic_regex(const charT* p, flag_type f = regex_constants::ECMAScript);
2
Requires: p shall not be a null pointer.
3
Throws: regex_error if p is not a valid regular expression.
4
Effects: Constructs an object of class basic_regex; the object’s internal finite state machine is
constructed from the regular expression contained in the array of charT of length char_traits<charT>::
length(p) whose first element is designated by p, and interpreted according to the flags f.
5
Postconditions: flags() returns f. mark_count() returns the number of marked sub-expressions
within the expression.
basic_regex(const charT* p, size_t len, flag_type f);
6
Requires: p shall not be a null pointer.
7
Throws: regex_error if p is not a valid regular expression.
8
Effects: Constructs an object of class basic_regex; the object’s internal finite state machine is
constructed from the regular expression contained in the sequence of characters [p, p+len), and
interpreted according the flags specified in f.
9
Postconditions: flags() returns f. mark_count() returns the number of marked sub-expressions
within the expression.
basic_regex(const basic_regex& e);
10
Effects: Constructs an object of class basic_regex as a copy of the object e.
11
Postconditions: flags() and mark_count() return e.flags() and e.mark_count(), respectively.
basic_regex(basic_regex&& e) noexcept;
12
Effects: Move constructs an object of class basic_regex from e.
13
Postconditions: flags() and mark_count() return the values that e.flags() and e.mark_count(),
respectively, had before construction. e is in a valid state with unspecified value.
template<class ST, class SA>
explicit basic_regex(const basic_string<charT, ST, SA>& s,
flag_type f = regex_constants::ECMAScript);
14
Throws: regex_error if s is not a valid regular expression.
15
Effects: Constructs an object of class basic_regex; the object’s internal finite state machine is
constructed from the regular expression contained in the string s, and interpreted according to the
flags specified in f.
16
Postconditions: flags() returns f. mark_count() returns the number of marked sub-expressions
within the expression.
template<class ForwardIterator>
basic_regex(ForwardIterator first, ForwardIterator last,
flag_type f = regex_constants::ECMAScript);
17
Throws: regex_error if the sequence [first, last) is not a valid regular expression.
18
Effects: Constructs an object of class basic_regex; the object’s internal finite state machine is
constructed from the regular expression contained in the sequence of characters [first, last), and
interpreted according to the flags specified in f.
19
Postconditions: flags() returns f. mark_count() returns the number of marked sub-expressions
within the expression.
basic_regex(initializer_list<charT> il, flag_type f = regex_constants::ECMAScript);
20
Effects: Same as basic_regex(il.begin(), il.end(), f).
§ 31.8.2
1174
31.8.3
basic_regex assign
[re.regex.assign]
basic_regex& operator=(const basic_regex& e);
1
Effects: Copies e into *this and returns *this.
2
Postconditions: flags() and mark_count() return e.flags() and e.mark_count(), respectively.
basic_regex& operator=(basic_regex&& e) noexcept;
3
Effects: Move assigns from e into *this and returns *this.
4
Postconditions: flags() and mark_count() return the values that e.flags() and e.mark_count(),
respectively, had before assignment. e is in a valid state with unspecified value.
basic_regex& operator=(const charT* ptr);
5
Requires: ptr shall not be a null pointer.
6
Effects: Returns assign(ptr).
basic_regex& operator=(initializer_list<charT> il);
7
Effects: Returns assign(il.begin(), il.end()).
template<class ST, class SA>
basic_regex& operator=(const basic_string<charT, ST, SA>& p);
8
Effects: Returns assign(p).
basic_regex& assign(const basic_regex& that);
9
Effects: Equivalent to: return *this = that;
basic_regex& assign(basic_regex&& that) noexcept;
10
Effects: Equivalent to: return *this = std::move(that);
basic_regex& assign(const charT* ptr, flag_type f = regex_constants::ECMAScript);
11
Returns: assign(string_type(ptr), f).
basic_regex& assign(const charT* ptr, size_t len, flag_type f = regex_constants::ECMAScript);
12
Returns: assign(string_type(ptr, len), f).
template<class string_traits, class A>
basic_regex& assign(const basic_string<charT, string_traits, A>& s,
flag_type f = regex_constants::ECMAScript);
13
Throws: regex_error if s is not a valid regular expression.
14
Returns: *this.
15
Effects: Assigns the regular expression contained in the string s, interpreted according the flags specified
in f. If an exception is thrown, *this is unchanged.
16
Postconditions: If no exception is thrown, flags() returns f and mark_count() returns the number of
marked sub-expressions within the expression.
template<class InputIterator>
basic_regex& assign(InputIterator first, InputIterator last,
flag_type f = regex_constants::ECMAScript);
17
Requires: The type InputIterator shall satisfy the requirements for an Input Iterator (27.2.3).
18
Returns: assign(string_type(first, last), f).
basic_regex& assign(initializer_list<charT> il,
flag_type f = regex_constants::ECMAScript);
19
Effects: Same as assign(il.begin(), il.end(), f).
20
Returns: *this.
§ 31.8.3
1175
31.8.4
basic_regex constant operations
[re.regex.operations]
unsigned mark_count() const;
1
Effects: Returns the number of marked sub-expressions within the regular expression.
flag_type flags() const;
2
Effects: Returns a copy of the regular expression syntax flags that were passed to the object’s constructor
or to the last call to assign.
31.8.5
basic_regex locale
[re.regex.locale]
locale_type imbue(locale_type loc);
1
Effects: Returns the result of traits_inst.imbue(loc) where traits_inst is a (default-initialized)
instance of the template type argument traits stored within the object. After a call to imbue the
basic_regex object does not match any character sequence.
locale_type getloc() const;
2
Effects: Returns the result of traits_inst.getloc() where traits_inst is a (default-initialized)
instance of the template parameter traits stored within the object.
31.8.6
basic_regex swap
[re.regex.swap]
void swap(basic_regex& e);
1
Effects: Swaps the contents of the two regular expressions.
2
Postconditions: *this contains the regular expression that was in e, e contains the regular expression
that was in *this.
3
Complexity: Constant time.
31.8.7
basic_regex non-member functions
[re.regex.nonmemb]
31.8.7.1
basic_regex non-member swap
[re.regex.nmswap]
template<class charT, class traits>
void swap(basic_regex<charT, traits>& lhs, basic_regex<charT, traits>& rhs);
1
Effects: Calls lhs.swap(rhs).
31.9
Class template sub_match
[re.submatch]
1
Class template sub_match denotes the sequence of characters matched by a particular marked sub-expression.
namespace std {
template<class BidirectionalIterator>
class sub_match : public pair<BidirectionalIterator, BidirectionalIterator> {
public:
using value_type
=
typename iterator_traits<BidirectionalIterator>::value_type;
using difference_type =
typename iterator_traits<BidirectionalIterator>::difference_type;
using iterator
= BidirectionalIterator;
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;
§ 31.9
1176
};
}
31.9.1
sub_match members
[re.submatch.members]
constexpr sub_match();
1
Effects: Value-initializes the pair base class subobject and the member matched.
difference_type length() const;
2
Returns: matched ? distance(first, second) : 0.
operator string_type() const;
3
Returns: matched ? string_type(first, second) : string_type().
string_type str() const;
4
Returns: matched ? string_type(first, second) : string_type().
int compare(const sub_match& s) const;
5
Returns: str().compare(s.str()).
int compare(const string_type& s) const;
6
Returns: str().compare(s).
int compare(const value_type* s) const;
7
Returns: str().compare(s).
31.9.2
sub_match non-member operators
[re.submatch.op]
template<class BiIter>
bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
1
Returns: lhs.compare(rhs) == 0.
template<class BiIter>
bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
2
Returns: lhs.compare(rhs) != 0.
template<class BiIter>
bool operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
3
Returns: lhs.compare(rhs) < 0.
template<class BiIter>
bool operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
4
Returns: lhs.compare(rhs) <= 0.
template<class BiIter>
bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
5
Returns: lhs.compare(rhs) >= 0.
template<class BiIter>
bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
6
Returns: lhs.compare(rhs) > 0.
template<class BiIter, class ST, class SA>
bool operator==(
const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
const sub_match<BiIter>& rhs);
7
Returns:
rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size()))
==
0
§ 31.9.2
1177
template<class BiIter, class ST, class SA>
bool operator!=(
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& lhs,
const sub_match<BiIter>& rhs);
8
Returns: !(lhs == rhs).
template<class BiIter, class ST, class SA>
bool operator<(
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& lhs,
const sub_match<BiIter>& rhs);
9
Returns:
rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(),
lhs.size())) >
0
template<class BiIter, class ST, class SA>
bool operator>(
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& lhs,
const sub_match<BiIter>& rhs);
10
Returns: rhs < lhs.
template<class BiIter, class ST, class SA>
bool operator>=(
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& lhs,
const sub_match<BiIter>& rhs);
11
Returns: !(lhs < rhs).
template<class BiIter, class ST, class SA>
bool operator<=(
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& lhs,
const sub_match<BiIter>& rhs);
12
Returns: !(rhs < lhs).
template<class BiIter, class ST, class SA>
bool operator==(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& rhs);
13
Returns:
lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(),
rhs.size())) ==
0
template<class BiIter, class ST, class SA>
bool operator!=(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& rhs);
14
Returns: !(lhs == rhs).
template<class BiIter, class ST, class SA>
bool operator<(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& rhs);
15
Returns:
lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(),
rhs.size())) < 0
template<class BiIter, class ST, class SA>
bool operator>(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type,
ST, SA>& rhs);
16
Returns: rhs < lhs.
template<class BiIter, class ST, class SA>
bool operator>=(
const sub_match<BiIter>& lhs,
§ 31.9.2
1178
const basic_string<typename iterator_traits<BiIter>::value_type, ST,
SA>&
rhs);
17
Returns: !(lhs < rhs).
template<class BiIter, class ST, class SA>
bool operator<=(
const sub_match<BiIter>& lhs,
const basic_string<typename iterator_traits<BiIter>::value_type, ST,
SA>&
rhs);
18
Returns: !(rhs < lhs).
template<class BiIter>
bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
19
Returns: rhs.compare(lhs) == 0.
template<class BiIter>
bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
20
Returns: !(lhs == rhs).
template<class BiIter>
bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
21
Returns: rhs.compare(lhs) > 0.
template<class BiIter>
bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
22
Returns: rhs < lhs.
template<class BiIter>
bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
23
Returns: !(lhs < rhs).
template<class BiIter>
bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
const sub_match<BiIter>& rhs);
24
Returns: !(rhs < lhs).
template<class BiIter>
bool operator==(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
25
Returns: lhs.compare(rhs) == 0.
template<class BiIter>
bool operator!=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
26
Returns: !(lhs == rhs).
template<class BiIter>
bool operator<(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
27
Returns: lhs.compare(rhs) < 0.
template<class BiIter>
bool operator>(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
28
Returns: rhs < lhs.
§ 31.9.2
1179
template<class BiIter>
bool operator>=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
29
Returns: !(lhs < rhs).
template<class BiIter>
bool operator<=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type* rhs);
30
Returns: !(rhs < lhs).
template<class BiIter>
bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
31
Returns: rhs.compare(typename sub_match<BiIter>::string_type(1,
lhs))
== 0.
template<class BiIter>
bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
32
Returns: !(lhs == rhs).
template<class BiIter>
bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
33
Returns: rhs.compare(typename sub_match<BiIter>::string_type(1,
lhs))
> 0.
template<class BiIter>
bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
34
Returns: rhs < lhs.
template<class BiIter>
bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
35
Returns: !(lhs < rhs).
template<class BiIter>
bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
const sub_match<BiIter>& rhs);
36
Returns: !(rhs < lhs).
template<class BiIter>
bool operator==(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
37
Returns: lhs.compare(typename sub_match<BiIter>::string_type(1, rhs))
== 0.
template<class BiIter>
bool operator!=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
38
Returns: !(lhs == rhs).
template<class BiIter>
bool operator<(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
39
Returns: lhs.compare(typename sub_match<BiIter>::string_type(1, rhs))
< 0.
template<class BiIter>
bool operator>(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
40
Returns: rhs < lhs.
§ 31.9.2
1180
template<class BiIter>
bool operator>=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
41
Returns: !(lhs < rhs).
template<class BiIter>
bool operator<=(const sub_match<BiIter>& lhs,
const typename iterator_traits<BiIter>::value_type& rhs);
42
Returns: !(rhs < lhs).
template<class charT, class ST, class BiIter>
basic_ostream<charT, ST>&
operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
43
Returns: os << m.str().
31.10
Class template match_results
[re.results]
1
Class template match_results denotes a collection of character sequences representing the result of a regular
expression match. Storage for the collection is allocated and freed as necessary by the member functions of
class template match_results.
2
The class template match_results satisfies the requirements of an allocator-aware container and of a sequence
container (26.2.1, 26.2.3) except that only operations defined for const-qualified sequence containers are
supported and that the semantics of comparison functions are different from those required for a container.
3
A default-constructed match_results object has no fully established result state. A match result is ready
when, as a consequence of a completed regular expression match modifying such an object, its result state
becomes fully established. The effects of calling most member functions from a match_results object that
is not ready are undefined.
4
The sub_match object stored at index 0 represents sub-expression 0, i.e., the whole match. In this case the
sub_match member matched is always true. The sub_match object stored at index n denotes what matched
the marked sub-expression n within the matched expression. If the sub-expression n participated in a regular
expression match then the sub_match member matched evaluates to true, and members first and second
denote the range of characters [first, second) which formed that match. Otherwise matched is false,
and members first and second point to the end of the sequence that was searched. [ Note: The sub_match
objects representing different sub-expressions that did not participate in a regular expression match need not
be distinct. — end note ]
namespace std {
template<class BidirectionalIterator,
class Allocator = allocator<sub_match<BidirectionalIterator>>>
class match_results {
public:
using value_type
= sub_match<BidirectionalIterator>;
using const_reference = const value_type&;
using reference
= value_type&;
using const_iterator
= implementation-defined ;
using iterator
= const_iterator;
using difference_type =
typename iterator_traits<BidirectionalIterator>::difference_type;
using size_type
= typename allocator_traits<Allocator>::size_type;
using allocator_type
= Allocator;
using char_type
=
typename iterator_traits<BidirectionalIterator>::value_type;
using string_type
= basic_string<char_type>;
// 31.10.1, construct/copy/destroy
explicit match_results(const Allocator& a = Allocator());
match_results(const match_results& m);
match_results(match_results&& m) noexcept;
match_results& operator=(const match_results& m);
match_results& operator=(match_results&& m);
~match_results();
§ 31.10
1181
// 31.10.2, state
bool ready() const;
// 31.10.3, size
size_type size() const;
size_type max_size() const;
[[nodiscard]] bool empty() const;
// 31.10.4, element access
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;
// 31.10.5, format
template<class OutputIter>
OutputIter
format(OutputIter out,
const char_type* fmt_first, const char_type* fmt_last,
regex_constants::match_flag_type flags = regex_constants::format_default)
const;
template<class OutputIter, class ST, class SA>
OutputIter
format(OutputIter 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;
// 31.10.6, allocator
allocator_type get_allocator() const;
// 31.10.7, swap
void swap(match_results& that);
};
}
31.10.1
match_results constructors
[re.results.const]
1
In all match_results constructors, a copy of the Allocator argument shall be used for any memory allocation
performed by the constructor or member functions during the lifetime of the object.
match_results(const Allocator& a = Allocator());
2
Effects: Constructs an object of class match_results.
3
Postconditions: ready() returns false. size() returns 0.
match_results(const match_results& m);
4
Effects: Constructs an object of class match_results, as a copy of m.
match_results(match_results&& m) noexcept;
5
Effects: Move constructs an object of class match_results from m satisfying the same postconditions
as Table 134. Additionally, the stored Allocator value is move constructed from m.get_allocator().
§ 31.10.1
1182
6
Throws: Nothing.
match_results& operator=(const match_results& m);
7
Effects: Assigns m to *this. The postconditions of this function are indicated in Table 134.
match_results& operator=(match_results&& m);
8
Effects: Move-assigns m to *this. The postconditions of this function are indicated in Table 134.
Table 134 — match_results assignment operator effects
Element
Value
ready()
m.ready()
size()
m.size()
str(n)
m.str(n) for all integers n < m.size()
prefix()
m.prefix()
suffix()
m.suffix()
(*this)[n]
m[n] for all integers n < m.size()
length(n)
m.length(n) for all integers n < m.size()
position(n)
m.position(n) for all integers n < m.size()
31.10.2
match_results state
[re.results.state]
bool ready() const;
1
Returns: true if *this has a fully established result state, otherwise false.
31.10.3
match_results size
[re.results.size]
size_type size() const;
1
Returns: One plus the number of marked sub-expressions in the regular expression that was matched
if
*this represents the result of a successful match. Otherwise returns 0.
[Note: The state of a
match_results object can be modified only by passing that object to regex_match or regex_search.
Sections 31.11.2 and 31.11.3 specify the effects of those algorithms on their match_results arguments.
— end note ]
size_type max_size() const;
2
Returns: The maximum number of sub_match elements that can be stored in *this.
[[nodiscard]] bool empty() const;
3
Returns: size() == 0.
31.10.4
match_results element access
[re.results.acc]
difference_type length(size_type sub = 0) const;
1
Requires: ready() == true.
2
Returns: (*this)[sub].length().
difference_type position(size_type sub = 0) const;
3
Requires: ready() == true.
4
Returns: The distance from the start of the target sequence to (*this)[sub].first.
string_type str(size_type sub = 0) const;
5
Requires: ready() == true.
6
Returns: string_type((*this)[sub]).
§ 31.10.4
1183
const_reference operator[](size_type n) const;
7
Requires: ready() == true.
8
Returns: A reference to the sub_match object representing the character sequence that matched marked
sub-expression n. If n == 0 then returns a reference to a sub_match object representing the character
sequence that matched the whole regular expression. If n >= size() then returns a sub_match object
representing an unmatched sub-expression.
const_reference prefix() const;
9
Requires: ready() == true.
10
Returns: A reference to the sub_match object representing the character sequence from the start of the
string being matched/searched to the start of the match found.
const_reference suffix() const;
11
Requires: ready() == true.
12
Returns: A reference to the sub_match object representing the character sequence from the end of the
match found to the end of the string being matched/searched.
const_iterator begin() const;
const_iterator cbegin() const;
13
Returns: A starting iterator that enumerates over all the sub-expressions stored in *this.
const_iterator end() const;
const_iterator cend() const;
14
Returns: A terminating iterator that enumerates over all the sub-expressions stored in *this.
31.10.5
match_results formatting
[re.results.form]
template<class OutputIter>
OutputIter format(
OutputIter out,
const char_type* fmt_first, const char_type* fmt_last,
regex_constants::match_flag_type flags = regex_constants::format_default) const;
1
Requires: ready() == true and OutputIter shall satisfy the requirements for an Output Iterator
(27.2.4).
2
Effects: Copies the character sequence [fmt_first, fmt_last) to OutputIter out. Replaces each
format specifier or escape sequence in the copied range with either the character(s) it represents or
the sequence of characters within *this to which it refers. The bitmasks specified in flags determine
which format specifiers and escape sequences are recognized.
3
Returns: out.
template<class OutputIter, class ST, class SA>
OutputIter format(
OutputIter out,
const basic_string<char_type, ST, SA>& fmt,
regex_constants::match_flag_type flags = regex_constants::format_default) const;
4
Effects: Equivalent to:
return format(out, fmt.data(), fmt.data() + fmt.size(), flags);
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;
5
Requires: ready() == true.
6
Effects: Constructs an empty string result of type basic_string<char_type, ST, SA> and calls:
format(back_inserter(result), fmt, flags);
7
Returns: result.
§ 31.10.5
1184
string_type format(
const char_type* fmt,
regex_constants::match_flag_type flags = regex_constants::format_default) const;
8
Requires: ready() == true.
9
Effects: Constructs an empty string result of type string_type and calls:
format(back_inserter(result), fmt, fmt + char_traits<char_type>::length(fmt), flags);
10
Returns: result.
31.10.6
match_results allocator
[re.results.all]
allocator_type get_allocator() const;
1
Returns: A copy of the Allocator that was passed to the object’s constructor or, if that allocator has
been replaced, a copy of the most recent replacement.
31.10.7
match_results swap
[re.results.swap]
void swap(match_results& that);
1
Effects: Swaps the contents of the two sequences.
2
Postconditions:
*this contains the sequence of matched sub-expressions that were in that, that
contains the sequence of matched sub-expressions that were in *this.
3
Complexity: Constant time.
template<class BidirectionalIterator, class Allocator>
void swap(match_results<BidirectionalIterator, Allocator>& m1,
match_results<BidirectionalIterator, Allocator>& m2);
4
Effects: As if by m1.swap(m2).
31.10.8
match_results non-member functions
[re.results.nonmember]
template<class BidirectionalIterator, class Allocator>
bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
1
Returns: true if neither match result is ready, false if one match result is ready and the other is not.
If both match results are ready, returns true only if:
(1.1)
—
m1.empty() && m2.empty(), or
(1.2)
—
!m1.empty() && !m2.empty(), and the following conditions are satisfied:
(1.2.1)
—
m1.prefix() == m2.prefix(),
(1.2.2)
—
m1.size() == m2.size() && equal(m1.begin(), m1.end(), m2.begin()), and
(1.2.3)
—
m1.suffix() == m2.suffix().
[ Note: The algorithm equal is defined in Clause 28.
— end note ]
template<class BidirectionalIterator, class Allocator>
bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
const match_results<BidirectionalIterator, Allocator>& m2);
2
Returns: !(m1 == m2).
31.11
Regular expression algorithms
[re.alg]
31.11.1
Exceptions
[re.except]
1
The algorithms described in this subclause may throw an exception of type regex_error. If such an
exception e is thrown, e.code() shall return either regex_constants::error_complexity or regex_-
constants::error_stack.
§ 31.11.1
1185
31.11.2
regex_match
[re.alg.match]
template<class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
1
Requires: The type BidirectionalIterator shall satisfy the requirements of a Bidirectional Iterator
(27.2.6).
2
Effects: Determines whether there is a match between the regular expression e, and all of the character
sequence [first, last). The parameter flags is used to control how the expression is matched
against the character sequence. When determining if there is a match, only potential matches that
match the entire character sequence are considered. Returns true if such a match exists, false
otherwise. [ Example:
std::regex re("Get|GetValue");
std::cmatch m;
regex_search("GetValue", m, re);
// returns true, and m[0] contains "Get"
regex_match ("GetValue", m, re);
// returns true, and m[0] contains "GetValue"
regex_search("GetValues", m, re);
// returns true, and m[0] contains "Get"
regex_match ("GetValues", m, re);
// returns false
— end example ]
3
Postconditions: m.ready() == true in all cases. If the function returns false, then the effect on
parameter m is unspecified except that m.size() returns 0 and m.empty() returns true.
Otherwise
the effects on parameter m are given in Table 135.
Table 135 — Effects of regex_match algorithm
Element
Value
m.size()
1 + e.mark_count()
m.empty()
false
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
For all integers 0 < n < m.size(), the start of the se-
quence that matched sub-expression n. Alternatively, if
sub-expression n did not participate in the match, then
last.
m[n].second
For all integers 0 < n < m.size(), the end of the se-
quence that matched sub-expression n. Alternatively, if
sub-expression n did not participate in the match, then
last.
m[n].matched
For all integers 0 < n < m.size(), true if sub-expression
n participated in the match, false otherwise.
template<class BidirectionalIterator, class charT, class traits>
bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
4
Effects: Behaves “as if” by constructing an instance of match_results<BidirectionalIterator>
what, and then returning the result of regex_match(first, last, what, e, flags).
§ 31.11.2
1186
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);
5
Returns: regex_match(str, str + char_traits<charT>::length(str), m, e, flags).
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);
6
Returns: regex_match(s.begin(), s.end(), m, e, flags).
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);
7
Returns: regex_match(str, str + char_traits<charT>::length(str), e, flags)
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);
8
Returns: regex_match(s.begin(), s.end(), e, flags).
31.11.3
regex_search
[re.alg.search]
template<class BidirectionalIterator, class Allocator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
match_results<BidirectionalIterator, Allocator>& m,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
1
Requires: Type BidirectionalIterator shall satisfy the requirements of a Bidirectional Iterator
(27.2.6).
2
Effects: Determines whether there is some sub-sequence within [first, last) that matches the
regular expression e. The parameter flags is used to control how the expression is matched against
the character sequence. Returns true if such a sequence exists, false otherwise.
3
Postconditions: m.ready() == true in all cases. If the function returns false, then the effect on
parameter m is unspecified except that m.size() returns 0 and m.empty() returns true. Otherwise
the effects on parameter m are given in Table 136.
Table 136 — Effects of regex_search algorithm
Element
Value
m.size()
1 + e.mark_count()
m.empty()
false
m.prefix().first
first
m.prefix().second
m[0].first
m.prefix().matched
m.prefix().first != m.prefix().second
m.suffix().first
m[0].second
m.suffix().second
last
m.suffix().matched
m.suffix().first != m.suffix().second
m[0].first
The start of the sequence of characters that matched the
regular expression
m[0].second
The end of the sequence of characters that matched the
regular expression
m[0].matched
true
§
31.11.3
1187
Table 136 — Effects of regex_search algorithm (continued)
Element
Value
m[n].first
For all integers 0 < n < m.size(), the start of the se-
quence that matched sub-expression n. Alternatively, if
sub-expression n did not participate in the match, then
last.
m[n].second
For all integers 0 < n < m.size(), the end of the se-
quence that matched sub-expression n. Alternatively, if
sub-expression n did not participate in the match, then
last .
m[n].matched
For all integers 0 < n < m.size(), true if sub-expression
n participated in the match, false otherwise.
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);
4
Returns: regex_search(str, str + char_traits<charT>::length(str), m, e, flags).
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);
5
Returns: regex_search(s.begin(), s.end(), m, e, flags).
template<class BidirectionalIterator, class charT, class traits>
bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
regex_constants::match_flag_type flags = regex_constants::match_default);
6
Effects: Behaves “as if” by constructing an object what of type match_results<Bidirectional-
Iterator> and returning regex_search(first, last, what, e, flags).
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);
7
Returns: regex_search(str, str + char_traits<charT>::length(str), e, flags).
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);
8
Returns: regex_search(s.begin(), s.end(), e, flags).
31.11.4
regex_replace
[re.alg.replace]
template<class OutputIterator, class BidirectionalIterator,
class traits, class charT, class ST, class SA>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
const basic_string<charT, ST, SA>& fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
§ 31.11.4
1188
template<class OutputIterator, class BidirectionalIterator, class traits, class charT>
OutputIterator
regex_replace(OutputIterator out,
BidirectionalIterator first, BidirectionalIterator last,
const basic_regex<charT, traits>& e,
const charT* fmt,
regex_constants::match_flag_type flags = regex_constants::match_default);
1
Effects: Constructs a regex_iterator object i as if by
regex_iterator<BidirectionalIterator, charT, traits> i(first, last, e, flags)
and uses i to enumerate through all of the matches m of type match_results<BidirectionalIterator>
that occur within the sequence [first, last). If no such matches are found and !(flags & regex_-
constants::format_no_copy), then calls
out = copy(first, last, out)
If any matches are found then, for each such match:
(1.1)
—
If !(flags & regex_constants::format_no_copy), calls
out = copy(m.prefix().first, m.prefix().second, out)
(1.2)
—
Then calls
out = m.format(out, fmt, flags)
for the first form of the function and
out = m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags)
for the second.
Finally, if such a match is found and !(flags & regex_constants::format_no_copy), calls
out = copy(last_m.suffix().first, last_m.suffix().second, out)
where last_m is a copy of the last match found. If flags & regex_constants::format_first_only
is nonzero, then only the first match found is replaced.
2
Returns: out.
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);
3
Effects: Constructs an empty string result of type basic_string<charT, ST, SA> and calls:
regex_replace(back_inserter(result), s.begin(), s.end(), e, fmt, flags);
4
Returns: result.
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,
§ 31.11.4
1189
regex_constants::match_flag_type flags = regex_constants::match_default);
5
Effects: Constructs an empty string result of type basic_string<charT> and calls:
regex_replace(back_inserter(result), s, s + char_traits<charT>::length(s), e, fmt, flags);
6
Returns: result.
31.12
Regular expression iterators
[re.iter]
31.12.1
Class template regex_iterator
[re.regiter]
1
The class template regex_iterator is an iterator adaptor. It represents a new view of an existing iterator
sequence, by enumerating all the occurrences of a regular expression within that sequence. A regex_-
iterator uses regex_search to find successive regular expression matches within the sequence from which
it was constructed. After the iterator is constructed, and every time operator++ is used, the iterator finds
and stores a value of match_results<BidirectionalIterator>. If the end of the sequence is reached
(regex_search returns false), the iterator becomes equal to the end-of-sequence iterator value. The
default constructor constructs an end-of-sequence iterator object, which is the only legitimate iterator to
be used for the end condition. The result of operator* on an end-of-sequence iterator is not defined.
For any other iterator value a const match_results<BidirectionalIterator>& is returned. The result of
operator-> on an end-of-sequence iterator is not defined. For any other iterator value a const match_-
results<BidirectionalIterator>* is returned. It is impossible to store things into regex_iterators. Two
end-of-sequence iterators are always equal. An end-of-sequence iterator is not equal to a non-end-of-sequence
iterator. Two non-end-of-sequence iterators are equal when they are constructed from the same arguments.
namespace std {
template<class BidirectionalIterator,
class charT = typename iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT>>
class regex_iterator {
public:
using regex_type
= basic_regex<charT, traits>;
using iterator_category = forward_iterator_tag;
using value_type
= match_results<BidirectionalIterator>;
using difference_type
= ptrdiff_t;
using pointer
= const value_type*;
using reference
= const value_type&;
regex_iterator();
regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type& re,
regex_constants::match_flag_type m = regex_constants::match_default);
regex_iterator(BidirectionalIterator, BidirectionalIterator,
const regex_type&&,
regex_constants::match_flag_type = regex_constants::match_default) = delete;
regex_iterator(const regex_iterator&);
regex_iterator& operator=(const regex_iterator&);
bool operator==(const regex_iterator&) const;
bool operator!=(const regex_iterator&) const;
const value_type& operator*() const;
const value_type* operator->() const;
regex_iterator& operator++();
regex_iterator operator++(int);
private:
BidirectionalIterator
begin;
// exposition only
BidirectionalIterator
end;
// exposition only
const regex_type*
pregex; // exposition only
regex_constants::match_flag_type
flags;
// exposition only
match_results<BidirectionalIterator> match;
// exposition only
};
}
2
An object of type regex_iterator that is not an end-of-sequence iterator holds a zero-length match if
match[0].matched == true and match[0].first == match[0].second.
[Note: For example, this can
§ 31.12.1
1190
occur when the part of the regular expression that matched consists only of an assertion (such as ’^’, ’$’,
’\b’, ’\B’). — end note ]
31.12.1.1
regex_iterator constructors
[re.regiter.cnstr]
regex_iterator();
1
Effects: Constructs an end-of-sequence iterator.
regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
const regex_type& re,
regex_constants::match_flag_type m = regex_constants::match_default);
2
Effects: Initializes begin and end to a and b, respectively, sets pregex to &re, sets flags to m, then calls
regex_search(begin, end, match, *pregex, flags). If this call returns false the constructor sets
*this to the end-of-sequence iterator.
31.12.1.2
regex_iterator comparisons
[re.regiter.comp]
bool operator==(const regex_iterator& right) const;
1
Returns: true if *this and right are both end-of-sequence iterators or if the following conditions all
hold:
(1.1)
—
begin == right.begin,
(1.2)
—
end == right.end,
(1.3)
—
pregex == right.pregex,
(1.4)
—
flags == right.flags, and
(1.5)
—
match[0] == right.match[0];
otherwise false.
bool operator!=(const regex_iterator& right) const;
2
Returns: !(*this == right).
31.12.1.3
regex_iterator indirection
[re.regiter.deref]
const value_type& operator*() const;
1
Returns: match.
const value_type* operator->() const;
2
Returns: &match.
31.12.1.4
regex_iterator increment
[re.regiter.incr]
regex_iterator& operator++();
1
Effects: Constructs a local variable start of type BidirectionalIterator and initializes it with the
value of match[0].second.
2
If the iterator holds a zero-length match and start == end the operator sets *this to the end-of-
sequence iterator and returns *this.
3
Otherwise, if the iterator holds a zero-length match, the operator calls:
regex_search(start, end, match, *pregex,
flags | regex_constants::match_not_null | regex_constants::match_continuous)
If the call returns true the operator returns *this. Otherwise the operator increments start and
continues as if the most recent match was not a zero-length match.
4
If the most recent match was not a zero-length match, the operator sets flags to flags | regex_-
constants::match_prev_avail and calls regex_search(start, end, match, *pregex, flags). If
the call returns false the iterator sets *this to the end-of-sequence iterator. The iterator then returns
*this.
5
In all cases in which the call to regex_search returns true, match.prefix().first shall be equal to
the previous value of match[0].second, and for each index i in the half-open range [0, match.size())
§ 31.12.1.4
1191