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

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

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

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); } }

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