Почему 0 <-0x80000000?

У меня ниже простая программа:

#include <stdio.h>

#define INT32_MIN        (-0x80000000)

int main(void) 
{
    long long bal = 0;

    if(bal < INT32_MIN )
    {
        printf("Failed!!!");
    }
    else
    {
        printf("Success!!!");
    }
    return 0;
}

Условие if(bal < INT32_MIN )всегда верно. Как это возможно?

Он отлично работает, если я изменю макрос на:

#define INT32_MIN        (-2147483648L)

Кто-нибудь может указать на проблему?

Это довольно тонко.

Каждый целочисленный литерал в вашей программе имеет тип. Какой тип он имеет, регулируется таблицей в 6.4.4.1:

Suffix      Decimal Constant    Octal or Hexadecimal Constant

none        int                 int
            long int            unsigned int
            long long int       long int
                                unsigned long int
                                long long int
                                unsigned long long int

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

• Пытаться int
• Если это не подходит, попробуйте long
• Если это не подходит, попробуйте long long.

Шестнадцатеричные литералы ведут себя иначе! Если литерал не может вписаться в подписанный тип, например int, он сначала попытается, unsigned intпрежде чем перейти к использованию более крупных типов. Смотрите разницу в таблице выше.

Так что в 32-битной системе ваш литерал 0x80000000имеет тип unsigned int.

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

bal < INT32_MINвызывает обычные арифметические преобразования и результат выражения 0x80000000повышается с unsigned intдо long long. Значение 0x80000000сохраняется и 0 меньше 0x80000000, отсюда и результат.

Когда вы заменяете литерал на 2147483648Lвас, используйте десятичную нотацию, и поэтому компилятор не выбирает unsigned int, а пытается разместить его внутри long. Также суффикс L говорит, что вы хотите, long если это возможно . Суффикс L на самом деле имеет аналогичные правила, если вы продолжаете читать упомянутую таблицу в 6.4.4.1: если число не соответствует запрошенному long, чего не происходит в 32-битном случае, компилятор даст вам, long longгде он подойдет просто отлично.

0x80000000является unsignedлитералом со значением 2147483648.

Применение унарного минуса к этому все еще дает вам тип без знака с ненулевым значением. (На самом деле, для ненулевого значения xзначение, которое вы в итоге получите, равно UINT_MAX - x + 1.)

Этот целочисленный литерал 0x80000000имеет тип unsigned int.

Согласно стандарту C (6.4.4.1 Целочисленные константы)

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

И эта целочисленная константа может быть представлена ​​типом unsigned int.

Так что это выражение

-0x80000000имеет тот же unsigned intтип. Кроме того, он имеет то же значение 0x80000000в представлении дополнения двух, которое рассчитывает следующим образом

-0x80000000 = ~0x80000000 + 1 => 0x7FFFFFFF + 1 => 0x80000000

Это имеет побочный эффект, если написать, например,

int x = INT_MIN;
x = abs( x );

Результат будет снова INT_MIN.

Таким образом, в этом состоянии

bal < INT32_MIN

там сравнивается 0с беззнаковое значение 0x80000000преобразуется к типу INT долго долго в соответствии с правилами обычных арифметических преобразований.

Очевидно, что 0 меньше, чем 0x80000000.

Числовая константа 0x80000000имеет тип unsigned int. Если мы возьмем -0x80000000и сделаем 2s комплимент по математике, мы получим это:

~0x80000000 = 0x7FFFFFFF
0x7FFFFFFF + 1 = 0x80000000

Так -0x80000000 == 0x80000000. И сравнение (0 < 0x80000000)(так 0x80000000как без знака) верно.

Когда мы думаем, что -это часть числовой константы, возникает путаница .

В приведенном ниже коде 0x80000000числовая константа. Его тип определяется только по этому. -Применяется после и не меняет тип .

#define INT32_MIN        (-0x80000000)
long long bal = 0;
if (bal < INT32_MIN )

Необработанные необработанные числовые константы являются положительными.

Если это десятичное, то тип присвоенный первый типа , который будет держать его: int, long, long long.

Если константа восьмеричный или шестнадцатеричный, он получает первый тип , который держит его: int, unsigned, long, unsigned long, long long, unsigned long long.

0x80000000, в системе ОП получает тип unsignedили unsigned long. В любом случае, это какой-то неподписанный тип.

-0x80000000также является некоторым ненулевым значением и является незнаковым типом, он больше 0. Когда код сравнивает это с a long long, значения не изменяются на 2 сторонах сравнения, так 0 < INT32_MINчто верно.

Альтернативное определение избегает этого любопытного поведения

#define INT32_MIN        (-2147483647 - 1)

Давайте прогуляемся по фэнтезийной земле на некоторое время, где intи unsigned48-битные.

Тогда 0x80000000вписывается intи так тип int. -0x80000000затем отрицательное число и результат распечатки отличается.

[Назад к реальному слову]

Поскольку 0x80000000вписывается в некоторый неподписанный тип перед подписанным типом, поскольку он просто больше, чем some_signed_MAXвнутри some_unsigned_MAX, это некоторый неподписанный тип.

C имеет правило, что целочисленный литерал может быть signedили unsignedзависит от того, подходит ли он signedили unsigned(целочисленное продвижение). На 32-битной машине литерал 0x80000000будет unsigned. 2-е дополнение -0x80000000находится 0x80000000 на 32-битной машине. Таким образом, сравнение bal < INT32_MINмежду signedи unsignedи перед сравнением в соответствии с правилом C unsigned intбудет преобразован в long long.

С11: 6.3.1.8/1:

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

Поэтому bal < INT32_MINвсегда есть true.