В чем разница между литералами и переменными в C (подписанный с беззнаковым коротким ints)?

Question

Я видел следующий код в книге Компьютерные системы: перспектива программиста, 2/E. Это хорошо работает и создает желаемый результат. Вывод может быть объяснен различием подписанных и неподписанных представлений.

#include<stdio.h> 
int main() { 
    if (-1 < 0u) { 
     printf("-1 < 0u\n"); 
    } 
    else { 
     printf("-1 >= 0u\n"); 
    } 
    return 0; 
} 

Код выше доходности -1 >= 0u, однако, следующий код, который должен быть таким же, как и выше, не делает! Иными словами,

#include <stdio.h> 

int main() { 

    unsigned short u = 0u; 
    short x = -1; 
    if (x < u) 
     printf("-1 < 0u\n"); 
    else 
     printf("-1 >= 0u\n"); 
    return 0; 
} 

дает -1 < 0u. Почему это произошло? Я не могу это объяснить.

Обратите внимание, что я видел похожие вопросы, такие как this, но они не помогают.

PS. Как сказал @Abhineet, дилемму можно решить, изменив short на int. Однако как объяснить эти явления? Другими словами, -1 в 4 байтах - 0xff ff ff ff, а в 2 байтах - 0xff ff. Учитывая их как 2s-дополнение, которые интерпретируются как unsigned, они имеют соответствующие значения 4294967295 и 65535. Они оба не менее 0, и я думаю, что в обоих случаях выход должен быть -1 >= 0u, то есть x >= u.

Выходной образец для него на небольшой Endian системы Intel:

Для краткости:

-1 < 0u 
u = 
00 00 
x = 
ff ff 

Для междунар:

-1 >= 0u 
u = 
00 00 00 00 
x = 
ff ff ff ff 

Answer 1

Код выше урожайности -1> = 0u

Все целочисленные литералы (числовые constansts) имеют вид и, следовательно, также знаковость. По умолчанию они имеют тип int, который подписан. Когда вы добавляете суффикс u, вы превращаете литерал в unsigned int.

Для любого выражения C, в котором у вас есть один операнд, который подписан, и тот, который не задан, правило выравнивания (формально: the usual arithmetic conversions) неявно преобразует подписанный тип в unsigned.

Преобразование из подписанного в беззнаковое корректно определено (6.3.1.3):

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

Например, для 32-битных чисел на стандартных до два системы комплемента, максимальное значение целого числа без знака является 2^32 - 1 (4294967295, UINT_MAX в limits.h). Больше, чем максимальное значение, равно 2^32. И -1 + 2^32 = 4294967295, поэтому литерал -1 преобразуется в unsigned int со значением 4294967295. Что больше, чем 0.

---

При переключении типов на короткий, однако, вы в конечном итоге с небольшой целочисленного типа. В этом разница между двумя примерами. Всякий раз, когда небольшое число типа является частью выражения, правило продвижения целого неявно преобразует его в больший междунар (6.3.1.1):

Если INT может представлять все значения исходного типа (как ограничено по ширине, для битового поля), значение преобразуется в int; в противном случае он преобразуется в беззнаковый int. Они называются целыми рекламными акциями . Все остальные типы не изменяются целыми акциями.

short Если меньше int на данной платформе (как это имеет место на 32 и 64-битных систем), любой short или unsigned short будет поэтому всегда преобразуются в int, потому что они могут поместиться внутри одного.

Итак, для выражения if (x < u) вы на самом деле заканчиваете if((int)x < (int)u), который ведет себя как ожидалось (-1 меньше 0).

Answer 2

0u не unsigned short, это unsigned int.

Edit :: Объяснение поведения, How comparison is performed ?

Как ответил Jens Gustedt,

Это называется "обычные арифметические преобразования" стандартом и применяется всякий раз, когда две разные целочисленные типы являются операндами того же оператора .

В сущности то, что делает

если типы имеют различную ширину (точнее то, что стандарт вызовы преобразования ранга), то он превращается в более широкий тип, если оба типа имеют такую ​​же ширину, кроме действительно странные архитектуры , беззнаковый из них выигрывает. Подписанный к беззнаковому преобразованию значение -1 с любым типом всегда приводит к наивысшему представляемому значению неподписанного типа.

Более подробный пояснительный блог, написанный им, может быть найден here.

Answer 3

Вы используете целые правила продвижения C.

Операторы по типам, меньшим, чем int, автоматически рекламируют свои операнды до int или unsigned int. См. Комментарии для более подробных объяснений. Существует еще один шаг для двоичных (двух операндов) операторов, если типы по-прежнему не совпадают после этого (например, unsigned int vs. int). Я не буду пытаться суммировать правила более подробно, чем это. См. Ответ Лундина.

This blog post охватывает это более подробно, с аналогичным примером для вашего: подписанного и неподписанного символа. Он цитирует C99 спецификации:

Если INT может представлять все значения исходного типа, значение преобразуется в межд; в противном случае он преобразуется в unsigned int. Они называются целыми акциями. Все остальные типы не изменяются целыми рекламными акциями.

---

Вы можете играть вокруг с этим легче на что-то вроде godbolt, with a function that returns one or zero. Просто посмотрите на выход компилятора, чтобы узнать, что происходит.

#define mytype short 

int main() { 
    unsigned mytype u = 0u; 
    mytype x = -1; 
    return (x < u); 
} 

Answer 4

Кроме того, что вы, кажется, предположить, что это не является свойством определенной ширины типов, здесь 2 байта против 4 байта, а вопрос о правилах, которые должны быть применены. В целых правилах продвижения указано, что short и unsigned short преобразуются в int на всех платформах, где соответствующий диапазон значений вписывается в int. Так как это имеет место здесь, значения сохраняются и получают тип int. -1 прекрасно представлен в int как есть 0. Таким образом, результаты испытаний в -1 меньше, чем 0.

В случае тестирования -1 против 0u обычное преобразование преобразует тип unsigned в качестве общего типа, к которому оба преобразования. -1, преобразованный в unsigned, является значением UINT_MAX, которое больше 0u.

Это хороший пример, почему вы никогда не должны использовать «узкие» типы для выполнения арифметики или сравнения. Используйте их только в том случае, если у вас ограниченное ограничение размера. Это редко бывает для простых переменных, но в основном для больших массивов, где вы действительно можете получить от хранения в узком типе.