Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | regex
m (+seealso to regex_token_iterator, +missing op<<)
m (Minor tweak.)
 
(17 intermediate revisions by 7 users not shown)
Line 1: Line 1:
 
{{cpp/title|sub_match}}
 
{{cpp/title|sub_match}}
−
{{cpp/regex/sub_match/sidebar}}
+
{{cpp/regex/sub_match/navbar}}
−
{{ddcl | header=regex | notes={{mark since c++11}} | 1=
+
{{ddcl|header=regex|since=c++11|
−
template<
+
template< class BidirIt >
−
    class BidirectionalIterator
+
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 {{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|sub_match}} are normally constructed and populated as a part of a {{c|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<BidirectionalIterator, BidirectionalIterator>}}, although it cannot be treated as a {{c|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===
 +
{{par begin}}
 +
{{par req named|BidirIt|BidirectionalIterator}}
 +
{{par end}}
 +
 +
===Specializations===
 
Several specializations for common character sequence types are provided:  
 
Several specializations for common character sequence types are provided:  
  
−
{{tdcl list begin}}
+
{{dsc begin}}
−
{{tdcl list header | regex}}
+
{{dsc header|regex}}
−
{{tdcl list hitem | Type | Definition}}
+
{{dsc hitem|Type|Definition}}
−
{{tdcl list item | {{tt|csub_match}} | {{c|sub_match<const char*>}}}}
+
{{dsc|{{tt|std::csub_match}}|{{c/core|std::sub_match<const char*>}}}}
−
{{tdcl list item | {{tt|wcsub_match}} | {{c|sub_match<const wchar_t*>}}}}
+
{{dsc|{{tt|std::wcsub_match}}|{{c/core|std::sub_match<const wchar_t*>}}}}
−
{{tdcl list item | {{tt|ssub_match}} | {{c|sub_match<std::string::const_iterator>}}}}
+
{{dsc|{{tt|std::ssub_match}}|{{c/core|std::sub_match<std::string::const_iterator>}}}}
−
{{tdcl list item | {{tt|wssub_match}} | {{c|sub_match<std::wstring::const_iterator>}}}}
+
{{dsc|{{tt|std::wssub_match}}|{{c/core|std::sub_match<std::wstring::const_iterator>}}}}
−
{{tdcl list end}}
+
{{dsc end}}
  
−
===Member types===
+
===Nested types===
−
{{tdcl list begin}}
+
{{dsc begin}}
−
{{tdcl list hitem | Member type | Definition}}
+
{{dsc hitem|Type|Definition}}
−
{{tdcl list item | {{tt|iterator}} | {{c|BidirectionalIterator}}}}
+
{{dsc|{{tt|iterator}}|{{tt|BidirIt}}}}
−
{{tdcl list item | {{tt|value_type}} | {{c|std::iterator_traits<BidirectionalIterator>::value_type}}}}
+
{{dsc|{{tt|value_type}}|{{c/core|std::iterator_traits<BidirIt>::value_type}}}}
−
{{tdcl list item | {{tt|difference_type}} | {{c|std::iterator_traits<BidirectionalIterator>::difference_type}}}}
+
{{dsc|{{tt|difference_type}}|{{c/core|std::iterator_traits<BidirIt>::difference_type}}}}
−
{{tdcl list item | {{tt|string_type}} | {{c|std::basic_string<value_type>}}}}
+
{{dsc|{{tt|string_type}}|{{c/core|std::basic_string<value_type>}}}}
−
{{tdcl list end}}
+
{{dsc end}}
  
−
===Member objects===
+
===Data members===
−
{{tdcl list begin}}
+
{{dsc begin}}
−
{{dcl list item| {{tt|matched}} | Indicates if this match was successful.}}
+
{{dsc hitem|Member|Description}}
−
{{tdcl list end}}
+
{{dsc|{{dsc small|{{c/core|bool}}}} {{tt|matched}}|whether this match was successful}}
−
{{inherited | [[cpp/utility/pair | {{small|std::}}pair]] |
+
{{dsc end}}
−
{{tdcl list begin}}
+
 
−
{{dcl list item| {{tt|first}} | Start of the match sequence.}}
+
{{inherited|[[cpp/utility/pair|{{small|std::}}pair]]|
−
{{dcl list item| {{tt|second}} | One-past-the-end of the match sequence.}}
+
{{dsc begin}}
−
{{tdcl list end}}
+
{{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 end}}
 
}}
 
}}
  
 
===Member functions===
 
===Member functions===
−
{{dcl list begin}}
+
{{todo|Apply LWG 3204, add the swap() member function}}
−
{{dcl list template | cpp/regex/sub_match/dcl list constructor}}
+
{{dsc begin}}
 +
{{dsc inc|cpp/regex/sub_match/dsc constructor}}
  
−
{{dcl list h2 | Observers}}
+
{{dsc h2|Observers}}
−
{{dcl list template | cpp/regex/sub_match/dcl list length}}
+
{{dsc inc|cpp/regex/sub_match/dsc length}}
−
{{dcl list template | cpp/regex/sub_match/dcl list str}}
+
{{dsc inc|cpp/regex/sub_match/dsc str}}
−
{{dcl list template | cpp/regex/sub_match/dcl list compare}}
+
{{dsc inc|cpp/regex/sub_match/dsc compare}}
−
{{dcl list end}}
+
{{dsc end}}
  
 
===Non-member functions===
 
===Non-member functions===
−
{{dcl list begin}}
+
{{dsc begin}}
−
{{dcl list template | cpp/regex/dcl list operator_cmp | sub_match}}
+
{{dsc inc|cpp/regex/sub_match/dsc operator_cmp}}
−
{{dcl list tfun | cpp/regex/sub_match/operator_ltlt | title=operator<< | outputs the matched character subsequence}}
+
{{dsc inc|cpp/regex/sub_match/dsc operator_ltlt}}
−
{{dcl list end}}
+
{{dsc end}}
  
 
===See also===
 
===See also===
−
{{dcl list begin}}
+
{{dsc begin}}
−
{{dcl list tclass | cpp/regex/regex_token_iterator | iterates through regex submatches | notes={{mark c++11}}}}
+
{{dsc inc|cpp/regex/dsc regex_token_iterator}}
−
{{dcl list end}}
+
{{dsc end}}
 +
 
 +
{{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"