Boolean true - положительный 1 или отрицательный 1?

Ответ 1

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

Никакие другие флаги не установлены ни на какое другое значение (0x01, 0xff и т.д.), но флаг нуля устанавливается равным false, если в регистре есть ненулевое значение.

Таким образом, ответы здесь, защищающие определение 0 как ложные и все остальное как истинные, являются правильными.

Если вы хотите "определить" значение по умолчанию для true, то 0x01 лучше большинства:

• Он представляет одно и то же число в каждой битовой длине и подписи
• Требуется только тестирование одного бита, если вы хотите узнать, действительно ли он равен нулю, если флаг нуля недоступен или дорогостоящий для использования
• Не нужно беспокоиться о расширении знака при конвертации в другие типы
• Логические и арифметические выражения действуют на нем одинаково

-Adam

Ответ 2

Это не имеет значения, если оно удовлетворяет правилам внешнего представления.

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

Ответ 3

Почему вы выбираете, что отличные от нуля значения являются истинными? В Ada true TRUE, а false - FALSE. В BOOLEAN и BOOLEAN нет никакого неявного преобразования типов.

Ответ 4

Использование -1 имеет одно преимущество в слабо типизированном языке - если вы испортите и используете побитовый оператор and вместо логического оператора and, ваше условие будет по-прежнему правильно оцениваться, если один из операндов был преобразован в каноническое булево представление. Это неверно, если каноническое представление равно 1.

  0xffffffff & 0x00000010 == 0x00000010 (true)
  0xffffffff && 0x00000010 == 0xffffffff (true)

но

  0x00000001 & 0x00000010 == 0x00000000 (false)
  0x00000001 && 0x00000010 == 0xffffffff (true)

Ответ 5

IMO, если вы хотите придерживаться false= 0x00, вы должны использовать 0x01. 0xFF обычно:

• знак того, что некоторая операция переполнена

или

• маркер ошибки

И в обоих случаях это, вероятно, означает false. Следовательно, соглашение об использовании символа * nix из исполняемых файлов, true= 0x00, а любое ненулевое значение - false.

Ответ 6

-1 длиннее, чем 1...

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

Изменить, для тех, кто голосует, объясните, почему. Этот ответ по существу тот же, что и в рейтинге +19. Таким образом, это разница в 21 голос за то, что является одним и тем же основным ответом.

Если это из-за комментария -1, это правда, человек, который фактически определяет "истинный" (например, писатель компилятора), должен использовать -1 вместо 1, предполагая, что они решили использовать точное представление. -1 будет занимать больше времени, чем 1, и конечный результат будет таким же. Утверждение глупо, оно должно было быть глупо, потому что между двумя (1 или -1) нет реальной разницы.

Если вы собираетесь отметить что-то, по крайней мере, объясните это.

Ответ 7

0xff является нечетным выбором, поскольку имеет неявное предположение, что 8 бит - ваш минимальный блок памяти. Но это не так необычно, чтобы хотеть хранить логические значения более компактно, чем это.

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

Я думаю, что ваша жизнь проще с 0 и 1.

Ответ 8

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

С другой стороны, если вы не разрешили это автоматическое преобразование, у вас будет pro: у вас не было бы совершенно произвольного правила на вашем языке. У вас не было бы (7 - 4 - 3) == false, или 3 * 4 + 17 == "Hello", или "Hi mom!" == Complex(7, -2).

Ответ 9

Я думаю, что метод C - это путь. 0 означает false, все остальное означает true. Если вы перейдете с другим сопоставлением для истины, тогда вам останется проблема с неопределенными значениями - это не правда, а false.

Если это язык, который вы будете компилировать для определенного набора инструкций, который имеет специальную поддержку для определенного представления, тогда я бы дал этому руководство. Но без какой-либо дополнительной информации, для "стандартного" внутреннего представления я бы пошел с -1 (все 1 в двоичном формате). Это значение хорошо распространяется на любой нужный вам размер (однобитовый, 8-разрядный, 16 и т.д.), И если вы разбиваете "TRUE" или "FALSE" на меньшие "TRUE" или "FALSE", тоже самое. (где, если вы сломали 16 бит TRUE = 0x0001, вы получите FALSE = 0x00 и TRUE = 0x01).

Ответ 10

Создайте язык так, чтобы 0 был ложным, а ненулевой - true. Нет необходимости "конвертировать" что угодно, и мышление "ненулевое" вместо определенного значения поможет вам правильно написать код.

Если у вас есть встроенные символы, такие как "Истина", тогда идите и выберите значение, но всегда думайте, что "ненулевое значение истинно" вместо "0x01 - это правда".

Ответ 11

Что бы вы ни делали, как только вы выберете свои значения, они не изменят их. В FORTH-77 true и false были определены как 1 и 0. Затем FORTH-83 переопределил их как -1 и 0. Было немного (хорошо, только немногие, это FORTH, о которых мы говорим) вызванный этим.