Подписанные / беззнаковые сравнения

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

//from limits.h
#define UINT_MAX 0xffffffff /* maximum unsigned int value */
#define INT_MAX  2147483647 /* maximum (signed) int value */
            /* = 0x7fffffff */

int a = INT_MAX;
//_int64 a = INT_MAX; // makes all warnings go away
unsigned int b = UINT_MAX;
bool c = false;

if(a < b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a > b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a <= b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a >= b) // warning C4018: '<' : signed/unsigned mismatch
    c = true;
if(a == b) // no warning <--- warning expected here
    c = true;
if(((unsigned int)a) == b) // no warning (as expected)
    c = true;
if(a == ((int)b)) // no warning (as expected)
    c = true;

Я думал, что это связано с фоновым продвижением, но последние два, кажется, говорят иначе.

На мой взгляд, первое ==сравнение - это такое же несоответствие знак / без знака, как и другие?

При сравнении подписанного с беззнаковым компилятор преобразует подписанное значение в беззнаковое. Для равенства это не имеет значения -1 == (unsigned) -1. Для других сравнений это имеет значение, например, верно следующее:-1 > 2U .

РЕДАКТИРОВАТЬ: Ссылки:

5/9: (Выражения)

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

• Если один из операндов имеет тип long double, другой должен быть преобразован в long double.

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

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

• В противном случае интегральные акции (4.5) должны выполняться для обоих операндов. 54)

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

• В противном случае, если один операнд является длинным int, а другой - unsigned int, тогда, если длинный int может представлять все значения беззнакового int, беззнаковый int должен быть преобразован в длинный int; в противном случае оба операнда должны быть преобразованы в unsigned long int.

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

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

4,7 / 2: (Интегральные преобразования)

Если целевой тип беззнаковый, результирующее значение является наименьшим беззнаковым целым числом, совпадающим с исходным целым числом (по модулю 2 ^n, где n - количество битов, используемых для представления беззнакового типа). [Примечание: в представлении с дополнением до двух это преобразование является концептуальным, и битовый шаблон не изменяется (если нет усечения). ]

EDIT2: уровни предупреждений MSVC

То, о чем предупреждают о различных уровнях предупреждений MSVC, конечно же, сделано разработчиками. Насколько я понимаю, их выбор в отношении равенства со знаком / без знака и сравнений больше / меньше имеет смысл, это, конечно, полностью субъективно:

-1 == -1означает то же самое, что и -1 == (unsigned) -1- я считаю, что это интуитивный результат.

-1 < 2 не означает то же самое, что и -1 < (unsigned) 2- На первый взгляд это менее интуитивно понятно, и ИМО заслуживает «более раннего» предупреждения.

Почему подписанные / неподписанные предупреждения важны и программисты должны уделять им внимание, демонстрирует следующий пример.

Угадайте вывод этого кода?

#include <iostream>

int main() {
        int i = -1;
        unsigned int j = 1;
        if ( i < j ) 
            std::cout << " i is less than j";
        else
            std::cout << " i is greater than j";

        return 0;
}

Вывод:

i is greater than j

Удивлен? Онлайн-демонстрация: http://www.ideone.com/5iCxY

Итог: для сравнения, если один операнд равен unsigned, то другой операнд неявно преобразуется в, unsigned если его тип подписан!

Оператор == просто выполняет побитовое сравнение (простым делением, чтобы узнать, равен ли он 0).

Сравнение меньше / больше зависит от знака числа.

4-битный пример:

1111 = 15? или -1?

так что если у вас 1111 <0001 ... это неоднозначно ...

но если у вас есть 1111 == 1111 ... Это то же самое, хотя вы этого не имели в виду.

В системе, которая представляет значения с использованием двух дополнений (большинство современных процессоров), они равны даже в своей двоичной форме. Возможно, поэтому компилятор не жалуется на a == b .

И мне кажется странным, что компилятор не предупреждает вас об a == ((int) b) . Я думаю, это должно дать вам предупреждение об усечении целого числа или что-то в этом роде.

Данная строка кода не генерирует предупреждение C4018, поскольку Microsoft использовала другой номер предупреждения (например, C4389 ) для обработки этого случая, а C4389 не включен по умолчанию (например, на уровне 3).

Из документации Microsoft для C4389:

// C4389.cpp
// compile with: /W4
#pragma warning(default: 4389)

int main()
{
   int a = 9;
   unsigned int b = 10;
   if (a == b)   // C4389
      return 0;
   else
      return 0;
};

Другие ответы довольно хорошо объяснили, почему Microsoft, возможно, решила сделать особый случай из оператора равенства, но я считаю, что эти ответы не очень полезны без упоминания C4389 или того, как включить его в Visual Studio .

Я также должен упомянуть, что если вы собираетесь включить C4389, вы также можете рассмотреть возможность включения C4388. К сожалению, официальной документации для C4388 нет, но, похоже, она появляется в следующих выражениях:

int a = 9;
unsigned int b = 10;
bool equal = (a == b); // C4388