Целочисленные типы

Общее представление и назначение

Целочисленный тип - тип данных в программировании и информатике, предназначенный для представления целых чисел (без дробной части) — как положительных, так и отрицательных, в зависимости от конкретного варианта типа.

Целочисленные типы используются повсеместно: для подсчёта элементов, индексации массивов, работы с битовыми масками, временными метками и для представления флагов. Количество различных значений, которые может хранить целочисленный тип с n битами, равно $2^n$ — это ключевое свойство, определяющее диапазон.

Например, один из часто встречающихся частных случаев — 8‑битный тип: для него количество значений равно $2^8 = 256$. Понимание того, сколько значений можно представить и как именно они кодируются, помогает правильно выбирать типы в задачах и избегать ошибок переполнения.

Знаковые и беззнаковые типы

Беззнаковый тип - целочисленный тип, который хранит только неотрицательные значения (включая ноль). Диапазон беззнакового n‑битного типа обычно задают как $0,\dots,2^n-1$.

Знаковый тип - целочисленный тип, который может хранить отрицательные и положительные значения. Для наиболее распространённого в современных системах представления с дополнянием до двух диапазон знакового n‑битного типа обычно равен $-2^{n-1},\dots,2^{n-1}-1$.

Выбор между знаковыми и беззнаковыми типами зависит от предметной области: счётчики и размеры обычно берут беззнаковыми, арифметику со знаком — знаковой. В языках программирования существует также множество производных типов (int, short, long, unsigned и т. п.), которые по размеру и знаковости различаются.

Двоичное представление и дополнение до двух

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

Дополнение до двух - способ кодирования отрицательных чисел, при котором значение отрицательного числа −x представляется таким образом, что в арифметике по модулю 2^n оно эквивалентно положительному числу $-x\equiv 2^n - x \pmod{2^n}$. На практике это достигается инверсией битов и добавлением единицы: $\operatorname{NOT}(x)+1$.

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

Диапазоны, максимумы, минимумы и переполнение

Для знаковых типов удобно запоминать формулы для минимума и максимума: минимальное значение равно $\min = -2^{n-1}$, а максимальное значение равно $\max = 2^{n-1}-1$. Для беззнаковых типов минимальное значение обычно равно нулю, а максимум — $0,\dots,2^n-1$ (повторение для наглядности).

Переполнение целочисленных операций — это результат арифметической операции, значение которой выходит за границы представимого диапазона. На уровне машинной арифметики переполнение можно рассматривать как вычисление результата по модулю $2^n$ (для n бит):, например, результат сложения фактически равен $(a+b) \bmod 2^n$.

Семантика переполнения зависит от языка. В некоторых языках (C, C++) переполнение знаковых целых UB (неопределённое поведение), для беззнаковых обычно определено как арифметика по модулю 2^n. В других языках (Java, C#) переполнение фиксируется и имеет определённое поведение или вызывает исключение/флаг.

Типы в языках программирования: конкретика

В языках высоко уровня набор целочисленных типов и их точный размер зависят от стандарта и реализации. Например, в стандарте C/C++ часто встречаются типы фиксированного размера, определённые в <stdint.h>: int8_t, int16_t, int32_t, int64_t и их беззнаковые аналоги. Для int8_t диапазон обычно равен $-128,\dots,127$.

В Java есть строгие гарантии размеров: byte (8 бит), short (16), int (32), long (64). В C/C++ размеры могут варьироваться, но для переносимости рекомендуется использовать типы фиксированной ширины или типы из <stdint.h>.

Преобразования типов и приведение

При преобразовании между целочисленными типами важны два случая: расширение (высвобождение) и усечение (сужение). При расширении обычно выполняется расширение знака (для знаковых типов) или расширение с добавлением нулей (для беззнаковых). При сужении старшие биты отбрасываются, что эквивалентно взятию по модулю $x \bmod 2^n$.

Например, если из целого 300 сделать 8‑битное число, результат будет равен $300 \bmod 256 = 44$. Это означает, что при явном или неявном приведении надо учитывать возможную потерю информации и изменённое значение.

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

Операции над целыми числами и поведение деления

Арифметические операции над целыми числами выполняются быстро и предсказуемо, но поведение операции деления и остатка может зависеть от языка и знака операндов. В некоторых языках целочисленное деление усечёт результат вниз (в сторону −∞), в других — усечёт к нулю. Для положительных чисел результат деления обычно совпадает с математическим целой частью: например, $7/2=3$.

Для отрицательных чисел результат зависит от выбранной семантики: в языках, где деление усечено к нулю, $-7/2=-3$. Это важно учитывать при реализации алгоритмов, где знак результата критичен, например при хешировании или при работе с индексами.

Практические советы и распространённые ошибки

1) Всегда выбирайте минимально достаточный размер типа, но учитывайте возможные расширения данных в будущем. 2) При смешанной арифметике явно приводите типы, чтобы избежать неочевидных преобразований знака и переполнений. 3) Для битовых масок и сдвигов проверяйте, что вы используете беззнаковые типы, если ожидаете логические сдвиги.

Частые ошибки: ожидание, что беззнаковый тип «автоматически» защитит от ошибок — на самом деле беззнаковая арифметика работает по модулю и может скрыть переполнение. Другие ошибки связаны с неверным предположением о размере типа на целевой платформе.