Что такое ошибка целочисленного переполнения?

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

Что такое ошибка переполнения целых чисел?

Устаревший артефакт из темных веков вычисления.

почему меня это волнует?

Тебе нет.

как этого можно избежать?

Используйте современный язык программирования, в котором целые числа не переполняются. (Lisp, Scheme, Smalltalk, Self, Ruby, Newspeak, Ioke, Haskell, выбирайте ...)

Переполнение - это когда результат арифметической операции не соответствует типу данных операции. У вас может быть переполнение беззнаковым целым числом байтов, если вы добавите 255 + 1, потому что результат (256) не умещается в 8 битах байта.

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

У вас также может быть потеря значимости с типами с плавающей запятой, когда результат операции с плавающей запятой слишком мал для представления в данном типе данных с плавающей запятой. Например, если тип данных с плавающей запятой может обрабатывать показатели в диапазоне от -100 до +100, и вы возводите значение в квадрат с показателем -80, результат будет иметь показатель порядка -160, что не вписывается в заданный тип данных с плавающей запятой.

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

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

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

Сделайте себе одолжение и по крайней мере разработайте и протестируйте свой код с включенной проверкой переполнения.

Проще всего объяснить это на тривиальном примере. Представьте, что у нас есть 4-битное беззнаковое целое число. 0 будет 0000, а 1111 - 15. Поэтому если вы увеличите 15 вместо того, чтобы получить 16, вы вернетесь к 0000, так как 16 на самом деле 10000, а мы не можем представить это менее чем 5 битами. Следовательно, переполнение...

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

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

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

Например, ноль будет представлен как 00000000 (8-битные целые числа), а 127 - как 01111111. Если вы добавите единицу к 127, это "перевернет" биты и поменяет его на 10000000, но в стандартном представлении двух комплиментов это значение фактически используется для представления -128. Это "переполняет" значение.

С беззнаковыми числами происходит то же самое: 255 (11111111) плюс 1 станет 100000000, но так как есть только 8 "битов", это заканчивается как 00000000, то есть 0.

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

Это происходит, когда вы пытаетесь использовать целое число для значения, которое больше, чем внутренняя структура целого числа может поддерживать из-за количества используемых байтов. Например, если максимальный целочисленный размер равен 2 147 483 647, и вы попытаетесь сохранить 3 000 000 000, вы получите ошибку переполнения целого числа.

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

Например, если максимальное значение, которое вы можете иметь, составляет 100000, а ваше текущее значение - 99999, то добавление 2 приведет к «переполнению».

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

Из http://www.first.org/conference/2006/papers/seacord-robert-slides.pdf :

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

P.S .: В PDF-документе есть подробное объяснение переполнения и других состояний целочисленных ошибок, а также способов их устранения / предотвращения.

Из википедии :

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

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