std::rel_ops::operator!=,>,<=,>=

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Library feature-test macros
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
integer_sequence (C++14)
Relational operators (deprecated in C++20)
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Comparisons (C++20)
strong_order weak_order partial_order strong_equal weak_equal	strong_ordering weak_ordering partial_ordering strong_equality weak_equality	is_eqis_neqis_ltis_lteqis_gtis_gteq
common_comparison_category
Common vocabulary types
pair tuple (C++11) apply (C++17) make_from_tuple (C++17)	optional (C++17) any (C++17) variant (C++17)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)
launder (C++17)

 

Defined in header <utility>
template< class T > bool operator!=( const T& lhs, const T& rhs );	(1)	(deprecated in C++20)
template< class T > bool operator>( const T& lhs, const T& rhs );	(2)	(deprecated in C++20)
template< class T > bool operator<=( const T& lhs, const T& rhs );	(3)	(deprecated in C++20)
template< class T > bool operator>=( const T& lhs, const T& rhs );	(4)	(deprecated in C++20)

Given a user-defined operator== and operator< for objects of type T, implements the usual semantics of other comparison operators.

1) Implements operator!= in terms of operator==.

2) Implements operator> in terms of operator<.

3) Implements operator<= in terms of operator<.

4) Implements operator>= in terms of operator<.

Parameters

lhs	-	left-hand argument
rhs	-	right-hand argument

Return value

1) Returns true if lhs is not equal to rhs.

2) Returns true if lhs is greater than rhs.

3) Returns true if lhs is less or equal to rhs.

4) Returns true if lhs is greater or equal to rhs.

Possible implementation

First version
namespace rel_ops { template< class T > bool operator!=( const T& lhs, const T& rhs ) { return !(lhs == rhs); } }
Second version
namespace rel_ops { template< class T > bool operator>( const T& lhs, const T& rhs ) { return rhs < lhs; } }
Third version
namespace rel_ops { template< class T > bool operator<=( const T& lhs, const T& rhs ) { return !(rhs < lhs); } }
Fourth version
namespace rel_ops { template< class T > bool operator>=( const T& lhs, const T& rhs ) { return !(lhs < rhs); } }

Notes

Boost.operators provides a more versatile alternative to std::rel_ops

As of C++20, std::rel_ops are deprecated in favor of operator<=>.

Example

Run this code

#include <iostream>
#include <utility>
 
struct Foo {
    int n;
};
 
bool operator==(const Foo& lhs, const Foo& rhs)
{
    return lhs.n == rhs.n;
}
 
bool operator<(const Foo& lhs, const Foo& rhs)
{
    return lhs.n < rhs.n;
}
 
int main()
{
    Foo f1 = {1};
    Foo f2 = {2};
    using namespace std::rel_ops;
 
    std::cout << std::boolalpha;
    std::cout << "not equal?     : " << (f1 != f2) << '\n';
    std::cout << "greater?       : " << (f1 > f2) << '\n';
    std::cout << "less equal?    : " << (f1 <= f2) << '\n';
    std::cout << "greater equal? : " << (f1 >= f2) << '\n';
}

Output:

not equal?     : true
greater?       : false
less equal?    : true
greater equal? : false