Этот вопрос может показаться глупым, но почему 0оценки falseи любое другое [целочисленное] значение для trueбольшинства языков программирования составляют?

Сравнение строк

Поскольку вопрос кажется немного слишком простым, я объясню немного подробнее: во-первых, это может показаться очевидным любому программисту, но почему бы не появиться язык программирования - на самом деле может быть, но не любой Я использовал - где 0вычисляет trueи все другие [целочисленные] значения false? Это одно замечание может показаться случайным, но у меня есть несколько примеров, где это могло бы быть хорошей идеей. Прежде всего, давайте возьмем пример трехстороннего сравнения строк, я возьму в strcmpкачестве примера C : любой программист, пытающийся использовать C в качестве своего первого языка, может испытывать желание написать следующий код:

if (strcmp(str1, str2)) { // Do something... }

Так как strcmpвозвращает, 0которое оценивает, falseкогда строки равны, то, что пытался сделать начинающий программист, с треском проваливается, и он, как правило, сначала не понимает, почему. Если бы 0оценены , чтобы trueвместо того, чтобы эта функция могла быть использована в наиболее простом выражении - один выше - при сравнении равенства, а соответствующие проверки на -1и 1было бы сделано только тогда , когда это необходимо. Мы бы рассматривали тип возвращаемого значения bool( как мы думаем ) большую часть времени.

Кроме того, давайте введем новый тип sign, который просто принимает значения -1, 0и 1. Это может быть очень удобно. Представьте себе, что в C ++ есть оператор космического корабля, и мы его хотим std::string(ну, там уже есть compareфункция, но оператор космического корабля более интересен). Декларация в настоящее время будет следующей:

sign operator<=>(const std::string& lhs, const std::string& rhs);

Если бы это 0было оценено true, оператор космического корабля даже не существовал бы, и мы могли бы объявить operator==так:

sign operator==(const std::string& lhs, const std::string& rhs);

Это operator==бы обрабатывало трехстороннее сравнение одновременно и могло бы использоваться для выполнения следующей проверки, в то же время имея возможность проверить, какая строка лексикографически превосходит другую при необходимости:

if (str1 == str2) { // Do something... }

Старая обработка ошибок

Теперь у нас есть исключения, так что эта часть относится только к старым языкам, где такого не существует (например, C). Если мы посмотрим на стандартную библиотеку C (и POSIX), то увидим, что функции maaaaany возвращаются в 0случае успеха и любое целое число в противном случае. Я, к сожалению, видел, как некоторые люди делают такие вещи:

#define TRUE 0
// ...
if (some_function() == TRUE)
{
    // Here, TRUE would mean success...
    // Do something
}

Если мы думаем о том, как мы думаем в программировании, мы часто имеем следующую модель рассуждений:

Do something
Did it work?
Yes ->
    That's ok, one case to handle
No ->
    Why? Many cases to handle

Если думать об этом снова, это имело бы смысл ставить только нейтральное значение, 0, к yes(и это, как функции C работают), в то время как все остальные значения могут быть там , чтобы решить многие случаи no. Тем не менее, во всех языках программирования, которые я знаю (за исключением, может быть, некоторых экспериментальных эзотерических языков), который yesоценивается falseкак ifусловие, а все noслучаи - как условие true. Есть много ситуаций, когда «это работает» представляет один случай, в то время как «это не работает» представляет много вероятных причин. Если мы думаем об этом таким образом, то иметь 0оценку trueи все остальное falseимело бы гораздо больше смысла.

Заключение

По сути, мой вывод - это мой первоначальный вопрос: почему мы разрабатывали языки там, где 0есть falseи другие значения true, принимая во внимание мои несколько приведенных выше примеров и, может быть, некоторые другие, о которых я не думал?

Продолжение: Приятно видеть, что есть много ответов с множеством идей и как можно больше причин для этого. Мне нравится, насколько ты увлечен этим. Изначально я задавал этот вопрос от скуки, но, поскольку вы кажетесь настолько страстным, я решил пойти немного дальше и спросить об обосновании логического выбора для 0 и 1 на Math.SE :)

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

• 0это тождество для сложения и ноль для умножения. Это верно для целых и рациональных чисел, но не для чисел с плавающей точкой IEEE-754: 0.0 * NaN = NaNи 0.0 * Infinity = NaN.

• falseявляется тождеством для логического xor (⊻) и нуля для логического и (∧). Если логические значения представлены как {0, 1} - набор целых чисел по модулю 2 - вы можете рассматривать ⊻ как сложение без переноса и ∧ как умножение.

• ""и []являются идентичностью для объединения, но есть несколько операций, для которых они имеют смысл как ноль. Повторение одно, но повторение и конкатенация не распределяются, поэтому эти операции не образуют полукольца.

Такие неявные преобразования полезны в небольших программах, но в целом могут затруднить анализ программ. Просто один из многих компромиссов в языковом дизайне.

Потому что математика работает.

FALSE OR TRUE is TRUE, because 0 | 1 is 1.

... insert many other examples here.

Традиционно, программы на С имеют такие условия, как

if (someFunctionReturningANumber())

скорее, чем

if (someFunctionReturningANumber() != 0)

потому что концепция нуля, эквивалентного ложному, хорошо понятна.

Как уже говорили другие, математика пришла первой. Вот почему 0 есть, falseа 1 есть true.

О какой математике мы говорим? Булевы алгебры, которые датируются серединой 1800-х годов, задолго до появления цифровых компьютеров.

Можно также сказать, что конвенция возникла из логики высказываний , которая даже старше, чем булевы алгебры. Это формализация многих логических результатов, которые программисты знают и любят ( false || xравно x, true && xравно xи так далее).

В основном мы говорим об арифметике на множестве из двух элементов. Подумайте о подсчете в двоичном виде. Булевы алгебры являются источником этой концепции и ее теоретической основой. Соглашения о языках, таких как C, являются простым приложением.

Я думал, что это связано с «наследованием» от электроники, а также с булевой алгеброй, где

• 0= off, negative, no,false
• 1= on, positive, yes,true

strcmp возвращает 0, когда строки равны, что связано с его реализацией, поскольку фактически он вычисляет «расстояние» между двумя строками. То, что 0 также считается ложным, является просто совпадением.

возвращать 0 в случае успеха имеет смысл, потому что 0 в этом случае означает отсутствие ошибок, а любое другое число будет кодом ошибки. Использование любого другого числа для успеха будет менее целесообразным, поскольку у вас есть только один код успеха, а у вас может быть несколько кодов ошибок. Вы используете "Это сработало?" как выражение оператора if и сказать 0 = да, имело бы больше смысла, но выражение более корректно: «Что-то пошло не так?» и тогда вы видите, что 0 = нет, имеет большой смысл. Думать о false/trueне имеет смысла здесь, как это на самом деле no error code/error code.

Как поясняется в этой статье , значения falseи trueне следует путать с целыми числами 0 и 1, но их можно отождествлять с элементами поля Галуа (конечного поля) из двух элементов (см. Здесь ).

Поле - это набор с двумя операциями, которые удовлетворяют определенным аксиомам.

Символы 0 и 1 обычно используются для обозначения аддитивных и мультипликативных тождеств поля, поскольку действительные числа также являются полем (но не конечным), тождествами которого являются числа 0 и 1.

Аддитивным тождеством является элемент 0 поля, такой что для всех x:

x + 0 = 0 + x = x

и мультипликативная идентичность - это элемент 1 поля, такой что для всех x:

x * 1 = 1 * x = x

Конечное поле из двух элементов имеет только эти два элемента, а именно аддитивное тождество 0 (или false) и мультипликативное тождество 1 (или true). Две операции в этом поле - логический XOR (+) и логический AND (*).

Запись. Если вы переворачиваете операции (XOR - это умножение, а AND - это сложение), то умножение не является дистрибутивным по сравнению с сложением, и у вас больше нет поля. В таком случае у вас нет причин называть два элемента 0 и 1 (в любом порядке). Также обратите внимание, что вы не можете выбрать операцию ИЛИ вместо XOR: независимо от того, как вы интерпретируете ИЛИ / И как сложение / умножение, результирующая структура не является полем (не все обратные элементы существуют, как того требуют аксиомы поля).

Относительно функций C:

• Многие функции возвращают целое число, которое является кодом ошибки. 0 означает НЕТ ОШИБКИ.
• Интуитивно, функция strcmpвычисляет разницу между двумя строками. 0 означает, что нет никакой разницы между двумя строками, т.е. что две строки равны.

Приведенные выше интуитивные объяснения могут помочь запомнить интерпретацию возвращаемых значений, но еще проще просто проверить документацию библиотеки.

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

Оболочки: 0 выходной статус истина, ненулевое значение ложь

Пример оболочек, рассматривающих состояние выхода 0 как true, уже упоминался.

$ ( exit 0 ) && echo "0 is true" || echo "0 is false"
0 is true
$ ( exit 1 ) && echo "1 is true" || echo "1 is false"
1 is false

Основанием для этого является то, что есть один способ добиться успеха, но есть много способов потерпеть неудачу, поэтому прагматично использовать 0 в качестве специального значения, означающего «нет ошибок».

Рубин: 0, как и любой другой номер

Среди «нормальных» языков программирования есть некоторые выбросы, такие как Ruby, которые рассматривают 0 как истинное значение.

$ irb
irb(main):001:0> 0 ? '0 is true' : '0 is false'
=> "0 is true"

Обоснованием является то , что только falseи nilдолжно быть ложным. Для многих новичков в Ruby это гоча. Однако в некоторых случаях приятно, что 0 обрабатывается так же, как и любое другое число.

irb(main):002:0> (pos = 'axe' =~ /x/) ? "Found x at position #{pos}" : "x not found"
=> "Found x at position 1"
irb(main):003:0> (pos = 'xyz' =~ /x/) ? "Found x at position #{pos}" : "x not found"
=> "Found x at position 0"
irb(main):004:0> (pos = 'abc' =~ /x/) ? "Found x at position #{pos}" : "x not found"
=> "x not found"

Однако такая система работает только на языке, который может отличать логические значения как отдельный тип от чисел. На заре вычислительной техники программисты, работающие на ассемблере или на машинном языке, не имели такой роскоши. Вероятно, вполне естественно рассматривать 0 как «пустое» состояние и устанавливать бит в 1 как флаг, когда код обнаружил, что что-то произошло. Таким образом, согласно соглашению, ноль считался ложным, а ненулевые значения считались истинными. Тем не менее, это не должно быть так.

Java: числа вообще не могут рассматриваться как логические

В Java, trueи falseявляются единственными булевы значения. Числа не являются логическими значениями и даже не могут быть преобразованы в логические значения ( спецификация языка Java, раздел 4.2.2 ):

Между целочисленными типами и типом нет приведения boolean.

Это правило просто избегает вопроса - все логические выражения должны быть явно написаны в коде.

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

Строковые сравнения

То же самое верно для многих сравнений. Такие сравнения вычисляют расстояние между двумя объектами. Когда объекты равны, расстояние минимально. Поэтому , когда «сравнение успешно», то значение равно 0. Но на самом деле, возвращаемое значение strcmpявляется не логическим значением, это расстояние, и то , что ловушки не знающие программисты делают if (strcmp(...)) do_when_equal() else do_when_not_equal().

В C ++ мы могли бы перепроектировать, strcmpчтобы вернуть Distanceобъект, который переопределяет, operator bool()чтобы возвратить true, когда 0 (но тогда вы будете укушены другим набором проблем). Или в простом C просто есть streqфункция, которая возвращает 1, когда строки равны, и 0 в противном случае.

Вызовы API / код выхода из программы

Здесь вас волнует причина, по которой что-то пошло не так, потому что это приведет к ошибкам при принятии решений. Когда все получается, вы не хотите знать ничего конкретного - ваше намерение реализовано. Поэтому возвращаемое значение должно передавать эту информацию. Это не логическое значение, это код ошибки. Значение специальной ошибки 0 означает «нет ошибки». Остальная часть диапазона представляет локально значимые ошибки, с которыми вам приходится иметь дело (включая 1, что часто означает «неопределенная ошибка»).

Общий случай

Это оставляет нас с вопросом: почему логические значения Trueи Falseобычно представлены с 1 и 0, соответственно?

Ну, кроме субъективного аргумента "так лучше", есть несколько причин (в том числе и субъективных), о которых я могу подумать:

• аналогия электрической цепи. Ток включен в течение 1 с и выключен в течение 0 с. Мне нравится иметь (1, Да, True, On) вместе и (0, No, False, Off), а не другой микс

• инициализация памяти. Когда я получаю memset(0)кучу переменных (будь то целые числа, числа с плавающей запятой, значения типа bools), я хочу, чтобы их значение соответствовало самым консервативным предположениям. Например, моя сумма изначально равна 0, предикат равен False и т. Д.

Возможно, все эти причины связаны с моим образованием - если бы меня с самого начала учили ассоциировать 0 с Истиной, я бы пошел другим путем.

С точки зрения высокого уровня, вы говорите о трех совершенно разных типах данных:

1. Логическое. Математическое соглашение в булевой алгебре состоит в том, чтобы использовать 0 для falseи 1 для true, поэтому имеет смысл следовать этому соглашению. Я думаю, что этот путь также имеет больше смысла интуитивно.

2. Результат сравнения. Это имеет три значения: <, =и >(заметьте , что ни один из них не является true). Для них имеет смысл использовать значения -1, 0 и 1 соответственно (или, в более общем случае, отрицательное значение, ноль и положительное значение).

   Если вы хотите проверить на равенство, и у вас есть только функция, которая выполняет общее сравнение, я думаю, вы должны сделать это явно, используя что-то вроде strcmp(str1, str2) == 0. Я нахожу использование !в этой ситуации запутанным, потому что оно обрабатывает не логическое значение, как если бы оно было логическим.

   Также имейте в виду, что сравнение и равенство не обязательно должны совпадать. Например, если вы заказываете людей по дате их рождения, Compare(me, myTwin)должны вернуться 0, но Equals(me, myTwin)должны вернуться false.

3. Успех или неудача функции, возможно, также с подробностями об этом успехе или неудаче. Если вы говорите о Windows, то этот тип вызывается, HRESULTи ненулевое значение не обязательно означает сбой. Фактически, отрицательное значение указывает на неудачу и неотрицательный успех. Значение успеха очень часто S_OK = 0, но это могут быть, например S_FALSE = 1, или другие значения.

Путаница возникает из-за того, что три логически совершенно разных типа данных фактически представлены как один тип данных (целое число) в C и некоторых других языках и что вы можете использовать целое число в условии. Но я не думаю, что имеет смысл переопределять логическое значение, чтобы упростить использование некоторых не-логических типов в условиях.

Также рассмотрим другой тип, который часто используется в условии в C: указатель. Там естественно считать NULL-пойнт (который представлен как 0) как false. Поэтому следование вашему предложению также затруднит работу с указателями. (Хотя лично я предпочитаю явно сравнивать указатели NULL, а не рассматривать их как логические значения.)

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

Посмотрим почему.

Какой-то псевдокод, так как публика, вероятно, не читает сборку

c- исходный простой цикл вызывает колебания 10 раз

for (int foo =10; foo>0; foo-- ) /* down count loop is shorter */
{  
   wibble();
}

какая-то притворная сборка для этого

0x1000 ld a 0x0a      'foo=10
0x1002 call 0x1234    'call wibble()
0x1005 dec a          'foo--
0x1006 jrnz -0x06      'jump back to 0x1000 if not zero
0x1008  

c- источник еще один простой цикл вызывает колебания 10 раз

for (int foo =0; foo<10; foo-- ) /* up count loop is longer  */
{  
   wibble();
}

какая-то притворная сборка для этого случая

0x1000 ld a 0x00      'foo=0
0x1002 call 0x1234    'call wibble()
0x1005 dec a          'foo--
0x1006 cmp 0x0a       'compare foo to 10 ( like a subtract but we throw the result away)
0x1008 jrns -0x08      'jump back to 0x1000 if compare was negative
0x100a  

еще немного c источником

int foo=10;
if ( foo ) wibble()

и сборка

0x1000 ld a 0x10
0x1002 jz 0x3
0x1004 call 0x1234
0x1007  

видите, как это коротко?

еще немного c источником

int foo=10;
if ( foo==0 ) wibble()

и сборка (предположим, что немного умный компилятор может заменить == 0 без сравнения)

0x1000 ld a 0x10
0x1002 jz 0x3
0x1004 call 0x1234
0x1007  

Теперь давайте попробуем соглашение об истинности = 1

еще немного c source #define TRUE 1 int foo = TRUE; if (foo == TRUE) wibble ()

и сборка

0x1000 ld a 0x1
0x1002 cmp a 0x01
0x1004 jz 0x3
0x1006 call 0x1234
0x1009 

видите, насколько коротким является случай с ненулевым значением true?

Действительно ранние процессоры имели небольшие наборы флагов, прикрепленных к Аккумулятору.

Чтобы проверить, что a> b или a = b, обычно требуется инструкция сравнения.

• Если B не равен ZERO - в этом случае устанавливается флаг ZERO. Внедрен как простой логический NOR или все биты в накопителе.
• Или ОТРИЦАТЕЛЬНЫЙ, в котором просто используйте «знаковый бит», т. Е. Самый значимый бит Аккумулятора, если вы используете арифметику с двумя дополнительными компонентами. (В основном мы делаем)

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

Теперь вы понимаете, почему ноль может быть ложным?

Обратите внимание, что это псевдо-код, и никакой реальный набор инструкций не выглядит так. Если вы знаете сборку, вы знаете, я здесь многое упрощаю. Если вы знаете что-нибудь о дизайне компилятора, вам не нужно было читать этот ответ. Любой, кто знает что-либо о развертывании цикла или предсказании ветвления, продвинутый класс идет по коридору в комнате 203.

Есть много ответов, которые предполагают, что соответствие между 1 и истиной обусловлено некоторым математическим свойством. Я не могу найти такую ​​собственность и предполагаю, что это чисто историческое соглашение.

Для поля с двумя элементами у нас есть две операции: сложение и умножение. Мы можем отобразить логические операции с этим полем двумя способами:

Традиционно мы отождествляем True с 1 и False с 0. Мы отождествляем AND с * и XOR с +. Таким образом, OR является насыщающим дополнением.

Однако мы могли бы так же легко идентифицировать True с 0 и False с 1. Затем мы идентифицируем OR с * и XNOR с +. Таким образом, И является насыщающим дополнением.

Странно, ноль не всегда ложен.

В частности, соглашение Unix и Posix должно быть определено EXIT_SUCCESSкак 0 (и EXIT_FAILUREкак 1). На самом деле это даже стандартное соглашение C !

Таким образом, для оболочек Posix и системных вызовов exit (2) 0 означает «успешный», что наглядно скорее верно, чем ложно.

В частности, оболочка ifхочет , чтобы возвращаемый процесс EXIT_SUCCESS(то есть 0) следовал за своей ветвью "then"!

В Схеме (но не в Common Lisp или в MELT ) 0 и nil (т.е. ()в Схеме) являются истинными, поскольку единственное ложное значение#f

^{Я согласен, я придираюсь!}

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

Вы можете написать такие вещи, как:

if (modemctrl & MCTRL_CD) {
   /* carrier detect is on */
}

скорее, чем

if ((modemctrl & MCTRL_CD) != 0) {
    /* carrier detect is on */
}

В одном отдельном примере это не так уж и плохо, но необходимость делать это становится утомительной.

Аналогично, обратные операции. Для результата логической операции, такой как сравнение, полезно просто получить 0 или 1: Предположим, мы хотим установить третий бит некоторого слова в зависимости от того, modemctrlимеет ли бит обнаружения несущей:

flags |= ((modemctrl & MCTRL_CD) != 0) << 2;

Здесь мы должны иметь != 0, чтобы уменьшить результат &выражения biwise до 0или 1, но поскольку результатом является просто целое число, мы избавлены от необходимости добавлять некоторое раздражающее приведение для дальнейшего преобразования логического значения в целое.

Несмотря на то, что современный C теперь имеет boolтип, он все еще сохраняет достоверность кода, подобного этому, и потому, что это хорошо, и из-за огромного сбоя с обратной совместимостью, который мог бы возникнуть в противном случае.

Еще один пример, где C ловко: тестирование двух логических условий в качестве четырехходового переключателя:

switch (foo << 1 | bar) {  /* foo and bar booleans are 0 or 1 */
case 0: /* !foo && !bar */
   break;
case 1: /* !foo && bar */
   break;
case 2: /* foo && !bar */
   break;
case 3: /* foo && bar */
   break;
}

Вы не могли бы отнять это у программиста C без боя!

Наконец, C иногда служит своего рода языком ассемблера высокого уровня. В языках ассемблера у нас также нет логических типов. Логическое значение - это всего лишь бит или ноль в сравнении с ненулевым значением в ячейке памяти или регистре. Целый ноль, логический ноль и нулевой адрес проверяются одинаково в наборах команд на ассемблере (и, возможно, даже с плавающей точкой ноль). Сходство между C и ассемблером полезно, например, когда C используется в качестве целевого языка для компиляции другого языка (даже того, который имеет строго типизированные логические значения!)

Логическое или истинное значение имеет только 2 значения. Правда и ложь.

Они должны не быть представлены в виде целых чисел, но в качестве битов (0 и 1).

Сказать, что любое другое целое число, кроме 0 или 1, не является ложным, является ошибочным утверждением. Таблицы истинности имеют дело со значениями истинности, а не целыми числами.

С точки зрения истинного значения -1 или 2 сломают все таблицы истинности и любую логическую логику, связанную с ними.

• 0 И -1 ==?!
• 0 ИЛИ 2 ==?!

Большинство языков обычно имеют booleanтип, который при приведении к числовому типу, такому как целое число, показывает ложь, которая будет приведена к целочисленному значению 0.

В конечном счете, вы говорите о взломе основного языка, потому что некоторые API являются дерьмовыми. Crappy API не новы, и вы не можете исправить их, нарушив язык. Это математический факт, что 0 ложно, а 1 верно, и любой язык, который не уважает это, в корне нарушен. Трехстороннее сравнение является нишевым и не имеет никакого смысла, поскольку его результат неявно конвертируется, boolпоскольку он возвращает три возможных результата. Старые API-интерфейсы C просто ужасно обрабатывают ошибки, а также имеют проблемы, потому что C не имеет необходимых языковых возможностей, чтобы не иметь ужасных интерфейсов.

Обратите внимание, что я не говорю, что для языков, которые не имеют неявного целочисленного -> логического преобразования.