Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | regex
(c -> c/core, also added a TODO block (LWG 3204).)
m (Minor tweak.)
 
(2 intermediate revisions by 2 users not shown)
Line 2: Line 2:
 
{{cpp/regex/sub_match/navbar}}
 
{{cpp/regex/sub_match/navbar}}
 
{{ddcl|header=regex|since=c++11|
 
{{ddcl|header=regex|since=c++11|
−
template<class BidirIt>
+
template< class BidirIt >
 
class sub_match;
 
class sub_match;
 
}}
 
}}
  
 
The class template {{tt|std::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 {{range|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|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.
+
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 {{c|true}}.
 
The member functions return defined default values unless the {{c|matched}} member is {{c|true}}.
Line 24: Line 24:
  
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc header | regex}}
+
{{dsc header|regex}}
−
{{dsc hitem | Type | Definition}}
+
{{dsc hitem|Type|Definition}}
−
{{dsc | {{tt|std::csub_match}} | {{c/core|std::sub_match<const char*>}}}}
+
{{dsc|{{tt|std::csub_match}}|{{c/core|std::sub_match<const char*>}}}}
−
{{dsc | {{tt|std::wcsub_match}} | {{c/core|std::sub_match<const wchar_t*>}}}}
+
{{dsc|{{tt|std::wcsub_match}}|{{c/core|std::sub_match<const wchar_t*>}}}}
−
{{dsc | {{tt|std::ssub_match}} | {{c/core|std::sub_match<std::string::const_iterator>}}}}
+
{{dsc|{{tt|std::ssub_match}}|{{c/core|std::sub_match<std::string::const_iterator>}}}}
−
{{dsc | {{tt|std::wssub_match}} | {{c/core|std::sub_match<std::wstring::const_iterator>}}}}
+
{{dsc|{{tt|std::wssub_match}}|{{c/core|std::sub_match<std::wstring::const_iterator>}}}}
 
{{dsc end}}
 
{{dsc end}}
  
−
===Member types===
+
===Nested types===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc hitem | Member type | Definition}}
+
{{dsc hitem|Type|Definition}}
−
{{dsc | {{tt|iterator}} | {{tt|BidirIt}}}}
+
{{dsc|{{tt|iterator}}|{{tt|BidirIt}}}}
−
{{dsc | {{tt|value_type}} | {{c/core|std::iterator_traits<BidirIt>::value_type}}}}
+
{{dsc|{{tt|value_type}}|{{c/core|std::iterator_traits<BidirIt>::value_type}}}}
−
{{dsc | {{tt|difference_type}} | {{c/core|std::iterator_traits<BidirIt>::difference_type}}}}
+
{{dsc|{{tt|difference_type}}|{{c/core|std::iterator_traits<BidirIt>::difference_type}}}}
−
{{dsc | {{tt|string_type}} | {{c/core|std::basic_string<value_type>}}}}
+
{{dsc|{{tt|string_type}}|{{c/core|std::basic_string<value_type>}}}}
 
{{dsc end}}
 
{{dsc end}}
  
−
===Member objects===
+
===Data members===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc mem obj | nolink=true | {{dsc small|bool}} matched | Indicates if this match was successful}}
+
{{dsc hitem|Member|Description}}
 +
{{dsc|{{dsc small|{{c/core|bool}}}} {{tt|matched}}|whether this match was successful}}
 
{{dsc end}}
 
{{dsc end}}
−
{{inherited | [[cpp/utility/pair | {{small|std::}}pair]] |
+
 
 +
{{inherited|[[cpp/utility/pair|{{small|std::}}pair]]|
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc mem obj | nolink=true | {{dsc small|BidirIt}} first | Start of the match sequence.}}
+
{{dsc mem obj|nolink=true|{{dsc small|BidirIt}} first|Start of the match sequence.}}
−
{{dsc mem obj | nolink=true | {{dsc small|BidirIt}} second | One-past-the-end of the match sequence.}}
+
{{dsc mem obj|nolink=true|{{dsc small|BidirIt}} second|One-past-the-end of the match sequence.}}
 
{{dsc end}}
 
{{dsc end}}
 
}}
 
}}
Line 55: Line 57:
 
{{todo|Apply LWG 3204, add the swap() member function}}
 
{{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}}
  
−
{{dsc h2 | Observers}}
+
{{dsc h2|Observers}}
−
{{dsc inc | cpp/regex/sub_match/dsc length}}
+
{{dsc inc|cpp/regex/sub_match/dsc length}}
−
{{dsc inc | cpp/regex/sub_match/dsc str}}
+
{{dsc inc|cpp/regex/sub_match/dsc str}}
−
{{dsc inc | cpp/regex/sub_match/dsc compare}}
+
{{dsc inc|cpp/regex/sub_match/dsc compare}}
 
{{dsc end}}
 
{{dsc end}}
  
 
===Non-member functions===
 
===Non-member functions===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/regex/sub_match/dsc operator_cmp}}
+
{{dsc inc|cpp/regex/sub_match/dsc operator_cmp}}
−
{{dsc inc | cpp/regex/sub_match/dsc operator_ltlt}}
+
{{dsc inc|cpp/regex/sub_match/dsc operator_ltlt}}
 
{{dsc end}}
 
{{dsc end}}
  
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/regex/dsc regex_token_iterator}}
+
{{dsc inc|cpp/regex/dsc regex_token_iterator}}
 
{{dsc end}}
 
{{dsc end}}
  
 
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
 
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Latest revision as of 01:04, 14 November 2024

 
C++
 
Regular expressions library
Classes
(C++11)
sub_match
(C++11)
(C++11)
Algorithms
(C++11)
(C++11)
(C++11)
Iterators
(C++11)
(C++11)
Exceptions
(C++11)
Traits
(C++11)
Constants
(C++11)
(C++11)
(C++11)
Regex Grammar
(C++11)
 
std::sub_match
 
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

[edit] Type requirements

-
BidirIt must meet the requirements of LegacyBidirectionalIterator.

[edit] 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>

[edit] Nested types

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>

[edit] Data members

Member Description
bool matched whether this match was successful

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)

[edit] Member functions

This section is incomplete
Reason: Apply LWG 3204, add the swap() member function
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]

[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]

[edit] See also

(C++11)
 iterates through the specified sub-expressions within all regex matches in a given string or through unmatched substrings
(class template) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/regex/sub_match&oldid=177659"