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

Контекст

Пока я читал * Согласованное сравнение, я заметил странное использование глагола для сравнения:

Появился новый трехсторонний оператор сравнения, <=>;;. Выражение a <=> b возвращает объект, который сравнивает <0, если a , сравнивает >0, если a> b, и сравнивает ==0, если a и b равны / эквивалентны.

Другой пример, найденный где-то в интернете (выделено мной):

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

Последний пример, найденный в исходном коде на GitHub (выделено мной):

// Выполнить круговое 16-битное сравнение.
// Если расстояние между двумя числами больше 32767,
// и числа больше 32768, вычитаем 65536
// Таким образом, 65535 сравнивает меньше 0, но больше 65534
// Это правильно обрабатывает 65535->0

Конечно, для опытных программистов смысл этих выражений понятен. Но использование глагола для сравнения не соответствует синтаксическим правилам грамматики английского языка. Это жаргон

Вопросы **

  • Что значит сказать, что объект сравнивается меньше нуля? Означает ли это, что если объект сравнивается с 0 с использованием < оператор результат даст true? Есть ли другие последствия? Если объект сравнивается <0 Означает ли это (object == 0) даст ложное и (object > 0) даст ложь?
  • В чем смысл использовать глагол для сравнения вместо того, чтобы быть? В чем разница, например, между "объект сравнивает <0" и "объект равен <0"?
  • В более общем смысле, что такое жаргон для простого английского перевода выражений типа:
    LHSoperand сравнивает comparison operatorRHSoperand

* Английский для меня иностранный язык.
** Я задавал похожие вопросы об изучающих английский язык и об английском языке и использовании.

Источник

6 ответов

Решение

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

Что касается того, почему он не использует фразу "меньше 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 означает "не число", и то, что не является числом, не меньше, равно или больше числа. Эти два несопоставимы, поэтому в каждом случае ответ (совершенно справедливо) ложный.

Источник

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

Я считаю, что это обычная запись.

Таким образом, применение этого ко всему предложению дает:

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

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

Источник

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

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

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

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

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

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

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

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

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

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

Источник

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

"a сравнивает == 0 Значит это a == 0 правда.

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

Источник

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

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

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

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

Источник

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

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

Выражение оценивается в 0, если a == b

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

Источник
Другие вопросы по тегам