Если я вручную перегружаю оператор == для структуры, могу ли я получить оператор != бесплатно (предположительно определенный как boolean напротив), или мне нужно перегрузить его вручную (даже если просто return !(this == rhs)?
Изменить. Вопрос не в том, могу ли я перегрузить оба оператора, но должен ли я перегружать неравенство, если я уже перегрузил оператор равенства. Несмотря на это, были даны хорошие ответы.
Перегрузка operator == не дает вам operator !=. Вы должны сделать это вручную, и канонический способ - реализовать его в терминах operator ==, как в !(left == right).
Семантика операторов не продиктована стандартом. Вы могли бы очень сильно перегрузить operator ==, чтобы означать равенство, но перегрузили operator != к чему-то другому, как добавление или даже равенство снова (не то, что это хорошая практика, на самом деле это должно быть обескуражено). Если вы сомневаетесь, сделайте так, как это делают ints...). [См. (1) Ниже]
В стороне примечание Boost.Operators может помочь вам предоставить канонические реализации для операторов. Существует также std::rel_ops с канонической реализацией для operator !=.
(1) Чтобы узнать больше об этом, прочитайте Три основных правила перегрузки оператора на С++.
Нет ничего свободного. Вы платите за то, что используете на С++ (в случае перегрузки оператора).
Вы получаете только Оператора, который больше не перегружаете.
Кроме того, хорошая практика заключается в том, что если вы перегружаете оператор ==, тогда вы должны перегружать !=, а потому, что пользователи вашего класса ожидают, что они будут доступны.
Перегрузка оператора Часто задаваемые вопросы по С++ должны быть хорошо прочитаны.
Отвечая на обновленный Вопрос:
Вопрос не в том, могу ли я МОЖЕТ перегрузить оба оператора, но должен ли я перегружать неравенство, если я уже перегрузил оператор равенства.
NO.
Нет такого требования, чтобы вы Must перегружались != Если вам нужно перегрузить ==. Тем не менее, это хорошая практика, когда вы должны перегружать операторы, связанные друг с другом.
Почему это хорошая практика?
Подумайте об этом с точки зрения пользователя вашего класса. Если пользователь вашего класса может использовать == (критерии равенства) для сравнения объектов вашего класса, естественно, они ожидают, что они также смогут использовать != (критерии неравновесия), это проистекает из тот факт, что эти два оператора тесно связаны и поддерживаются для всех встроенных типов.
Что произойдет, если вы проигнорируете should, а не перегружаете != при перегрузке ==?
Если пользователи вашего класса используют !=, они получат ошибку компиляции.
Они немного нахмурились в том, что не были предоставлены !=, когда они снабжены ==, и им придется перестроить свою логику, чтобы использовать == вместо !=.
Таким образом, вы можете жить с ним, но будьте готовы ожидать нескольких хмуриться и жаловаться на неудобства и не предоставлять удобный интерфейс.
Вам нужно перегрузить каждого оператора.!= и == не связаны.
Это не так, и, к счастью, так оно и есть. Например, вам может понадобиться структура, где оба a!= B и a == a верны. Они не обязательно обратные, они могут быть любыми, что вы хотите.
Увеличивает творческий потенциал.:)
Например, если вы не знаете результат сравнения или, как правило, не знаете, тогда было бы разумно, чтобы == b и a!= b возвращали то же самое.