Перегрузки оператора равенства: Is (x! = Y) == (! (X == y))?

_{Я надеюсь, что это не дубликат — я искал другие вопросы относительно операторов равенства, но кроме некоторых комментариев в связанных вопросах, я не нашел определенного утверждения}

ТЛ; др:

Гарантирует ли стандарт C ++, что (x!=y) всегда имеет то же значение истинности, что и !(x==y)?

Я знаю, что есть много Здесь задействованы тонкости: операторы == а также != может быть перегружен. Они могут быть перегружены, чтобы иметь разные типы возврата (которые должны быть неявно преобразованы в bool). Даже !-оператор может быть перегружен в типе возврата. Вот почему я неукоснительно ссылался на «значение истины» выше, но пытаясь уточнить его, используя неявное преобразование в boolи пытается устранить возможные неясности:

bool ne = (x!=y);
bool e = (x==y);
bool result = (ne == (!e));

Является result гарантированно будет true Вот?

Стандарт C ++ определяет операторы равенства в разделе 5.10, но в основном, кажется, определяет их синтаксически (и некоторая семантика относительно сравнения указателей). концепция быть EqualityComparable существует, но нет специального заявления об отношениях его оператора == к != оператор.

Существуют соответствующие документы из рабочих групп C ++, говоря это…

Важно, чтобы равные / неравные […] вели себя как булевы отрицания друг друга. В конце концов, мир не будет иметь смысла, если оба оператора == () и оператор! = () Вернули false! Таким образом, эти операторы часто используются в терминах друг друга.

Тем не менее, это только отражает здравый смысл ™, и не уточнить что они должны быть реализованы так.

_{Немного предыстории: я просто пытаюсь написать функцию, которая проверяет, равны ли два значения (неизвестного типа), и выводить сообщение об ошибке, если это не так. Я хотел бы сказать, что необходимая концепция здесь заключается в том, что типы EqualityComparable, Но для этого все равно придется писать if (!(x==y)) {...} и мог не записывать if (x!=y) {...}потому что это будет использовать другой оператор, который не охватывается концепцией EqualityComparable вообще, и который может быть даже перегружен по-другому …}

Я знаю, что программист в основном Можно делать все, что он хочет в его пользовательских перегрузок. Мне просто интересно, действительно ли он позволил делать все или есть ли правила, навязанные стандартом. Может быть, одно из этих тонких утверждений, предполагающих, что отклонение от обычной реализации вызывает неопределенное поведение, например, такое, которое NathanOliver упоминается в комментарии, но, похоже, относится только к определенным типам. Например, стандарт эксплицитно утверждает, что для типы контейнеров, a!=b эквивалентно !(a==b) (раздел 23.2.1, таблица 95, «Требования к контейнерам»).

Но для общих пользовательских типов в настоящее время кажется, что таких требований нет. Вопрос помечен language-lawyerпотому что я надеялся на определенное утверждение / ссылку, но я знаю, что это может быть почти невозможно: хотя можно указать на раздел, где говорится, что операторы иметь чтобы быть отрицанием друг друга, вряд ли можно доказать, что ни одна из ~ 1500 страниц стандарта не говорит что-то подобное …

Сомневаюсь, и если не будет дальнейших намеков, я буду голосовать / принимать соответствующие ответы позже, а пока предположим, что для сравнения неравенства для EqualityComparable типы должны быть сделаны с if (!(x==y)) быть на безопасной стороне.