Перегрузка операторов сравнения

Что является лучшей практикой (в данном случае):

bool Foo::operator==(const Foo& other) {
  return bar == other.bar;
}

// Implementation 1
bool Foo::operator!=(const Foo& other) {
  return bar != other.bar
}

// Implementation 2
bool Foo::operator!=(const Foo& other) {
  return !(*this == other);
}

Для таких операторов, как > , <, < =, > =, я мог бы пойти с реализацией 2, когда это возможно. Тем не менее, для!= Я думаю, что реализация 1 лучше, поскольку другой вызов метода не выполняется, правильно ли это?

Ответ 1

Вторая реализация имеет заметное ограничение, что == всегда будет логическим, противоположным !=. Это, вероятно, то, что вы хотите, и это упрощает работу с вашим кодом, потому что вам нужно только изменить одну реализацию, чтобы синхронизировать два.

Ответ 2

Вы всегда должны использовать то, что у вас есть при перегрузке операторов сравнения. Вам нужно определить только два: operator== и operator<. Остальное вы можете написать в терминах этих двух. Это менее подвержено ошибкам, как будто у вас есть ошибка, это только в одном месте.

Одной из основных особенностей ООП является повторное использование кода. Если вы уже написали код, зачем писать его снова? Придерживайтесь того, что у вас есть, и у вас будет только одна вещь для проверки.

Это скорее как объявление константы, а затем ее использование в нескольких местах в вашем файле.

Ответ 3

Реализация 2 лучше, потому что она использует уже определенный оператор ==. Также эти функции оператора должны быть const, потому что они не изменяют объект.

Ответ 4

Ничего из перечисленного.

Мне бы хотелось найти статью, которая действительно подробно описывает это, но я не могу вспомнить имя.

Ваши операции сравнения должны быть внешними. Ваш интерфейс должен быть достаточным для нахождения состояния объекта, а состояние объекта должно диктовать сравнение. Должно быть возможно писать "равно" вне вашего класса, и, таким образом, любое сравнение действительно, и что возможно... вы хотите.

Ответ 5

В целом реализация 2 лучше по многим причинам. Прежде всего, вы не пишете (почти) дубликат кода. Если вам нужно изменить его (потому что класс вырос или была ошибка), снова с реализацией 2 вы меняете только 1 место. То есть, реализация 2 делает ваш код более последовательным и менее подверженным ошибкам.