std::rel_ops::operators

template< class T >
bool operator!=( const T& lhs, const T& rhs );

template< class T >
bool operator>( const T& lhs, const T& rhs );

template< class T >
bool operator<=( const T& lhs, const T& rhs );

template< class T >
bool operator>=( const T& lhs, const T& rhs );

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

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

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

namespace rel_ops {
    template< class T >
    bool operator>( const T& lhs, const T& rhs ) 
    {
        return rhs < lhs;
    }
}

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

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.

Example

#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';
}

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