operator==,!=,<,<=,>,>=,<=>(std::sub_match)

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Textverarbeitungsbibliothek

Lokalisierungsbibliothek

Reguläre Ausdrücke-Bibliothek (C++11)

Formatierungsbibliothek (C++20)

Dienstprogramme für Null-terminierte Sequenzen

Byte-Zeichenketten

Multibyte-Zeichenketten

Wide-Zeichenketten

Primitive numerische Konvertierungen

to_chars (C++17) to_chars_result (C++17) from_chars (C++17) from_chars_result (C++17) chars_format (C++17)

Textkodierungserkennung

text_encoding (C++26)

 

Bibliothek für reguläre Ausdrücke

Klassen

basic_regex (C++11)

sub_match (C++11)

match_results (C++11)

Algorithmen

regex_match (C++11)

regex_search (C++11)

regex_replace (C++11)

Iteratoren

regex_iterator (C++11)

regex_token_iterator (C++11)

Ausnahmen

regex_error (C++11)

Traits

regex_traits (C++11)

Konstanten

syntax_option_type (C++11)

match_flag_type (C++11)

error_type (C++11)

Reguläre Ausdrucksgrammatiken

Modifizierte ECMAScript-262 (C++11)

 

std::sub_match

Memberfunktionen

sub_match::sub_match

sub_match::length

sub_match::strsub_match::operator string_type

sub_match::compare

sub_match::swap

Nicht-Member-Funktionen

operator==operator!=operator<<operator<=operator>operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20)

operator<<

 

Definiert in Header <regex>
Direkter Vergleich
template< class BidirIt > bool operator== ( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(1)	(seit C++11)
template< class BidirIt > bool operator!= ( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(2)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<  ( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(3)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<= ( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(4)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>  ( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(5)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>= ( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(6)	(seit C++11) (bis C++20)
template< class BidirIt > auto operator<=>( const std::sub_match<BidirIt>& lhs,                   const std::sub_match<BidirIt>& rhs );	(7)	(seit C++20)
Vergleich mit einem std::basic_string
template< class BidirIt, class Traits, class Alloc > bool operator== ( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(8)	(seit C++11)
template< class BidirIt, class Traits, class Alloc > bool operator!= ( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(9)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator<  ( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(10)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator<= ( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(11)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator>  ( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(12)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator>= ( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(13)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > auto operator<=>( const std::sub_match<BidirIt>& lhs,                   const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str );	(14)	(seit C++20)
template< class BidirIt, class Traits, class Alloc > bool operator== ( const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str,                   const std::sub_match<BidirIt>& rhs );	(15)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator!= ( const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str,                   const std::sub_match<BidirIt>& rhs );	(16)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator<  ( const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str,                   const std::sub_match<BidirIt>& rhs );	(17)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator<= ( const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str,                   const std::sub_match<BidirIt>& rhs );	(18)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator>  ( const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str,                   const std::sub_match<BidirIt>& rhs );	(19)	(seit C++11) (bis C++20)
template< class BidirIt, class Traits, class Alloc > bool operator>= ( const std::basic_string</*value-type-of*/<BidirIt>,                                           Traits, Alloc>& str,                   const std::sub_match<BidirIt>& rhs );	(20)	(seit C++11) (bis C++20)
Vergleich mit einem C-String
template< class BidirIt > bool operator== ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(21)	(seit C++11)
template< class BidirIt > bool operator!= ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(22)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<  ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(23)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<= ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(24)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>  ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(25)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>= ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(26)	(seit C++11) (bis C++20)
template< class BidirIt > auto operator<=>( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>* s );	(27)	(seit C++20)
template< class BidirIt > bool operator== ( const /*value-type-of*/<BidirIt>* s,                   const std::sub_match<BidirIt>& rhs );	(28)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator!= ( const /*value-type-of*/<BidirIt>* s,                   const std::sub_match<BidirIt>& rhs );	(29)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<  ( const /*value-type-of*/<BidirIt>* s,                   const std::sub_match<BidirIt>& rhs );	(30)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<= ( const /*value-type-of*/<BidirIt>* s,                   const std::sub_match<BidirIt>& rhs );	(31)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>  ( const /*value-type-of*/<BidirIt>* s,                   const std::sub_match<BidirIt>& rhs );	(32)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>= ( const /*value-type-of*/<BidirIt>* s,                   const std::sub_match<BidirIt>& rhs );	(33)	(seit C++11) (bis C++20)
Vergleich mit einem einzelnen Zeichen
template< class BidirIt > bool operator== ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(34)	(seit C++11)
template< class BidirIt > bool operator!= ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(35)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<  ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(36)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<= ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(37)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>  ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(38)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>= ( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(39)	(seit C++11) (bis C++20)
template< class BidirIt > auto operator<=>( const std::sub_match<BidirIt>& lhs,                   const /*value-type-of*/<BidirIt>& ch );	(40)	(seit C++20)
template< class BidirIt > bool operator== ( const /*value-type-of*/<BidirIt>& ch,                   const std::sub_match<BidirIt>& rhs );	(41)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator!= ( const /*value-type-of*/<BidirIt>& ch,                   const std::sub_match<BidirIt>& rhs );	(42)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<  ( const /*value-type-of*/<BidirIt>& ch,                   const std::sub_match<BidirIt>& rhs );	(43)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator<= ( const /*value-type-of*/<BidirIt>& ch,                   const std::sub_match<BidirIt>& rhs );	(44)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>  ( const /*value-type-of*/<BidirIt>& ch,                   const std::sub_match<BidirIt>& rhs );	(45)	(seit C++11) (bis C++20)
template< class BidirIt > bool operator>= ( const /*value-type-of*/<BidirIt>& ch,                   const std::sub_match<BidirIt>& rhs );	(46)	(seit C++11) (bis C++20)
Hilfstypalias
template< class BidirIt > using /*value-type-of*/ =     typename std::iterator_traits<BidirIt>::value_type;	(47)	(nur Exposition*)
template< class BidirIt > using /*cat-type-of*/ =     std::compare_three_way_result_t         <std::basic_string</*value-type-of*/<BidirIt>>>;	(48)	(seit C++20) (nur Exposition*)

Vergleicht einen sub_match mit einem anderen sub_match, einem std::basic_string, einem C-String oder einem einzelnen Zeichen.

1-7) Vergleicht zwei sub_match direkt.

8-20) Vergleicht einen sub_match mit einem std::basic_string.

21-33) Vergleicht einen sub_match mit einem C-String.

34-46) Vergleicht einen sub_match mit einem einzelnen Zeichen.

Die Operatoren <, <=, >, >= und != sind synthetisiert aus operator<=> und operator== beziehungsweise.

(seit C++20)

47) value-type-of <BidirIt> ist der Werttyp von BidirIt.

48) cat-type-of <BidirIt> ist der Ergebnistyp des Drei-Wege-Vergleichs von std::sub_match<BidirIt>.

Parameter

lhs, rhs	-	Ein zu vergleichender sub_match
str	-	Ein zu vergleichendes std::basic_string
s	-	Ein Zeiger auf einen zu vergleichenden C-String
ch	-	Ein zu vergleichendes Zeichen

Rückgabewert

Sei target die folgenden Werte

1-7) rhs

8-20) typename std::sub_match<BidirIt>::string_type(str.data(), str.size())

21-33) s

34-46) typename std::sub_match<BidirIt>::string_type(1, ch)

Die Rückgabewerte sind wie folgt definiert

Operator	Rückgabewert
	Überladungen (1-14,21-27,34-40) (Überladungen mit Parameter lhs)	Überladungen (15-20,28-33,41-46)       (Überladungen ohne Parameter lhs)
==	lhs.compare(target) == 0	rhs.compare(target) == 0
!=	lhs.compare(target) != 0	rhs.compare(target) != 0
<	lhs.compare(target) < 0	rhs.compare(target) > 0
<=	lhs.compare(target) <= 0	rhs.compare(target) >= 0
>	lhs.compare(target) > 0	rhs.compare(target) < 0
>=	lhs.compare(target) >= 0	rhs.compare(target) <= 0
<=>	static_cast<cat-type-of <BidirIt>>     (lhs.compare(target) <=> 0)	N/A

Anmerkungen

Der Rückgabetyp von operator<=> ist garantiert ein Vergleichskategorientyp. Wenn value-type-of <BidirIt> char, wchar_t, char8_t, char16_t oder char32_t ist, ist der Rückgabetyp von operator<=> std::strong_ordering.

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2217	C++11	Bei Vergleichen mit std::string war das Argument von compare() str.c_str()	Das Argument ist string_type(str.data(), str.size()))

Siehe auch

compare

vergleicht übereinstimmende Teilsequenz (falls vorhanden) (public member function)