(-2147483648> 0) возвращает true в C ++?

-2147483648 - это наименьшее целое число для целочисленного типа с 32 битами, но кажется, что оно будет переполнено в if(...)предложении:

if (-2147483648 > 0)
    std::cout << "true";
else
    std::cout << "false";

Это напечатает trueв моем тестировании. Однако, если мы приведем -2147483648 к целому числу, результат будет другим:

if (int(-2147483648) > 0)
    std::cout << "true";
else
    std::cout << "false";

Это напечатает false.

Я запутался. Кто-нибудь может дать объяснение по этому поводу?

Обновление 02-05-2012:

Спасибо за ваши комментарии, в моем компиляторе размер int составляет 4 байта. Я использую VC для простого тестирования. Я изменил описание в моем вопросе.

Это очень много хороших ответов в этом посте. AndreyT дал очень подробное объяснение того, как компилятор будет вести себя при таком вводе, и как реализовано это минимальное целое число. qPCR4vir, с другой стороны, дал некоторые связанные «курьезы» и то, как представлены целые числа. Так впечатляет!

-2147483648это не "число". Язык C ++ не поддерживает отрицательные литеральные значения.

-2147483648на самом деле выражение: положительное буквальное значение 2147483648с унарным -оператором перед ним. Значение 2147483648слишком велико для положительной стороны intдиапазона на вашей платформе. Если тип long intимеет больший диапазон на вашей платформе, компилятор должен будет автоматически предположить, что он 2147483648имеет long intтип. (В C ++ 11 компилятору также придется учитывать long long intтип.) Это заставит компилятор вычислять -2147483648в области большего типа, и результат будет отрицательным, как и следовало ожидать.

Однако, по-видимому, в вашем случае диапазон long intсовпадает с диапазоном int, и в целом нет целочисленного типа с большим диапазоном, чем intна вашей платформе. Формально это означает, что положительная константа 2147483648переполняет все доступные целочисленные типы со знаком, что, в свою очередь, означает, что поведение вашей программы не определено. (Немного странно, что спецификация языка в таких случаях выбирает неопределенное поведение, вместо того, чтобы требовать диагностическое сообщение, но это так.)

На практике, принимая во внимание, что поведение не определено, 2147483648может интерпретироваться как некое зависящее от реализации отрицательное значение, которое становится положительным после -применения к нему унарного кода. Альтернативно, некоторые реализации могут решить попытаться использовать неподписанные типы для представления значения (например, в C89 / 90 компиляторы должны были использоваться unsigned long int, но не в C99 или C ++). Реализациям разрешено делать что угодно, поскольку поведение в любом случае не определено.

В качестве примечания, это причина, почему такие константы, как INT_MINправило, определяются как

#define INT_MIN (-2147483647 - 1)

вместо, казалось бы, более простой

#define INT_MIN -2147483648

Последний не будет работать как задумано.

Компилятор (VC2012) повышает до "минимальных" целых чисел, которые могут содержать значения. В первом случае signed int(и long int) не может (до применения знака), но unsigned intможет: 2147483648имеетunsigned int ???? тип. Во втором вы вынуждаете intот unsigned.

const bool i= (-2147483648 > 0) ;  //   --> true

предупреждение C4146: унарный оператор минус применяется к типу без знака , результат все еще без знака

Здесь связаны "курьезы":

const bool b= (-2147483647      > 0) ; //  false
const bool i= (-2147483648      > 0) ; //  true : result still unsigned
const bool c= ( INT_MIN-1       > 0) ; //  true :'-' int constant overflow
const bool f= ( 2147483647      > 0) ; //  true
const bool g= ( 2147483648      > 0) ; //  true
const bool d= ( INT_MAX+1       > 0) ; //  false:'+' int constant overflow
const bool j= ( int(-2147483648)> 0) ; //  false : 
const bool h= ( int(2147483648) > 0) ; //  false
const bool m= (-2147483648L     > 0) ; //  true 
const bool o= (-2147483648LL    > 0) ; //  false

Стандарт C ++ 11 :

2.14.2 Целочисленные литералы [lex.icon]

...

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

...

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

Если целочисленный литерал не может быть представлен каким-либо типом в его списке, и расширенный целочисленный тип (3.9.1) может представлять его значение, он может иметь этот расширенный целочисленный тип. Если все типы в списке для литерала подписаны, расширенный целочисленный тип должен быть подписан. Если все типы в списке для литерала не подписаны, расширенный целочисленный тип должен быть без знака. Если список содержит типы со знаком и без знака, расширенный целочисленный тип может быть как со знаком, так и без знака. Программа плохо сформирована, если один из ее модулей перевода содержит целочисленный литерал, который не может быть представлен ни одним из разрешенных типов.

И это правила продвижения для целых чисел в стандарте.

4.5 Интегральные акции [conv.prom]

Prvalue целого типа, кроме bool, char16_t, char32_tили wchar_tчье число преобразования ранга (4.13) меньше , чем ранг Int может быть преобразован в prvalue типа , intесли intможет представлять все значения типа источника; в противном случае исходное значение prvalue может быть преобразовано в значение типа prvalue unsigned int.

Короче говоря, 2147483648переполняет -2147483648, и (-(-2147483648) > 0)есть true.

Это то , как 2147483648выглядит в двоичной форме .

Кроме того, в случае двоичных вычислений со знаком наиболее значимым битом («MSB») является знаковый бит. Этот вопрос может помочь объяснить почему.

Поскольку -2147483648на самом деле к нему применяется 2147483648negation ( -), число не соответствует ожидаемому. На самом деле это эквивалент этого псевдокода:operator -(2147483648)

Теперь, если предположить, что ваш компилятор sizeof(int)равен 4и CHAR_BITопределен как 8, это сделает 2147483648переполнение максимальным знаковым значением целого числа (2147483647 ). Так какой же максимум плюс один? Давайте разберемся с 4-битным целым числом комплимента 2s.

Подождите! 8 переполняет целое число! Что мы делаем? Используйте его беззнаковое представление 1000и интерпретируйте биты как целое число со знаком. Это представление оставляет нам -8применение отрицания дополнения 2s 8, которое, как мы все знаем, больше, чем 0.

Вот почему <limits.h>(и <climits>) обычно определяют INT_MINкак ((-2147483647) - 1)- так, что максимальное целое число со знаком ( 0x7FFFFFFF) отрицается ( 0x80000001), а затем уменьшается ( 0x80000000).