Как работает целочисленное деление C++ для предельных и отрицательных значений?

Question

Я столкнулся с некоторыми странными результатами с целым делением на C++. Я пытаюсь вычислить это: -2147483648/-1.

Что я получаю 3 разные результаты в 3-х различных сценариев:

int foo(int numerator, int denominator) { 
    int res = numerator/denominator; // produces SIGFPE, Arithmetic exception interrupt 

    cout << res << endl; 
} 

int main() { 
    int res = -2147483648/-1; 
    cout << res << endl;    // prints -2147483648 
    cout << -2147483648/-1 << endl; // prints 2147483648 
    foo(-2147483648, -1); 
    return 0; 
} 

Почему операция целочисленного деления производит различные результаты в различных ситуациях?

Answer 1

Буквальный -2147483648/-1 вычисляется компилятором, как 2147483648 в типе данных, который является достаточно широким, чтобы держать это значение ,

Когда литерал распечатывается напрямую, он правильно печатает значение.

Когда литерал хранится в res, он отливается int. В вашей системе есть int. Значение 2147483648 не может быть представлено как 32-битное целое число со знаком, поэтому приведение приводит к переполнению. В вашей системе это переполнение приводит к значению -2147483648 (скорее всего, он использует два дополнения).

Наконец, при попытке выполнить разделение во время выполнения (в функции foo), то SIGFPE исключение происходит из-за переполнения (потому что int тип данных не может представлять результат).

Обратите внимание, что все эти три варианта полагаться на платформу зависимого поведении:

• тот факт, что компилятор не создает какие-либо ошибок (или другие проблемы), когда буквенное переполнение вычисления и просто использует тип данных достаточно большие для хранения результата
• того факта, что int переполнения при хранении в буквальном смысле, что генерирует определенное значение (и никаких другие вопросов)
• того факта, что SIGFPE исключения, когда переполнение во время выполнения

Answer 2

Ваш результат может быть INT_MAX+1, другими словами, он, вероятно, переполняется. Это неопределенное поведение, и все может случиться. Например, компилятор может отклонить код напрямую.

(система может иметь INT_MAX >= 2147483648, но тогда можно было бы ожидать того же результата для ваших 3 testcases)

Answer 3

int res = -2147483648/-1; 
cout << res << endl;    // prints -2147483648 
cout << -2147483648/-1 << endl; // prints 2147483648 
int res = numerator/denominator; // produces SIGFPE, Arithmetic exception interrupt 

Примечание не вы никакого отрицательного integer literals.

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

Буквальная 2147483648 больше, чем максимальное значение из int, поэтому его типа будет long (или long long, зависит от реализации).Тогда -2147483648 имеет тип long, а результат расчета (-2147483648/-1) - long.

За 1-й случай, результат 2147483648 типа long является implicitly converted к int, но это больше, чем максимальное значение из int, результат реализации. (Кажется, результат обернут в соответствии с правилами представления (дополнение 2) здесь, так что вы получите результат -2147483648.)

Для второго случая распечатывается результат с типом long, поэтому вы получить правильный результат.

Для 3-й случай, вы делаете расчет на двух int с, и результат не может поместиться в тип результата (т.е. int), signed integer arithmetic operation overflow случилось, поведение не определено. (Здесь генерируется прерывание SIGFPE, прерывание арифметических исключений.)