Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/regex/sub match"

From cppreference.com
< cpp‎ | regex
m (templatize)
(c -> c/core, also added a TODO block (LWG 3204).)
Line 1: Line 1:
 
{{cpp/title|sub_match}}
 
{{cpp/title|sub_match}}
 
{{cpp/regex/sub_match/navbar}}
 
{{cpp/regex/sub_match/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
+
{{ddcl|header=regex|since=c++11|
 
template<class BidirIt>
 
template<class BidirIt>
 
class sub_match;
 
class sub_match;
 
}}
 
}}
  
The class template {{tt|sub_match}} is used by the regular expression engine to denote sequences of characters matched by marked sub-expressions.
+
The class template {{tt|std::sub_match}} is used by the regular expression engine to denote sequences of characters matched by marked sub-expressions.
 
A match is a {{tt|[begin, end)}} pair within the target range matched by the regular expression, but with additional observer functions to enhance code clarity.
 
A match is a {{tt|[begin, end)}} pair within the target range matched by the regular expression, but with additional observer functions to enhance code clarity.
  
Only the default constructor is publicly accessible.  Instances of {{tt|sub_match}} are normally constructed and populated as a part of a {{lc|std::match_results}} container during the processing of one of the regex algorithms.
+
Only the default constructor is publicly accessible.  Instances of {{tt|std::sub_match}} are normally constructed and populated as a part of a {{lc|std::match_results}} container during the processing of one of the regex algorithms.
  
The member functions return defined default values unless the {{c|matched}} member is {{tt|true}}.
+
The member functions return defined default values unless the {{c|matched}} member is {{c|true}}.
  
{{tt|sub_match}} inherits from {{c|std::pair<BidirIt, BidirIt>}}, although it cannot be treated as a {{lc|std::pair}} object because member functions such as swap and assignment will not work as expected.
+
{{tt|std::sub_match}} inherits from {{c/core|std::pair<BidirIt, BidirIt>}}, although it cannot be treated as a {{lc|std::pair}} object because member functions such as assignment will not work as expected.
  
 
===Type requirements===
 
===Type requirements===
 
{{par begin}}
 
{{par begin}}
{{par req named | BidirIt | BidirectionalIterator}}
+
{{par req named|BidirIt|BidirectionalIterator}}
 
{{par end}}
 
{{par end}}
  
Line 26: Line 26:
 
{{dsc header | regex}}
 
{{dsc header | regex}}
 
{{dsc hitem | Type | Definition}}
 
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|csub_match}} | {{c|sub_match<const char*>}}}}
+
{{dsc | {{tt|std::csub_match}} | {{c/core|std::sub_match<const char*>}}}}
{{dsc | {{tt|wcsub_match}} | {{c|sub_match<const wchar_t*>}}}}
+
{{dsc | {{tt|std::wcsub_match}} | {{c/core|std::sub_match<const wchar_t*>}}}}
{{dsc | {{tt|ssub_match}} | {{c|sub_match<std::string::const_iterator>}}}}
+
{{dsc | {{tt|std::ssub_match}} | {{c/core|std::sub_match<std::string::const_iterator>}}}}
{{dsc | {{tt|wssub_match}} | {{c|sub_match<std::wstring::const_iterator>}}}}
+
{{dsc | {{tt|std::wssub_match}} | {{c/core|std::sub_match<std::wstring::const_iterator>}}}}
 
{{dsc end}}
 
{{dsc end}}
  
Line 35: Line 35:
 
{{dsc begin}}
 
{{dsc begin}}
 
{{dsc hitem | Member type | Definition}}
 
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|iterator}} | {{c|BidirIt}}}}
+
{{dsc | {{tt|iterator}} | {{tt|BidirIt}}}}
{{dsc | {{tt|value_type}} | {{c|std::iterator_traits<BidirIt>::value_type}}}}
+
{{dsc | {{tt|value_type}} | {{c/core|std::iterator_traits<BidirIt>::value_type}}}}
{{dsc | {{tt|difference_type}} | {{c|std::iterator_traits<BidirIt>::difference_type}}}}
+
{{dsc | {{tt|difference_type}} | {{c/core|std::iterator_traits<BidirIt>::difference_type}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string<value_type>}}}}
+
{{dsc | {{tt|string_type}} | {{c/core|std::basic_string<value_type>}}}}
 
{{dsc end}}
 
{{dsc end}}
  
Line 53: Line 53:
  
 
===Member functions===
 
===Member functions===
 +
{{todo|Apply LWG 3204, add the swap() member function}}
 
{{dsc begin}}
 
{{dsc begin}}
 
{{dsc inc | cpp/regex/sub_match/dsc constructor}}
 
{{dsc inc | cpp/regex/sub_match/dsc constructor}}

Revision as of 21:50, 5 April 2023

Defined in header <regex>
template<class BidirIt>
class sub_match;
(since C++11)

The class template std::sub_match is used by the regular expression engine to denote sequences of characters matched by marked sub-expressions. A match is a [begin, end) pair within the target range matched by the regular expression, but with additional observer functions to enhance code clarity.

Only the default constructor is publicly accessible. Instances of std::sub_match are normally constructed and populated as a part of a std::match_results container during the processing of one of the regex algorithms.

The member functions return defined default values unless the matched member is true.

std::sub_match inherits from std::pair<BidirIt, BidirIt>, although it cannot be treated as a std::pair object because member functions such as assignment will not work as expected.

Contents

Type requirements

-
BidirIt must meet the requirements of LegacyBidirectionalIterator.

Specializations

Several specializations for common character sequence types are provided:

Defined in header <regex>
Type Definition
std::csub_match std::sub_match<const char*>
std::wcsub_match std::sub_match<const wchar_t*>
std::ssub_match std::sub_match<std::string::const_iterator>
std::wssub_match std::sub_match<std::wstring::const_iterator>

Member types

Member type Definition
iterator BidirIt
value_type std::iterator_traits<BidirIt>::value_type
difference_type std::iterator_traits<BidirIt>::difference_type
string_type std::basic_string<value_type>

Member objects

bool matched
Indicates if this match was successful
(public member object)

Inherited from std::pair

BidirIt first
Start of the match sequence.
(public member object)
BidirIt second
One-past-the-end of the match sequence.
(public member object)

Member functions

constructs the match object
(public member function) [edit]
Observers
returns the length of the match (if any)
(public member function) [edit]
converts to the underlying string type
(public member function) [edit]
compares matched subsequence (if any)
(public member function) [edit]

Non-member functions

(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)
compares a sub_match with another sub_match, a string, or a character
(function template) [edit]
outputs the matched character subsequence
(function template) [edit]

See also

iterates through the specified sub-expressions within all regex matches in a given string or through unmatched substrings
(class template) [edit]