Обработка переполнения при приведении удвоений к целым числам в C

При преобразовании чисел с плавающей точкой в ​​целые числа переполнение вызывает неопределенное поведение. Из спецификации C99, раздел 6.3.1.4 Реальные числа с плавающей запятой и целые числа:

Когда конечное значение вещественного типа с плавающей запятой преобразуется в целочисленный тип, отличный от _Bool, дробная часть отбрасывается (т. Е. Значение обрезается до нуля). Если значение составной части не может быть представлено целочисленным типом, поведение не определено.

Вы должны проверить диапазон вручную, но не используйте такой код, как:

// DON'T use code like this!
if (my_double > INT_MAX || my_double < INT_MIN)
    printf("Overflow!");

INT_MAX - целочисленная константа, которая может не иметь точного представления с плавающей запятой. При сравнении с числом с плавающей запятой оно может быть округлено до ближайшего большего или ближайшего меньшего представимого значения с плавающей запятой (это определяется реализацией). Например, для 64-битных целых чисел INT_MAX равно 2^63 - 1, которое обычно округляется до 2^63, поэтому проверка по существу становится my_double > INT_MAX + 1. Это не обнаружит переполнения, если my_double равно 2^63.

Например, с gcc 4.9.1 в Linux следующая программа

#include <math.h>
#include <stdint.h>
#include <stdio.h>

int main() {
    double  d = pow(2, 63);
    int64_t i = INT64_MAX;
    printf("%f > %lld is %s\n", d, i, d > i ? "true" : "false");
    return 0;
}

отпечатки

9223372036854775808.000000 > 9223372036854775807 is false

Трудно понять это правильно, если вы заранее не знаете пределы и внутреннее представление целочисленных и двойных типов. Но если вы, например, конвертируете из double в int64_t, вы можете использовать константы с плавающей запятой, которые являются точными двойниками (при условии, что два дополнения и двойники IEEE):

if (!(my_double >= -9223372036854775808.0   // -2^63
   && my_double <   9223372036854775808.0)  // 2^63
) {
    // Handle overflow.
}

Конструкция !(A && B) также правильно обрабатывает NaN. Переносимая, безопасная, но немного неточная версия для ints:

if (!(my_double > INT_MIN && my_double < INT_MAX)) {
    // Handle overflow.
}

Это проявляет осторожность и ошибочно отклоняет значения, равные INT_MIN или INT_MAX. Но для большинства приложений это должно быть нормально.

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

if (my_double > nextafter(INT_MAX, 0) || my_double < nextafter(INT_MIN, 0))
    printf("Overflow!");
else
    my_int = (int)my_double;

РЕДАКТИРОВАТЬ: nextafter() решит проблему, упомянутую nwellnhof

Чтобы ответить на ваш вопрос: поведение, когда вы приводите значения с плавающей запятой за пределы диапазона, не определено или зависит от реализации.

Говоря по опыту: я работал над системой MIPS64, в которой вообще не реализовывалось такое приведение. Вместо того, чтобы делать что-то детерминированное, ЦП выдал исключение ЦП. Обработчик исключения, который должен имитировать приведение, возвращенный, ничего не влияя на результат.

Я закончил со случайными целыми числами. Угадайте, сколько времени потребовалось, чтобы отследить ошибку до этой причины. :-)

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

Переносимый способ для C ++ - использовать класс SafeInt:

http://www.codeplex.com/SafeInt

Реализация позволит выполнять обычное сложение / вычитание / и т. Д. Для числового типа C ++, включая приведение типов. Он будет генерировать исключение всякий раз, когда обнаруживается сценарий переполнения.

SafeInt<int> s1 = INT_MAX;
SafeInt<int> s2 = 42;
SafeInt<int> s3 = s1 + s2;  // throws

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

SafeInt теперь работает как в GCC, так и в Visual Studio.

Как лучше всего обнаружить это недостаточное / переполнение?

Сравните усеченный double с точными пределами около INT_MIN,INT_MAX.

Уловка состоит в том, чтобы точно преобразовать ограничения на основе INT_MIN,INT_MAX в double значения. double может не точно представлять INT_MAX, поскольку количество битов в int может превышать точность этой плавающей запятой. В этом случае преобразование INT_MAX в double страдает от округления. Число после INT_MAX является степенью двойки и, безусловно, может быть представлено как double. 2.0*(INT_MAX/2 + 1) генерирует целое число, которое на единицу больше INT_MAX.

То же самое относится к INT_MIN на машинах без дополнения до 2s.

INT_MAX всегда является степенью двойки - 1.
INT_MIN всегда:
-INT_MAX (не дополнение до 2) или
-INT_MAX-1 (дополнение до 2)

int double_to_int(double x) {
  x = trunc(x);
  if (x >= 2.0*(INT_MAX/2 + 1)) Handle_Overflow();
  #if -INT_MAX == INT_MIN
  if (x <= 2.0*(INT_MIN/2 - 1)) Handle_Underflow();
  #else
  if (x < INT_MIN) Handle_Underflow();
  #endif
  return (int) x;
}

Чтобы определить NaN и не использовать trunc()

#define DBL_INT_MAXP1 (2.0*(INT_MAX/2+1)) 
#define DBL_INT_MINM1 (2.0*(INT_MIN/2-1)) 

int double_to_int(double x) {
  if (x < DBL_INT_MAXP1) {
    #if -INT_MAX == INT_MIN
    if (x > DBL_INT_MINM1) {
      return (int) x;
    }
    #else
    if (ceil(x) >= INT_MIN) {
      return (int) x;
    }
    #endif 
    Handle_Underflow();
  } else if (x > 0) {
    Handle_Overflow();
  } else {
    Handle_NaN();
  }
}

Встречаем тот же вопрос. Такие как:

double d = 9223372036854775807L;
int i = (int)d;

в Linux / window, i = -2147483648. но в AIX 5.3 i = 2147483647.

Если дубль выходит за пределы диапазона interger.

• Linux / window всегда возвращает INT_MIN.
• AIX вернет INT_MAX, если double является положительным, вернет INT_MIN, если double является отрицательным.

Другой вариант - использовать boost :: numeric_cast, который позволяет произвольно преобразовывать числовые типы. Он обнаруживает потерю диапазона при преобразовании числового типа и выдает исключение, если диапазон не может быть сохранен.

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

Конечно, это уже не простой C ;-)

Я не уверен в этом, но я думаю, что можно «включить» исключения с плавающей запятой для недостаточного / переполнения ... взгляните на это Работа с исключениями с плавающей запятой в MSVC7 \ 8, чтобы у вас была альтернатива проверкам if / else.

Я не могу сказать вам наверняка, определен ли он для всех платформ, но это почти то, что происходило на каждой платформе, которую я использовал. Только вот, по моему опыту, это катит. То есть, если значение типа double равно INT_MAX + 2, тогда, когда результатом приведения будет INT_MIN + 2.

Что касается лучшего способа справиться с этим, я действительно не уверен. Я сам столкнулся с этой проблемой и еще не нашел элегантного способа ее решения. Я уверен, что кто-нибудь ответит, что поможет нам обоим.