Что значит "сравнивает меньше 0"?

Ответ 1

Да, "объект сравнивает меньше 0" означает, что object < 0 будет давать true. Точно так же compares equal to 0 означает, что object == 0 даст true, а compares greater than 0 означает, что object > 0 даст true.

Что касается того, почему он не использует фразу "меньше 0", я бы предположил, что это подчеркивает, что это все, что гарантировано. Например, это может быть по существу любой произвольный тип, в том числе тот, который на самом деле не представляет фактическое значение, а вместо этого поддерживает только сравнение с 0.

Просто, например, рассмотрим тип примерно так:

class comparison_result {
    enum { LT, GT, EQ } res; 

    friend template <class Integer>
    bool operator<(comparison_result c, Integer) { return c.res == LT; }

    friend template <class Integer>
    bool operator<(Integer, comparison_result c) { return c.res == GT; }

    // and similarly for `>` and `==`
};

[На данный момент предположим, что материал friend template<...> все закончен - я думаю, что вы все равно получите основную идею).

Это вообще не представляет значения. Он просто представляет результат "если по сравнению с 0, если результат будет меньше, равен или больше". Таким образом, это не то, что оно меньше 0, а только то, что оно выражает true или false по сравнению с 0 (но дает те же результаты по сравнению с другим значением).

Относительно того, является ли <0 истинным, означает, что >0 и ==0 должны быть ложными (и наоборот): таких ограничений для типа возврата для самого оператора нет. Язык даже не включает способ указания или применения такого требования. В спецификации нет ничего, чтобы предотвратить их возврат из всех true. Возвращение true для всех сравнений возможно и, кажется, разрешено, но оно, вероятно, довольно надуманное.

Возвращение false для всех из них вполне разумно - просто, например, любые и все сравнения с NaN с плавающей запятой должны нормально возвращать false. NaN означает "Не номер", а то, что не число, не меньше, равно или больше числа. Эти два несравнимы, поэтому в каждом случае ответ (совершенно справедливо) ложный.

Ответ 2

если a < b, затем (a <=> b) < 0

если a == b, тогда (a <=> b) == 0

если a > b, затем (a <=> b) > 0

Он похож на способ обычный memcmp работает.

Ответ 3

"сравнивает < 0" на простом английском языке, "сравнивает меньше нуля".

Это, по-моему, общая сокращенная версия.

Итак, чтобы применить это ко всему предложению, давайте:

Выражение a <= > b возвращает объект, который сравнивает меньше нуля если a меньше b, сравнивается больше нуля, если a больше, чем b и сравнивается с равным нулю, если a и b равны/эквивалентны.

Это довольно глоток. Я понимаю, почему авторы решили использовать символы.

Ответ 4

То, что меня интересует, точнее, является эквивалентным выражением "сравнивает &lt 0". "Сравнивает ли < 0" означает "оценивается с отрицательным числом"?

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

Стандартная формулировка P0515 для языковой функции operator<=> заключается в том, что она возвращает один из 5 возможных типов. Эти типы определяются редакцией библиотеки в P0768.

Эти типы не являются целыми числами. Или даже перечисления. Это типы классов. Это означает, что они имеют точно и только те операции, которые библиотека определяет для них. И их формулировка очень специфична:

Типы категорий сравнения реляционных и равноправных функций друга задаются с анонимным параметром неуказанного типа. Этот тип выбирается реализацией таким образом, что эти параметры могут принимать литерал 0как соответствующий аргумент. [Пример: nullptr_t удовлетворяет этому требованию. - end example] В этом контексте поведение программы, которая предоставляет аргумент, отличный от литерала 0, это undefined.

Следовательно, текст Herb переводится непосредственно в стандартную формулировку: он сравнивает менее 0. Нет больше, не меньше. Не "отрицательное число"; это тип значения, где единственное, что вы можете с ним сделать, это сравнить его с нолем.

Важно отметить, что описательный текст Herb "сравнивает меньше 0" переводит на фактический стандартный текст. Стандартный текст в P0515 дает понять, что результатом 1 <=> 2 является strong_order::less. И стандартный текст в P0768 говорит нам, что strong_order::less < 0 истинно.

Но это также говорит нам, что все другие сравнения являются функциональным эквивалентом описательной фразы "сравнивает меньше 0".

Например, если -1 "сравнивает меньше 0", то это также означает, что оно не сравнивается с равным нулю. И это не сравнивается больше 0. Это также означает, что 0 не сравнивается меньше -1. И так далее.

P0768 говорит нам, что соотношение между strong_order::less и литералом 0 соответствует всем значениям слов "сравнивает меньше 0".

Ответ 5

"a сравнивает меньше нуля" означает, что a < 0 истинно.

"a сравнивает == 0 означает, что a == 0 истинно.

Другие выражения, которые я уверен, теперь имеют смысл?

Ответ 6

Я думаю, что другие ответы до сих пор в основном отвечали, каков результат операции, и это должно быть ясно. Ответ @VTT объясняет это лучше всего, IMO.

Однако пока никто не ответил на английский язык позади него. "Объект сравнивается меньше нуля". просто не стандартный английский, в лучшем случае это жаргон или сленг. Это делает его еще более запутанным для нелокальных носителей.

Эквивалент:
Сравнение объекта с использованием < 0 (меньше нуля) всегда возвращает true.

Это довольно длинный, поэтому я могу понять, почему был создан "ярлык":
Объект сравнивается меньше нуля.

Ответ 7

Это означает, что выражение вернет объект, который можно сравнить с < 0 или > 0 или == 0.

Если a и b являются целыми числами, выражение выражает отрицательное значение (возможно, -1), если a меньше b.

Выражение принимает значение 0, если a == b

И выражение будет оцениваться с положительным значением (возможно, 1), если a больше b.