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

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

Шестнадцатеричное число является просто менее подробным, и может выразить что-либо, что двоичное число может.

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

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

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

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

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

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

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

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

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

Бонусные очки!... Что языки действительно позволяют двоичным числам?

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

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

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

См. 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

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

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

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

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

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

int operator "" _B(int i);

assert( 1010_B == 10);

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

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

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

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

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

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

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

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

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

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

10 11 12 13 14 15 16 21 год 23 31 год 111 ?

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

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

Бонусные баллы! ... На каких языках можно использовать двоичные числа?

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

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

2: 11111111 = 255

3: 11111111 = 3280

16: 11111111 = 286331153

31: 11111111 = 28429701248

32: 11111111 = 35468117025

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

В то время как 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);

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