Как представляются отрицательные числа -- прямой код, обратный код, дополнительный код

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


Аналогия из жизни: нумерация этажей отеля

Представьте отель с 256 этажами.

Если нумеровать натуральными числами, можно использовать только от 0 до 255.

Но что, если мы хотим пронумеровать от «128 этажей под землёй» до «127 этажей над землёй»?

Хитрый приём: переинтерпретировать числа 128~255 как -128~-1.

Число 128 становится -128, число 255 становится -1, а число 0 остаётся 0.

ЭтоОсновная идея дополнительного кода— В пределах конечного диапазона битов переинтерпретировать «вторую половину» пространства значений как отрицательные числа.


Простейшая идея: знак и величина (прямой код)

Самая прямая идея для представления отрицательных чисел: использовать старший бит какзнаковый бит。

  • Старший бит 0 = положительное число
  • Старший бит 1 = отрицательное число
  • Остальные биты представляют абсолютное значение

Возьмём для примера 8 бит:

+5 =
0
0
0
0
0
1
0
1
Знаковый бит 0 = положительное число
-5 =
1
0
0
0
0
1
0
1
Знаковый бит 1 = отрицательное число

Выглядит разумно, правда? Но у прямого кода есть две фатальные проблемы.

Проблема первая: существуют и +0, и -0.

Положительный 0 — это00000000, отрицательный 0 — это10000000。

Одно и то же значение имеет два представления.

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

Проблема 2: сумматор не умеет выполнять вычитание

Вычислим с использованием представления «знак — величина»5 + (-3):

5 (знак — величина)
00000101
+
-3 (знак — величина)
10000011
=
Складываем напрямую
10001000
=
Результат
-8

5 + (-3) должно равняться 2, но прямое сложение с использованием представления «знак — величина» даёт -8.

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

Проблему представления «знак — величина» можно кратко описать так: интуитивно понятно, но непрактично. Оно подходит для чтения человеком, но не подходит для реализации в схемах.


Озарение от часов: модульная арифметика

Прежде чем продолжить, нам нужно понять ключевую концепцию —операция по модулю。

Взгляните на часы: на циферблате всего 12 отметок.

От 10 часов вы хотите перейти к 7 часам. Есть два способа:

Способ первый (против часовой стрелки): 10 - 3 =7(Вычитание)

Способ 2 (по часовой стрелке): 10 + 9 = 19, 19 mod 12 =7(Сложение)

В системе "по модулю 12" -3 и +9 эквивалентны (потому что -3 + 12 = 9).

В более общем виде:В системе по модулю M вычитание числа эквивалентно прибавлению (M минус это число)。

Дополнительный код применяет эту идею к двоичной системе. Для 8-битной двоичной системы модуль равен 2^8 = 256.

Дополнительный код числа -3 = 256 - 3 = 253 = двоичное представление.11111101。

therefore5 + (-3)Может стать5 + 253 = 258。

Но в 8-битной системе 258 превышает верхний предел 255. Перенос из старшего бита "переполняется" и отбрасывается, оставляя258 mod 256 = 2。

Сложение дало правильный результат вычитания.


Кольцевая диаграмма дополнительного кода (интерактивная демонстрация)

Кольцевая диаграмма ниже наглядно показывает 4-битную систему дополнительного кода.

4 бита могут представлять 16 значений (0~15); дополнительный код интерпретирует их как -8~+7.

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

Кольцевая диаграмма дополнительного кода (4-битная система, диапазон -8 ~ +7)

0

Двоичное представление:0000| Беззнаковая интерпретация:0

Загрузите библиотеку Plotly.js для построения полярной кольцевой диаграммы

Кольцевая диаграмма дополнительного кода Plotly (полярные координаты scatterpolar).

На рисунке ниже используются полярные координаты Plotly.js для отображения 16 делений 4-битного дополнительного кода. Синий = положительная область, красный = отрицательная область, зелёный = нулевая точка.

Диапазон положительных чисел (0 до +7)
Область отрицательных чисел (-8 до -1)
нулевая точка
Точка переполнения (+7→-8)

Смысл цикличности:

  • Направление по часовой стрелке = значение увеличивается
  • Проход по одному кругу (превышение максимума) = возврат к начальной точке (эффект «переполнения» модульной арифметики)
  • Красная область = отрицательные числа (интерпретация в дополнительном коде), синяя область = положительные числа
  • Внутреннее кольцо подписано беззнаковой интерпретацией (соответствует 0~15), внешнее кольцо — интерпретацией в дополнительном коде (-8~+7)

Из диаграммы видно, что,дополнительный код по сути сворачивает пространство значений в кольцо.。

Когда положительные числа достигают конца (после +7), они естественно становятся отрицательными (-8). Вычитание и сложение — это одно и то же направление на кольце.


Правила вычисления дополнительного кода

Чтобы вручную вычислить дополнительный код числа, есть два эквивалентных быстрых метода:

Метод первый: инвертировать и прибавить 1 (стандартный метод)

  1. Запишите двоичное представление, соответствующее абсолютному значению
  2. Инвертируйте каждый бит (0 становится 1, 1 становится 0), чтобы получить обратный код
  3. Прибавьте 1 к обратному коду, чтобы получить дополнительный код

Способ второй: справа налево (быстрый способ вычисления)

  1. Найдите первую 1 справа налево
  2. Инвертируйте все биты слева от этой 1
  3. Эта 1 и все биты справа от неё остаются без изменений

Возьмём -20 в качестве примера (8-битная система) и проверим обоими способами:

20 в двоичной системе
00010100
→
Инвертировать (обратный код)
11101011
→
Прибавить 1 (дополнительный код)
11101100

Проверка: дополнительный код числа -20 равен 11101100; при интерпретации как беззнакового числа он равен 236.

236 + 20 = 256, ровно один модуль. Это показывает, что вычисление верно.


Сравнение трёх представлений

valueпрямой кодобратный коддополнительный код
+5000001010000010100000101
-5100001011111101011111011
+0000000000000000000000000
-01000000011111111Не существует
+127011111110111111101111111
-127111111111000000010000001
-128Невозможно представитьНевозможно представить10000000

Отметим три ключевых отличия:

  1. В дополнительном коде нет -0: все единицы больше не тратятся на -0, а представляют -1.
  2. В дополнительном коде на одно отрицательное число большеДиапазон 8-битного дополнительного кода — от -128 до +127, что на одно значение -128 больше, чем диапазон прямого кода от -127 до +127.
  3. Дополнительный код унифицирует сложение: сложение положительных и отрицательных чисел использует одну и ту же схему.

Именно поэтому в JavabyteДиапазон типа — -128~127, а в языке Csigned charтакже находится в диапазоне -128~127. Оба используют 8-битный дополнительный код.


Интерактивная демонстрация: калькулятор дополнительного кода

Ниже введите целое число в 8-битном диапазоне (-128 ~ 127), чтобы увидеть его прямой, обратный и дополнительный код.

Калькулятор дополнительного кода (8-битный)

Введите целое число:

Особое примечание: когда введено -128, дополнительный код равен10000000。

Абсолютное значение этого числа равно 128, но 128 выходит за пределы 8-битного диапазона положительных чисел (0~127).

Таким образом, у -128 нет соответствующего положительного представления — это интересное свойство системы дополнительного кода.


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

Диапазон 8-битного дополнительного кода: -128~127.

Если результат вычисления выходит за пределы этого диапазона, это приведёт кпереполнению。

127 + 1
-128
(Положительное переполнение, отрицательный результат)
|
-128 - 1
+127
(Отрицательное переполнение, положительный результат)

Это снова перекликается с предыдущей кольцевой диаграммой — после достижения конца значение «оборачивается».

В C/C++ переполнение знаковых целых чисел — этонеопределённое поведение(компилятор может предполагать, что оно никогда не происходит), что является причиной многих странных ошибок.


Демонстрация кода: полная реализация дополнительного кода

Пример

# Полная реализация и проверка дополнительного кода (демонстрационный пример)

def to_twos_complement(n, bits=8):
    Преобразовать целое число n в строку в дополнительном коде с заданной разрядностью
    if n < -2**(bits-1) or n > 2**(bits-1) - 1:
        raise ValueError(fЗначение {n} выходит за пределы {bits}-битного диапазона дополнительного кода [-{2**(bits-1)}, {2**(bits-1)-1}])

    # Использование модульной арифметики: беззнаковый эквивалент отрицательного числа n = n + 2^bits
    # Использование битовой маски напрямую в Python
    mask = (1 << bits) - 1  # Например, 8 бит: 0xFF = 255
    unsigned_val = n & mask
    return format(unsigned_val, f'0{bits}b')

def from_twos_complement(bin_str):
    """Преобразовать строку в дополнительном коде обратно в десятичное целое число."""
    bits = len(bin_str)
    unsigned_val = int(bin_str, 2)

    # Если старший бит равен 1 (отрицательное число), вычесть 2^bits
    if bin_str[0] == '1':
        return unsigned_val - (1 << bits)
    else:
        return unsigned_val

def show_conversion_steps(n, bits=8):
    """Показать подробные шаги от n до дополнительного кода."""
    abs_bin = format(abs(n), f'0{bits}b')
    print(f"Значение: {n}")
    print(fШаг 1: абсолютное значение |{n}| = {abs(n)} → двоичное представление = {abs_bin})

    if n >= 0:
        print(f" Шаг 2: дополнительный код положительного числа = прямой код = {abs_bin}")
    else:
        # Инвертировать
        inverted = ''.join('1' if b == '0' else '0' for b in abs_bin)
        print(fШаг 2: инверсия (обратный код) = {inverted})

        # прибавить 1
        carry = 1
        result_list = list(inverted)
        for i in range(bits - 1, -1, -1):
            if carry == 0:
                break
            total = int(result_list[i]) + carry
            result_list[i] = str(total % 2)
            carry = total // 2
        result = ''.join(result_list)
        print(fШаг 3: обратный код + 1 = {result})

    comp = to_twos_complement(n, bits)
    print(f" → Итоговый дополнительный код: {comp}")

    # Проверка
    recovered = from_twos_complement(comp)
    print(fПроверка: дополнительный код {comp} → интерпретируется как {recovered})
    print()

#
print("=" * 50)
print("补码转换演示(8位系统)")
print("=" * 50)
print()

for val in [5, -5, 0, -1, 127, -128]:
    show_conversion_steps(val)

# 验证补码加法
print("=" * 50)
print("补码加法验证:减法变为加法")
print("=" * 50)

def twos_add(a, b, bits=8):
    """补码加法(包括溢出处理)"""
    mask = (1 << bits) - 1
    result_unsigned = (a + b) & mask
    # 解释有符号结果
    if result_unsigned >= (1 << (bits - 1)):
        signed_result = result_unsigned - (1 << bits)
    else:
        signed_result = result_unsigned
    return signed_result

# 5 - 3 = 2
print(f5 + (-3) = {twos_add(5, -3)} (ожидается: 2))

# 127 + 1 = -128 (переполнение)
print(f127 + 1 = {twos_add(127, 1)} (ожидается: -128, произошло переполнение))

# -128 - 1 = 127 (переполнение)
print(f-128 + (-1) = {twos_add(-128, -1)} (ожидается: 127, произошло переполнение))

# прибавление нуля
print(f0 + 0 = {twos_add(0, 0)} (ожидается: 0))

# Проверка на символах EXAMPLE: R=82, U=85 → 82 + (-85) = -3
print(f"\nEXAMPLE Тест:R(82) + (-U(85)) = {twos_add(82, -85)} (ожидается: -3)")

# Демонстрация циклической природы дополнительного кода
print("\nКольцо дополнительного кода (упрощённая 4-битная версия, диапазон от -8 до +7):)
print("Значение | Дополнительный код | Беззнаковое")
print("-" * 30)
for n in range(-8, 8):
    comp = to_twos_complement(n, 4)
    unsig = int(comp, 2)
    print(f" {n:3d} | {comp} | {unsig:2d}")
Другие расширения