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

Latest revision as of 01:04, 14 November 2024

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.

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

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

[edit] Non-member functions

operator==operator!=operator<operator<=operator>operator>=operator<=> (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]
operator<<	outputs the matched character subsequence (function template) [edit]

[edit] See also

regex_token_iterator

(C++11)

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

@@ Line 1: / Line 1: @@
 {{cpp/title|sub_match}}
-{{cpp/regex/sub_match/sidebar}}
+{{cpp/regex/sub_match/navbar}}
-{{ddcl | header=regex | notes={{mark c++11 feature}} | 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 [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:  object of this class are normally constructed and populated as a part of a {{cpp|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 {{cpp|matched}} member is {{tt|true}}.
+The member functions return defined default values unless the {{c|matched}} member is {{c|true}}.
-Inherits {{cpp|std::pair<BidirectionalIterator, BidirectionalIterator>}}
+{{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:
-{{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}} | {{cpp|sub_match<const char*>}}}}
+{{dsc|{{tt|std::csub_match}}|{{c/core|std::sub_match<const char*>}}}}
-{{tdcl list item | {{tt|wcsub_match}} | {{cpp|sub_match<const wchar_t*>}}}}
+{{dsc|{{tt|std::wcsub_match}}|{{c/core|std::sub_match<const wchar_t*>}}}}
-{{tdcl list item | {{tt|ssub_match}} | {{cpp|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}} | {{cpp|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}} | {{cpp|BidirectionalIterator}}}}
+{{dsc|{{tt|iterator}}|{{tt|BidirIt}}}}
-{{tdcl list item | {{tt|value_type}} | {{cpp|std::iterator_traits<BidirectionalIterator>::value_type}}}}
+{{dsc|{{tt|value_type}}|{{c/core|std::iterator_traits<BidirIt>::value_type}}}}
-{{tdcl list item | {{tt|difference_type}} | {{cpp|std::iterator_traits<BidirectionalIterator>::difference_type}}}}
+{{dsc|{{tt|difference_type}}|{{c/core|std::iterator_traits<BidirIt>::difference_type}}}}
-{{tdcl list item | {{tt|string_type}} | {{cpp|std::basic_string<value_type>}}}}
+{{dsc|{{tt|string_type}}|{{c/core|std::basic_string<value_type>}}}}
-{{tdcl list end}}
+{{dsc end}}
-===Member functions===
+===Data members===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list mem ctor | cpp/regex/sub_match/sub_match | constructs the match object}}
+{{dsc hitem|Member|Description}}
+{{dsc|{{dsc small|{{c/core|bool}}}} {{tt|matched}}|whether this match was successful}}
+{{dsc end}}
-{{dcl list h2 | Observers}}
+{{inherited|[[cpp/utility/pair|{{small|std::}}pair]]|
-{{dcl list mem fun | cpp/regex/sub_match/length | returns the length of the match, if any}}
+{{dsc begin}}
-{{dcl list mem fun | cpp/regex/sub_match/operator string_type | cast to the underlying string type}}
+{{dsc mem obj|nolink=true|{{dsc small|BidirIt}} first|Start of the match sequence.}}
-{{dcl list mem fun | cpp/regex/sub_match/str | returns the matched subsequence}}
+{{dsc mem obj|nolink=true|{{dsc small|BidirIt}} second|One-past-the-end of the match sequence.}}
-{{dcl list mem fun | cpp/regex/sub_match/compare | compares matched subsequence (if any)}}
+{{dsc end}}
+}}
-{{dcl list h1 | Member objects}}
+===Member functions===
-{{dcl list mem obj | cpp/regex/sub_match/matched | defines whether this match was successful}}{{dcl list end}}
+{{todo|Apply LWG 3204, add the swap() member function}}
+{{dsc begin}}
+{{dsc inc|cpp/regex/sub_match/dsc constructor}}
+{{dsc h2|Observers}}
+{{dsc inc|cpp/regex/sub_match/dsc length}}
+{{dsc inc|cpp/regex/sub_match/dsc str}}
+{{dsc inc|cpp/regex/sub_match/dsc compare}}
+{{dsc end}}
 ===Non-member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/regex/dcl list operator_comp | sub_match}}
+{{dsc inc|cpp/regex/sub_match/dsc operator_cmp}}
-{{dcl list end}}
+{{dsc inc|cpp/regex/sub_match/dsc operator_ltlt}}
+{{dsc end}}
+===See also===
+{{dsc begin}}
+{{dsc inc|cpp/regex/dsc regex_token_iterator}}
+{{dsc end}}
+{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Classes
basic_regex (C++11)
sub_match (C++11)
match_results (C++11)
Algorithms
regex_match (C++11)
regex_search (C++11)
regex_replace (C++11)
Iterators
regex_iterator (C++11)
regex_token_iterator (C++11)
Exceptions
regex_error (C++11)
Traits
regex_traits (C++11)
Constants
syntax_option_type (C++11)
match_flag_type (C++11)
error_type (C++11)
Regex Grammar
Modified ECMAScript-262 (C++11)

Member functions
sub_match::sub_match
sub_match::length
sub_match::strsub_match::operator string_type
sub_match::compare
Non-member functions
operator==operator!=operator<<operator<=operator>operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
operator<<

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>

cppreference.com

Namespaces

Variants

Views

Actions

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

Latest revision as of 01:04, 14 November 2024

Contents

[edit] Type requirements

[edit] Specializations

[edit] Nested types

[edit] Data members

Inherited from std::pair

[edit] Member functions

Observers

[edit] Non-member functions

[edit] See also

Navigation

Toolbox

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	Description
bool `matched`	whether this match was successful