Зачем использовать шестнадцатеричные константы?

Ответ 1

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

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

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

Существуют две другие разумные возможности: восьмеричная или базовая 8 просто кодирует 3 бита на цифру. И тогда есть двоично-кодированное десятичное число, в котором каждая цифра требует четыре бита, но значения цифр выше 9 запрещены - это было бы невыгодно, поскольку оно не могло бы представлять все возможности, которые могут быть использованы в двоичном формате.

Ответ 2

"Очевидно, проще определить 2914 вместо 0x0B62"

Я не знаю об этом конкретном случае, но довольно часто это неверно.

Из двух вопросов:

• A) Каково значение бит 2914?
• B) Какое значение бит 0x0B62?

B ответят более правильно быстрее, чем многие разработчики. (Это относится и к аналогичным вопросам)

0x0B62 (это 4 шестнадцатеричных разряда, поэтому он воспроизводит 16-разрядное число)

• бит 0 = 0000
• бит B = 1011
• бит 6 = 0110
• бит 2 = 0010

- >

0000101101100010

(Я смею делать то же самое с 2914.)

Это одна из причин использования шестнадцатеричного значения, другое - источник источника может использовать hex (например, стандарт спецификации).

Иногда я просто нахожу это глупым, как в:

public static final int NUMBER_OF_TIMES_TO_ASK_FOR_CONFIRMATION = ...;

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

Ответ 3

Считываемость при применении шестнадцатеричных масок, например.

Ответ 4

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

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

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

// These error flags tend to indicate that error flags probably
// all start with 0x05..
public static final int GL_STACK_UNDERFLOW = 0x0504;
public static final int GL_OUT_OF_MEMORY = 0x0505;

// These EXP flags tend to indicate that EXP flags probably
// all start with 0x08..
public static final int GL_EXP = 0x0800;
public static final int GL_EXP2 = 0x0801;

// These FOG flags tend to indicate that FOG flags probably
// all start with 0x0B.., or maybe 0x0B^.
public static final int GL_FOG_DENSITY = 0x0B62;
public static final int GL_FOG_START = 0x0B63;
public static final int GL_FOG_END = 0x0B64;
public static final int GL_FOG_MODE = 0x0B65;

С десятичными числами трудно было бы "заметить" константные области бит на большом количестве разных, но связанных элементов.

Ответ 5

Вы предпочитаете писать 0xFFFFFFFF или 4294967295?

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

Ответ 6

Когда дело доходит до больших чисел, представление их в шестнадцатеричном формате делает их более читабельными, потому что они более компактны.

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

Что касается коэффициента усиления производительности: нет, его нет.

Ответ 7

Шестнадцатеричный - это самый читаемый формат для двоичного формата. Это упрощает операции с большим количеством бит, например

Ответ 8

0xB62 равно 2914:-)

Для разработчиков гораздо проще мысленно изобразить битовый шаблон константы, когда он представлен в шестнадцатеричном виде, чем когда он представлен в виде базового числа 10.

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

Ответ 9

Ahh, но 0xDECAFF - оба (1460959) и приятный фиолетовый цвет (в RGB).

Для колонок hex больше MUCH.

FF FF FF - белый 00 00 FF синий FF 00 00 красный 00 FF 00 зеленый Легко видеть цветовые отношения как числа (хотя гамма и верность человеческого глаза, как правило, отбрасывают вещи, но мы будем игнорировать эти неудобные физические факты для чистой математической точности!

Ответ 10

Нет увеличения производительности.

Однако, если эти константы соответствуют некоторым битам ниже, большинство программистов предпочитают Hex (или даже двоичный), чтобы сделать это понятным и читаемым.

Например, нетрудно видеть, что GL_EXP2 имеет 2 бита, 1 бит и 0x0800 бит (что равно 2048 десятичным). Десятичное значение 2049 будет менее ясным.

Ответ 11

Иногда проще использовать битовые алгоритмы. В других случаях речь идет о бит-сравнениях, так как мой оператор в комментарии, 4 бита (двоичные цифры) преобразуются в 1 шестнадцатеричную букву, поэтому A3 = 10100011.

В других случаях это либо весело, либо ломает монотонность, хотя люди, не знакомые с hex, могут подумать, что вы делаете что-то с указателями

int data = 0xF00D;
if ( val != 0xC0FFEE )
{
   data = 0xDECAF;
}

Я иногда использую его для проверки границ таких вещей, как ints. Например, вы можете использовать 0x7FFFFFFF (0x80000000 работает во многих случаях, но 0x7F... безопаснее), чтобы получить максимальную ширину int. Это удобно для установки очень высокой константы ошибок, если у вас нет языка с чем-то вроде MAX_INT. Техника также масштабируется, так как для 64-битных вы можете использовать 0x7FFFFFFFFFFFFFFF. Вы можете заметить, что Android использует 0x7_ __ для поиска таблицы R.id.

Бьюсь об заклад, они делают это ради ясности. Вы можете легко использовать целые числа, но если вы знакомы с шестнадцатеричным, это неплохо. Похоже, что они резервируют значения х для определенных функций. В десятичной форме вы делаете что-то вроде 0-99, это ошибки, 100-199 для чего-то еще и т.д. Как они это делают, масштабируется по-разному.

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