Boolean значение true - положительный 1 или минус 1?

Я разрабатываю язык и пытаюсь решить, является ли true должно быть 0x01 или 0xFF. Очевидно, что все ненулевые значения будут преобразованы в true, но я пытаюсь решить точное внутреннее представление.

каковы плюсы и минусы каждого варианта?

11 ответов


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

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

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

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

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

Адам


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

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


Почему вы выбираете, что ненулевые значения истинны? В аде истина есть истина, а ложь есть ложь. Нет неявного преобразования типов логических.


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

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

но

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

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

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

или

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

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


-1 больше для ввода, чем 1...

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

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

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

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


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

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

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


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

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


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

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


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

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


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