请教整型比较时候的类型提升问题

demilich

代码如下，请教为何short和int在比较时候类型提升的结果不一致 ....
==========
user@user:~/Documents/CStudy$ cat typeUp.c
#include <stdio.h>

int main()
{
    short a1 = -1;
    unsigned short a2 = 1;
    if(a1 < a2)
        printf("-1 < 1\n");
    else
        printf("-1 > 1\n");

    int b1 = -1;
    unsigned int b2 = 1;
    if(b1 < b2)
        printf("-1 < 1\n");
    else
        printf("-1 > 1\n");


    return 0;
}
user@user:~/Documents/CStudy$ gcc typeUp.c -o typeUp
user@user:~/Documents/CStudy$ ./typeUp
-1 < 1
-1 > 1

hellioncu

大概是第一个都提升到int，第二个都提升到unsigned int吧

bruceteen

第一个，都提升到 int，即 if( -1 < 1 )
第二个，都提升到 unsigned int，即 if( -1u < 1u )

爻易

为什么提升后的类型不同，是因为按需提升。

第1例提升到int就足以装下signed/unsigned short，所以提升到int就够了，需扩展数位，使用有带符号比较指令。

第2例由于有unsigned int 的存在，int就需要进一步提升到 unsigned int。但因为数据位数不变，并不会实际扩展，仅表现在比较指令改成无符号比较。

井蛙夏虫

c语言标准中有两个概念：integer promotion和arithmetic conversion，你可以google一下

socay2

http://www.idryman.org/blog/2012/11/21/integer-promotion/
这里讲得好详细
c99 规定: 所有长度小于 int  的 都转成 int 比较
所以 unsigned char x = 0xFF ;    char y = 0xFF;
x != y

mymtom_cu

按照标准
b1 < b2
会转成unsigned int后进行比较

3.2.1.5 Usual arithmetic conversions

   Many binary operators that expect operands of arithmetic type cause
conversions and yield result types in a similar way.  The purpose is
to yield a common type, which is also the type of the result.  This
pattern is called the usual arithmetic conversions: First, if either
operand has type long double, the other operand is converted to long
double .  Otherwise, if either operand has type double, the other
operand is converted to double.  Otherwise, if either operand has
type float, the other operand is converted to float.  Otherwise, the
integral promotions are performed on both operands.  Then the
following rules are applied: If either operand has type unsigned long
int, the other operand is converted to unsigned long int.
Otherwise, if one operand has type long int and the other has type
unsigned int, if a long int can represent all values of an unsigned
int, the operand of type unsigned int is converted to long int ; if a
long int cannot represent all the values of an unsigned int, both
operands are converted to unsigned long int.  Otherwise, if either
operand has type long int, the other operand is converted to long int.
Otherwise, if either operand has type unsigned int, the other
operand is converted to unsigned int.  Otherwise, both operands have
type int.