Что «сравнивает меньше 0» имею в виду?

Question

Что «сравнивает меньше 0» имею в виду?

Контекст

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

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

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

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

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

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

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

Вопросы^**

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

_{* Английский для меня иностранный язык.

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

5

c++c++20 comparison-operators spaceship-operator terminology

Решение

Другие решения

«сравнивает <0 «в простом английском это» сравнивает меньше нуля «.

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

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

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

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

6

То, что меня интересует, точнее, эквивалентное выражение «сравнивает <0 «. Делает» сравнивает <0 «среднее» оценивает как отрицательное число »?

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

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

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

Реляционные типы сравнения и функции дружественного равенства задаются анонимным параметром неопределенные тип. Этот тип должен быть выбран реализацией так, чтобы эти параметры могли принимать литералы 0
в качестве соответствующего аргумента. [Пример: nullptr_t удовлетворяет этому требованию. —
end example] В этом контексте поведение программы, которая предоставляет аргумент, отличный от литерала 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».

3

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

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

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

2

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

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

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

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

1

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

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

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

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

0

Источник

Accepted Answer

Да, «объект сравнивает меньше 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

Что «сравнивает меньше 0» имею в виду?

Контекст

Вопросы**

Решение

Другие решения

Вопросы^**