std::rel_op...rator!=,>,=(3)

💅 std::rel_op...rator!=,>,=(3) 💅

okay so bestie, welcome to the std::rel_op...rator!=,>,= page, straight out of the C++ Standard Libary manual — section 3, and yes the header really spells it “Libary,” we’re keeping the lore. this one is a little deprecated-era time capsule and it’s honestly iconic.

---

💖 NAME 💖

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

yes, that’s the whole name, twice, because the manual said so and we respect the bit.

🌸 Synopsis 🌸

Defined in header <utility>:

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

Given a user-defined operator== and operator< for objects of type T, these implement the usual semantics of the other comparison operators. it’s giving “derive the whole friend group from two core operators” energy, fr.

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 🛠️

(1) operator!=

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

(2) operator>

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

(3) operator<=

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

(4) operator>=

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.

heads up, bestie: as of C++20, std::rel_ops are deprecated in favor of operator<=>. so this is very “still cute, but the new shiny thing exists” energy.

🍓 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
              << "{1} != {2} : " << (f1 != f2) << '\n'
              << "{1} >  {2} : " << (f1 >  f2) << '\n'
              << "{1} <= {2} : " << (f1 <= f2) << '\n'
              << "{1} >= {2} : " << (f1 >= f2) << '\n';
}

🌈 Output 🌈

{1} != {2} : true
{1} >  {2} : false
{1} <= {2} : true
{1} >= {2} : false

okay that’s the whole page, bestie. source/version: http://cppreference.com; date: 2024.06.10; page: std::rel_op...rator!=,>,=(3). mwah 💋 byeee 💖