# Comparison operators

suggest changeYou can overload all comparison operators:

`==`

and`!=`

`\>`

and`\<`

`>=`

and`<=`

The recommended way to overload all those operators is by implementing only 2 operators (`==`

and `\<`

) and then using those to define the rest. Scroll down for explanation

Overloading outside of `class`

/`struct`

:

```
//Only implement those 2
bool operator==(const T& lhs, const T& rhs) { /* Compare */ }
bool operator<(const T& lhs, const T& rhs) { /* Compare */ }
//Now you can define the rest
bool operator!=(const T& lhs, const T& rhs) { return !(lhs == rhs); }
bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; }
bool operator<=(const T& lhs, const T& rhs) { return !(lhs > rhs); }
bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); }
```

Overloading inside of `class`

/`struct`

:

```
//Note that the functions are const, because if they are not const, you wouldn't be able
//to call them if the object is const
//Only implement those 2
bool operator==(const T& rhs) const { /* Compare */ }
bool operator<(const T& rhs) const { /* Compare */ }
//Now you can define the rest
bool operator!=(const T& rhs) const { return !(*this == rhs); }
bool operator>(const T& rhs) const { return rhs < *this; }
bool operator<=(const T& rhs) const { return !(*this > rhs); }
bool operator>=(const T& rhs) const { return !(*this < rhs); }
```

The operators obviously return a `bool`

, indicating `true`

or `false`

for the corresponding operation.

All of the operators take their arguments by `const&`

, because the only thing that does operators do is compare, so they shouldn’t modify the objects. Passing by `&`

(reference) is faster than by value, and to make sure that the operators don’t modify it, it is a `const`

-reference.

Note that the operators inside the `class`

/`struct`

are defined as `const`

, the reason for this is that without the functions being `const`

, comparing `const`

objects would not be possible, as the compiler doesn’t know that the operators don’t modify anything.