Підписання / без підпису порівняння

Я намагаюся зрозуміти, чому наступний код не видає попередження у вказаному місці.

//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.

EDIT: Список літератури:

5/9: (вирази)

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

• Якщо один з операндів має тип long double, інший повинен бути перетворений у long double.

• В іншому випадку, якщо будь-який операнд подвійний, інший повинен бути перетворений у подвійний.

• В іншому випадку, якщо будь-який операнд є плаваючим, інший повинен бути перетворений у плаваючий.

• В іншому випадку цілісні акції (4.5) повинні виконуватися на обох операндах. 54)

• Потім, якщо будь-який операнд не має знака довгий, інший повинен бути перетворений у довгий без знака.

• В іншому випадку, якщо один операнд - це довгий int, а інший - беззнаковий int, то, якщо довгий int може представляти всі значення беззнакового int, беззнаковий int повинен бути перетворений у довгий int; інакше обидва операнди повинні бути перетворені в беззнакові 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 ... Це те саме, хоча ви не мали на увазі, що це має бути.

У системі, яка представляє значення з використанням 2-комплементу (більшість сучасних процесорів), вони рівні навіть у своїй двійковій формі. Ось чому компілятор не скаржиться на 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