Почему у Int32 не используется первый бит?

Хранение целых чисел со знаком в Swift/Objective-C

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

Представление целых чисел со знаком

В большинстве современных систем, включая iOS/macOS (архитектуры ARM и x86-64), используется дополнительный код (two's complement) для представления целых чисел со знаком.

Для Int32:

• Общее количество бит: 32 бита
• Диапазон значений: -2 147 483 648 до 2 147 483 647
• Старший бит (бит №31, если считать с 0): знаковый бит
  • 0 → число положительное или ноль
  • 1 → число отрицательное

Примеры в дополнительном коде

// Swift примеры
let positive: Int32 = 42        // 00000000 00000000 00000000 00101010
let negative: Int32 = -42       // 11111111 11111111 11111111 11010110
let zero: Int32 = 0            // 00000000 00000000 00000000 00000000
let minValue: Int32 = .min     // 10000000 00000000 00000000 00000000
let maxValue: Int32 = .max     // 01111111 11111111 11111111 11111111

// Objective-C пример
int32_t x = -1;  // 11111111 11111111 11111111 11111111

Почему дополнительный код?

Исторически существовало несколько систем представления отрицательных чисел, но дополнительный код стал стандартом по нескольким причинам:

Преимущества дополнительного кода:

1. Единственное представление нуля
   В отличие от прямого кода, где есть "+0" и "-0", здесь ноль всегда представлен как все нули.

2. Простота арифметических операций
   Сложение и вычитание выполняются одинаково для положительных и отрицательных чисел без специальной обработки знака:

   let a: Int32 = 10    // 00001010
   let b: Int32 = -3    // 11111101
   let result = a + b   // 00000111 = 7
   // Простое побитовое сложение работает корректно
   

3. Естественный переход через ноль
   Инкремент максимального положительного числа даёт минимальное отрицательное:

   var n: Int32 = 2147483647  // .max
   n += 1                     // становится -2147483648 (.min)
   

4. Удобная реализация в аппаратуре
   Требует минимальной дополнительной логики в процессорных АЛУ.

Сравнение с беззнаковыми типами

Для сравнения, UInt32 использует ВСЕ 32 бита для значения, включая самый старший:

let signed: Int32 = -1      // 0xFFFFFFFF, значение: -1
let unsigned: UInt32 = 4294967295  // 0xFFFFFFFF, значение: 4294967295

Практические следствия в iOS разработке

1. Битовые сдвиги
   Для Int32 арифметический сдвиг вправо сохраняет знак:

   let negative: Int32 = -8        // 0xFFFFFFF8
   let shifted = negative >> 1     // 0xFFFFFFFC = -4 (знак сохранён)
   
   let unsigned: UInt32 = 0xFFFFFFF8 // 4294967288
   let ushifted = unsigned >> 1    // 0x7FFFFFFC = 2147483644 (логический сдвиг)
   

2. Переполнение
   Swift предоставляет операторы с контролем переполнения:

   let max: Int32 = .max
   // let overflow = max + 1  // Ошибка в режиме дебага
   let safe = max &+ 1        // -2147483648, корректное переполнение
   

3. Взаимодействие с C API
   При работе с низкоуровневыми API важно учитывать знаковость:

   // Неправильно - возможна потеря знака
   let intValue: Int32 = -1
   let uintValue = UInt32(bitPattern: intValue)  // 4294967295
   
   // Правильные преобразования при необходимости
   if intValue >= 0 {
       let safeUInt = UInt32(intValue)
   }
   

Вывод

Первый бит в Int32 не просто "не используется" — он выполняет ключевую роль знакового бита в системе дополнительного кода. Это эффективное представление, которое позволяет:

• Упростить аппаратную реализацию арифметических операций
• Иметь непрерывный диапазон значений
• Минимизировать особые случаи при обработке

Понимание этого фундаментально для работы с битовыми операциями, низкоуровневой оптимизацией и предотвращения тонких багов при преобразовании типов в iOS/macOS разработке.