operator==,!=,<,<=,>,>=,<=>(std::sub_match) - cppreference.com (original) (raw)
| Defined in header | ||
|---|---|---|
| Direct comparison | ||
| template< class BidirIt > bool operator== ( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (1) | (since C++11) |
| template< class BidirIt > bool operator!= ( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (2) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator< ( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (3) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator<= ( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (4) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator> ( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (5) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator>= ( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (6) | (since C++11) (until C++20) |
| template< class BidirIt > auto operator<=>( const std::sub_match<BidirIt>& lhs, const std::sub_match<BidirIt>& rhs ); | (7) | (since C++20) |
| Comparing with a 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) | (since 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until 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) | (since C++11) (until C++20) |
| Comparing with a C-style string | ||
| template< class BidirIt > bool operator== ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (21) | (since C++11) |
| template< class BidirIt > bool operator!= ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (22) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator< ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (23) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator<= ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (24) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator> ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (25) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator>= ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (26) | (since C++11) (until C++20) |
| template< class BidirIt > auto operator<=>( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>* s ); | (27) | (since C++20) |
| template< class BidirIt > bool operator== ( const /*value-type-of*/<BidirIt>* s, const std::sub_match<BidirIt>& rhs ); | (28) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator!= ( const /*value-type-of*/<BidirIt>* s, const std::sub_match<BidirIt>& rhs ); | (29) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator< ( const /*value-type-of*/<BidirIt>* s, const std::sub_match<BidirIt>& rhs ); | (30) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator<= ( const /*value-type-of*/<BidirIt>* s, const std::sub_match<BidirIt>& rhs ); | (31) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator> ( const /*value-type-of*/<BidirIt>* s, const std::sub_match<BidirIt>& rhs ); | (32) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator>= ( const /*value-type-of*/<BidirIt>* s, const std::sub_match<BidirIt>& rhs ); | (33) | (since C++11) (until C++20) |
| Comparing with a single character | ||
| template< class BidirIt > bool operator== ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (34) | (since C++11) |
| template< class BidirIt > bool operator!= ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (35) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator< ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (36) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator<= ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (37) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator> ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (38) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator>= ( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (39) | (since C++11) (until C++20) |
| template< class BidirIt > auto operator<=>( const std::sub_match<BidirIt>& lhs, const /*value-type-of*/<BidirIt>& ch ); | (40) | (since C++20) |
| template< class BidirIt > bool operator== ( const /*value-type-of*/<BidirIt>& ch, const std::sub_match<BidirIt>& rhs ); | (41) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator!= ( const /*value-type-of*/<BidirIt>& ch, const std::sub_match<BidirIt>& rhs ); | (42) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator< ( const /*value-type-of*/<BidirIt>& ch, const std::sub_match<BidirIt>& rhs ); | (43) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator<= ( const /*value-type-of*/<BidirIt>& ch, const std::sub_match<BidirIt>& rhs ); | (44) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator> ( const /*value-type-of*/<BidirIt>& ch, const std::sub_match<BidirIt>& rhs ); | (45) | (since C++11) (until C++20) |
| template< class BidirIt > bool operator>= ( const /*value-type-of*/<BidirIt>& ch, const std::sub_match<BidirIt>& rhs ); | (46) | (since C++11) (until C++20) |
| Helper type aliases | ||
| template< class BidirIt > using /*value-type-of*/ = typename std::iterator_traits<BidirIt>::value_type; | (47) | (exposition only*) |
| template< class BidirIt > using /*cat-type-of*/ = std::compare_three_way_result_t <std::basic_string</*value-type-of*/<BidirIt>>>; | (48) | (since C++20) (exposition only*) |
Compares a sub_match to another sub_match, a std::string, a C-style string or a single character.
1-7) Compares two sub_match directly.
21-33) Compares a sub_match with a C-style string.
34-46) Compares a sub_match with a single character.
| The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively. | (since C++20) |
|---|
_value-type-of_<BidirIt> is the value type ofBidirIt._cat-type-of_<BidirIt> is the result type of three-way comparison of std::sub_match<BidirIt>.
[edit] Parameters
| lhs, rhs | - | a sub_match to compare |
|---|---|---|
| str | - | a std::basic_string to compare |
| s | - | a pointer to a C-style string to compare |
| ch | - | a character to compare |
[edit] Return value
Let target be the following values:
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)
The return values are defined as follows:
| Operator | Return value | |
|---|---|---|
| Overloads (1-14,21-27,34-40)(overloads with parameter lhs) | Overloads (15-20,28-33,41-46) (overloads without 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 |
[edit] Notes
The return type of operator<=> is guaranteed to be a comparison category type. If _value-type-of_ <BidirIt> is char, wchar_t, char8_t, char16_t, or char32_t, the return type of operator<=> is std::strong_ordering.
[edit] Example
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 2217 | C++11 | for comparisons with std::string, theargument of compare() was str.c_str() | the argument isstring_type(str.data(), str.size())) |
[edit] See also
| | compares matched subsequence (if any) (public member function) [edit] | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |