◐ Shell
clean mode source ↗

operator==,!=,<,<=,>,>=,<=>(std::sub_match) - cppreference.com

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.

8-20) Compares a sub_match with a std::basic_string.

21-33) Compares a sub_match with a C-style string.

34-46) Compares a sub_match with a single character.

48) cat-type-of <BidirIt> is the result type of three-way comparison of std::sub_match<BidirIt>.

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.

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.