Question: If I manually overload the `==` operator for a structure, do I get the `!=` operator for free (presumably defined to be the boolean opposite), or do I have to overload it manually (even if to just `return !(this == rhs)`?

Edit-The question is not whether or not I CAN overload both operators, but whether I must overload inequality if I've already overloaded the equality operator. Regardless, good answers have been given.

Answer: 
Overloading `operator ==` does not give you `operator !=`. You have to do it manually and the canonical way is to implement it in terms of `operator ==` as in `!(left == right)`.

The semantics of the operators are not dictated by the standard. You could very well overload `operator ==` to mean equality yet overload `operator !=` to something different like addition or even equality again *(not that this is a good practice, in fact it should be discouraged. When in doubt, do as the ints do...)*.[Refer (1) Below]

On a side note, `Boost.Operators` can help you provide canonical implementations for operators. There is also `std::rel_ops` with a canonical implementation for `operator !=`.

(1) To know more about it read **[Three basic rules of operator overloading in C++.](https://stackoverflow.com/questions/4421706/operator-overloading/4421708#4421708)**
No nothing is for free. You pay for what you use in C++(in case of Operator Overloading).  

You only get the Operator which you overload nothing more. 

Also, It is a good practice that if you overload `==` operator then you should overload `!=` as well because the users of your class will expect that to be available.

**[Operator Overloading](https://stackoverflow.com/questions/4421706/operator-overloading/4421708)** C++ FAQ should be a good read.

---

Answering the updated Question:

> 
> The question is not whether or not I CAN overload both operators, but whether I must overload inequality if I've already overloaded the equality operator. 
> 
> 
> 

**NO.**  

There is no such requirement that you **Must** overload `!=` If you need to overload `==`. However,it is a good practice that you **Should** overload operators *related* to each other. 

**Why is it a good practice?**  

Think it from the perspective of the user of your class. If the user of your class can use `==`(equality criteria) to compare objects of your class, naturally they are going to expect that they should be able to use `!=`(Non-equality criteria) as well, this stems from the fact that these two operators are related closely and supported for all built-in tyes. 

**What happens if you disregard the `should` and not overload `!=` when you overload `==`?**  

If the users of your class use `!=` they will get a compile error.  

They would frown a bit about not being provided with `!=` when they are provided with `==` and they will have to realign their logic to use `==` instead of the `!=`. 

So you can live with it but be ready to expect a few frowns and complaints of inconvinience and not providing user friendly interface.