The algorithm regex_match
determines whether a given regular expression matches all
of a given character sequence denoted by a pair of bidirectional-iterators,
the algorithm is defined as follows, the main use of this function is data
input validation.

Important

Note that the result is true only if the expression matches the whole of the input sequence. If you want to search
for an expression somewhere within the sequence then use regex_search. If you want to match
a prefix of the character string then use regex_search with the flag match_continuous
set.

Effects: Determines whether there is an
exact match between the regular expression e, and all
of the character sequence [first, last), parameter flags
(see match_flag_type)
is used to control how the expression is matched against the character sequence.
Returns true if such a match exists, false otherwise.

Throws: std::runtime_error
if the complexity of matching the expression against an N character string
begins to exceed O(N2), or if the program runs out of stack space while matching
the expression (if Boost.Regex is configured in recursive mode), or if the
matcher exhausts its permitted memory allocation (if Boost.Regex is configured
in non-recursive mode).

Postconditions: If the function returns
false, then the effect on parameter m is undefined,
otherwise the effects on parameter m are given in the
table:

Element

Value

m.size()

e.mark_count()

m.empty()

false

m.prefix().first

first

m.prefix().last

first

m.prefix().matched

false

m.suffix().first

last

m.suffix().last

last

m.suffix().matched

false

m[0].first

first

m[0].second

last

m[0].matched

true if a full match was found, and false if it was a partial match
(found as a result of the match_partial flag being set).

m[n].first

For all integers n<m.size(), the start of the sequence that
matched sub-expression n. Alternatively, if
sub-expression n did not participate in the
match, then last.

m[n].second

For all integers n<m.size(), the end of the sequence that
matched sub-expression n. Alternatively, if
sub-expression n did not participate in the
match, then last.

m[n].matched

For all integers n<m.size(), true if sub-expression n
participated in the match, false otherwise.