Почему большинство языков не допускают двоичные числа?

Ответ 1

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

Python 2.6+ позволяет бинарные литералы, а также Ruby и Java 7, где вы можете использовать знак подчеркивания, чтобы сделать границы байтов очевидными. Например, шестнадцатеричное значение 0x1b2a теперь может быть записано как 0b00011011_00101010.

Ответ 2

В С++ 0x с пользовательские литералы будут поддерживаться двоичные числа, я не уверен, будет ли он частью но в худшем случае вы сможете включить его самостоятельно

int operator "" _B(int i);

assert( 1010_B == 10);

Ответ 3

Чтобы представление бит было значимым, вам нужно знать, как его интерпретировать. Вам нужно будет указать, какой тип двоичного числа вы используете (подпись/без знака, двухкомпонентность, один-комплимент, знак-величина).

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

Ответ 4

См. perldoc perlnumber:

NAME
   perlnumber - semantics of numbers and numeric operations in Perl

SYNOPSIS
       $n = 1234;              # decimal integer
       $n = 0b1110011;         # binary integer
       $n = 01234;             # octal integer
       $n = 0x1234;            # hexadecimal integer
       $n = 12.34e-56;         # exponential notation
       $n = "-12.34e56";       # number specified as a string
       $n = "1234";            # number specified as a string

Ответ 5

Немного не по теме, но более новые версии GCC добавили расширение C, которое позволяет бинарные литералы. Поэтому, если вы только компилируете GCC, вы можете использовать их. Documenation здесь.

Ответ 6

Общий Lisp позволяет использовать двоичные числа, используя #b... (бит переходит от максимальной к наименьшей мощности 2). Большую часть времени, по крайней мере, так же удобно использовать шестнадцатеричные числа, хотя (используя #x...), так как довольно легко преобразовать между шестнадцатеричными и двоичными числами в вашей голове.

Ответ 7

Шестигранные и восьмеричные - это всего лишь более короткие способы записи двоичных файлов. Вы действительно хотите, чтобы в вашем коде была определена константа длиной 64 символа?

Ответ 8

D поддерживает бинарные литералы, используя синтаксис 0 [bB] [01] +, например. 0b1001. Он также позволяет встроенным _ символам в числовых литералах, чтобы они могли быть прочитаны более легко.

Ответ 9

Java 7 теперь поддерживает бинарные литералы. Поэтому вы можете просто написать 0b110101. Документации по этой функции мало. Единственная ссылка, которую я мог найти, - здесь.

Ответ 10

В то время как C имеет только встроенную поддержку 8, 10 или 16 в качестве базы, на самом деле не так сложно написать препроцессорный макрос, который делает запись 8-битных двоичных чисел довольно простой и удобочитаемой:

#define BIN(d7,d6,d5,d4, d3,d2,d1,d0)                      \
(                                                          \
    ((d7)<<7) + ((d6)<<6) + ((d5)<<5) + ((d4)<<4) +        \
    ((d3)<<3) + ((d2)<<2) + ((d1)<<1) + ((d0)<<0)          \
)
int my_mask = BIN(1,1,1,0, 0,0,0,0);

Это также можно использовать для С++.

Ответ 11

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

Ruby, который, как уже упоминалось, пытается разрешить это, позволяя быть свободно вставленным в литерал, позволяя, например:

irb(main):005:0> 1111_0111_1111_1111_0011_1100
=> 111101111111111100111100

Ответ 12

для записи и ответить на это:

Бонусные баллы!... Какие языки разрешают двоичные числа?

Specman (aka e) допускает двоичные числа. Хотя, честно говоря, это не совсем общий язык.

Ответ 13

Каждый язык должен поддерживать бинарные литералы. Я схожу с ума, не имея их!

Бонусные баллы!... Какие языки разрешают двоичные числа?

Icon позволяет использовать литералы в любой базе от 2 до 16 и, возможно, до 36 (моя память становится тусклой).

Ответ 14

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

Ответ 15

Я ожидаю, что разработчикам языка просто не хватало необходимости добавлять двоичные числа. Средний кодер может анализировать шестнадцатеричные так же, как и двоичные при обработке флагов или бит-масок. Замечательно, что некоторые языки поддерживают двоичное представление как представление, но я думаю, что в среднем он будет мало использован. Хотя бинарный - если он доступен в C, С++, Java, С#, вероятно, будет использоваться более чем восьмеричным!

Ответ 16

В Smalltalk это похоже на 2r1010. Вы можете использовать любую базу до 36 или около того.

Ответ 17

Hex - это всего лишь несколько подробностей и может выражать любые двоичные числа.

Ruby имеет хорошую поддержку двоичных чисел, если вы действительно этого хотите. 0b11011 и т.д.

Ответ 18

В Pop-11 вы можете использовать префикс из числа (от 2 до 32) + двоеточие, чтобы указать базу, например

2: 11111111 = 255

3: 11111111 = 3280

16: 11111111 = 286331153

31:11111111 = 28429701248

32: 11111111 = 35468117025

Ответ 19

Хотя он не является прямым, большинство языков также могут анализировать строку. Java может преобразовать "10101000" в int с помощью метода.

Не то, чтобы это было эффективно или что-то еще... Просто сказал это там. Если это было сделано в статическом блоке инициализации, это может быть сделано даже во время компиляции в зависимости от компилятора.

Если вы хорошо разбираетесь в двоичном коде, даже с коротким номером, достаточно прямо, чтобы увидеть 0x3c как 4, за которыми следуют 2 нуля, тогда как даже это короткое число в двоичном формате будет 0b111100, что может сделать ваши глаза больными раньше вы были уверены в количестве своих.

0xff9f имеет ровно 4 + 4 + 1 единицы, 2 нуля и 5 единиц (на вид битмакс очевиден). Попытка подсчитать 0b1111111110011111 гораздо более раздражает.

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

Эй, это напоминает мне то, что я придумал, думая о базовых конверсиях. Последовательность - я не думал, что кто-то может понять "Следующий номер", но один парень действительно сделал, поэтому он разрешимый. Попробуйте:

10 11 12 13 14 15 16 21 23 31 111

Изменить: Кстати, эта последовательность может быть создана путем подачи последовательных чисел в единую встроенную функцию на большинстве языков (Java наверняка).

Ответ 20

Forth всегда позволял использовать номера любой базы (вплоть до ограничения по размеру процессора, конечно). Хотите использовать двоичный код: 2 BASE ! восьмеричный: 8 BASE ! и т.д. Хотите работать со временем? 60 BASE ! Все эти примеры вводятся с базового набора в 10 десятичных знаков. Чтобы изменить базу, вы должны представлять нужную базу с текущей базы. Если в двоичном формате и вы хотите переключиться обратно в десятичную, то 1010 BASE ! будет работать. Большинство реализаций Forth имеют "слова" для перехода к общим основаниям, например. DECIMAL, HEX, OCTAL и BINARY.