bulgakov

11. Преобразования и переполнение

Присваивание происходит после вычисления правой части. Это уже объясняло, почему double result = 8 / 3; сохраняет 2.0: целочисленное деление успело отбросить дробь. Тот же порядок важен, когда результат получается слишком большим.

Большая переменная не делает вычисление большим

Пусть int занимает 32 бита и вмещает числа до 2 147 483 647. Неверный фрагмент внутри main:

C
int a = 50000;
int b = 50000;
long long product = a * b;

Оба исходных числа помещаются в int. Однако их произведение — 2 500 000 000, что больше его верхней границы.

  1. a и b имеют тип int.
  2. Умножение выполняется в int и выходит за допустимый диапазон.
  3. Присваивание в long long должно было произойти лишь после него — исправить уже неверное вычисление оно не может.

Это знаковое переполнение. В C у него неопределённое поведение: язык не гарантирует результат. Не следует ожидать определённого отрицательного числа или обязательного сообщения об ошибке.

Нужно изменить тип вычисления до умножения. Полная программа для той же системы:

C
#include <stdio.h>

int main(void)
{
    int a = 50000;
    int b = 50000;
    long long product = (long long)a * b;

    printf("%lld\n", product);
    return 0;
}

Вывод:

2500000000

Запись (long long)a получает значение a в типе long long. Для этого умножения значение b тоже преобразуется в long long, и результат помещается в его диапазон. Сами переменные a и b остаются целыми типа int.

Скобки в (long long)(a * b) проблему не решат: в таком варианте преобразование снова происходит после умножения. При работе с числом прямо в исходнике можно задать нужный тип суффиксом: 50000LL * 50000.

Вычисление и сохранение могут дать разные эффекты

Теперь возьмём обычную систему, где unsigned char хранит 0…255, а int имеет 32 бита. Фрагмент внутри main:

C
unsigned char n = 255;
int next = n + 1;
unsigned char wrapped = n + 1;

printf("%d %d\n", next, wrapped);

Вывод — 256 0. Почему сложение с одной и той же переменной привело к разным значениям?

Перед сложением маленький целый тип преобразуется в int, способный вместить все его значения. Такое преобразование называют целочисленным продвижением. Здесь тип int выбирается потому, что он вмещает весь диапазон unsigned char, от 0 до 255. Правило зависит от типов, а не от того, какое конкретное число сейчас хранит n. Поэтому оба выражения n + 1 вычисляются в int и дают 256.

  • В next значение 256 помещается и сохраняется без изменения.
  • В wrapped оно уже не помещается. При сохранении происходит преобразование в беззнаковый восьмибитный тип: 256 становится 0.

При выводе wrapped также передаётся как int, поэтому здесь подходит %d. В общем случае малые целые продвигаются в int, если он вмещает их диапазон; иначе — в unsigned int.

Правило беззнакового преобразования

Для беззнакового типа значения возвращаются в диапазон с шагом максимум плюс один. Для восьми битов шаг равен 256: в диапазоне 0…255 именно столько значений. Вычитаем или прибавляем этот шаг, пока число не окажется внутри диапазона:

Схема
 256 → 256 − 256 = 0
 257 → 257 − 256 = 1
  −1 →  −1 + 256 = 255

Так же по модулю диапазона работает арифметика, когда сама операция выполняется в беззнаковом типе. Это определённое правило; переносить его на знаковое переполнение нельзя.

Если целое значение помещается в новый целый тип, оно сохраняется. Если не помещается в знаковый целевой тип, C17 не задаёт одного результата для всех реализаций. Не стоит рассчитывать на автоматическое «отрезание лишних битов» как на универсальное исправление.

Из дробного значения в целое

Преобразование в int отбрасывает дробную часть к нулю:

Выражение Результат
(int)3.9 3
(int)-3.9 −3

Это не округление до ближайшего целого. Оставшаяся целая часть должна помещаться в целевой тип.

Clang и GCC могут обнаруживать некоторые ошибки вычислений при запуске с флагом -fsanitize=undefined. Такая проверка помогает найти переполнение, но не исправляет программу и не заменяет выбор подходящих типов.

ПрактикаЗагружаем тест…