C语言运算中的数据类型自动转换原则

1、隐式转换
C在以下四种情况下会进行隐式转换:
1、算术运算式中，低类型能够转换为高类型。
2、赋值表达式中，右边表达式的值自动隐式转换为左边变量的类型，并赋值给他。
3、函数调用中参数传递时，系统隐式地将实参转换为形参的类型后，赋给形参。
4、函数有返回值时，系统将隐式地将返回表达式类型转换为返回值类型，赋值给调用函数。

2、算数运算的隐式转换
算数运算中，首先有如下类型转换规则：
1、字符必须先转换为整数(C语言规定字符类型数据和整型数据之间可以通用) 。
2、short型转换为int型(同属于整型) 。
3、float型数据在运算时一律转换为双精度(double)型，以提高运算精度(同属于实型) 。
其次，有下面的规则。

当不同类型的数据进行操作时，应当首先将其转换成相同的数据类型，然后进行操作，转换规则是由低级向高级转换。转换规则如下图所示:

有符号数与无符号数之间运算问题
以下实验均在virual c++6中运行通过
这个问题测试是否懂得C语言中的整数自动转换原则，有些开发者懂得极少这些东西。当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此，从这个意义上讲，无符号数的运算优先级要高于有符号数，这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。
首先进行一个实验，分别定义一个signed int型数据和unsigned int型数据，然后进行大小比较：
unsigned int a=20;
signed int b=-130;
a>b?还是b>a？实验证明b>a，也就是说－130>20,为什么会出现这样的结果呢？
这是因为在C语言操作中，如果遇到无符号数与有符号数之间的操作，编译器会自动转化为无符号数来进行处理，因此a＝20，b＝4294967166，这样比较下去当然b>a了。
再举一个例子：
unsigned int a=20;
signed int b=-130;
cout< < b+30 << std::endl
输出为-100。

而对于浮点数来说，浮点数（float，double）实际上都是有符号数，unsigned 和signed前缀不能加在float和double之上，当然就不存在有符号数根无符号数之间转化的问题了。

一、unsigned int变量跟int类型的变量运算时得出的结果是什么类型的？

1、先看一个有趣的例子：

    int a = 3;
    unsigned int b = -6; 
    printf("%d\n", a+b);
    if((a+b)>0)
    {
             printf("yes\n");
    }
    else
    {
            printf("no\n");
    }
    return 0;

}
运行结果：
-3
yes
1
2
3
看到这个运行结果，很多小伙伴开始疑惑了？unsigned int类型怎么可以赋值一个-6？既然打印出来结果是-3<0，为什么还打印出来是yes？有这些问题的小伙伴且听我娓娓道来。

（1）必须知道的是：
①int类型和unsigned int类型的差别。unsigned int类型比int类型的容量大是因为，unsigned int是无符号类型的，所以最高位不表示正负，而int类型的最高位是表示正负的，1表示负数，0表示正数。

②计算机中负数的存储方式——其补码。在计算机中，负数存储的方式都是以其其补码形式储存，例如：6在计算机的存储形式是0000 0000 0000 0110（32位计算机中），而-6是1000 0000 0000 0110 （32位机下）（最高位是符号位），补码也就是1111 1111 1111 1010（32位计算机中），补码=原码取反+1。

③赋值一个负数给unsigned int类型的变量，它的意思就是将-6这个数的补码形式（1111 1111 1111 1010（32位机下））形式存到一个叫b的空间中，下次我读取这个数的时候，是使用b这个名字，按照b这个名字的类型来读取的，所以当b是unsigned int类型的时候，就不考虑最高位是符号位，则b = 1111 1111 1111 1010（32位机下）（因为是无符号），当b是int类型的时候，考虑最高位是符号位（1为负数，0为正数），当发现是1的时候也就是负数的时候，计算机会把它转换成为原码从而读出是-6。所以一个变量的类型是决定读取这个变量存储的数的方式。

④隐式转换。当unsigned int类型与int类型运算时，如果没有指出转换的类型，它会进行“隐式转换”转换为unsigned int类型，也可以记住，不同类型进行运算时，没指出转换的类型时，它会往容量大的那总类型转换，因为这样可以更加容易避免溢出嘛。

（2）代码分析：
首先，定义了一个 int a = 3 。a的存储以3的二进制形式存储。 unsigned int b = -6 。b的存储是以其补码存储的，也就是1111 1111 1111 1010（32位机下）。当执行a+b的时候，printf函数要求指定打印出%d，所以，a以int（%d）类型读取出来，也就是3；b也是以int（%d）类型读取出来，也就是-6，所以3+（-6）=-3，发现打印结果是-3。而在后面的 if((a+b)>0) 判断中，(a+b)中并没有指定读取的类型，所以就进行隐式转换，a就转成unsigned int类型，也就是3；b转成unsigned int类型，因为b本来的存储是1111 1111 1111 1010（32位机下），转成unsigned int类型时不考虑符号位，所以就直接以补码的形式转化，也就是65530（32位机下），所以a+b=65533>0，输出yes。

二、总结
①当一个int类型的a与unsigned int类型的b相运算时，例如：a+b的时候，如果直接是a+b的话，各个变量就会隐式转换成为unsigned int的类型再相加。

②当用print函数指定打印的时候，例如：printf（”%d\n”,a+b），就要各个变量转换为%d的类型再想加。

③当用一个int c类型去装这个结果时，如：c=a+b，同理，a和b会根据c的类型去分别转换跟c一致的类型再去运算。

有如下程序：
void main()
{
int a=-1;
unsigned int b=16;
int c=-17;
printf(“%u\n”,a+b);
printf(“%u\n”,c+b);//表示为unsigned int输出
printf(“%d\n”,c+b);//%d表示为int型输出
system(“pause”);
}
输出结果为：
15
4294967295
-1
其实运算a+b或者c+b时都是现将其转化成unsigned int型再进行运算的，
a的补码为0xFFFFFFFF,当将其转化为无符号数时为4294967295
b的补码为0x00000010，两个相加会溢出，结果为0x0000000F,即15
c的补码为0xFFFFFFEF,转化为无符号数为4294967279，c和b相加为4294967295。它是-1的补码

其实我们可以肉眼先求出-17+16=-1，然后求出-1的unsigned 值

又有如下：
1. #include
2. /*
3. 当表达式中存在符号类型和无符号类型时
4. 所有的操作数都自动转换为无符号类型
5. */
6. char getChar(int x,int y){
7. char c;
8. unsigned int a=x;
9. unsigned int b=a+y;
10. (a+y>10)?(c=1):(c=2);
11. return c;
12. }
13. void main(){
14. char c1=getChar(7,4);
15. char c2=getChar(7,3);
16. char c3=getChar(7,-7);
17. char c4=getChar(7,-8);
18.
19. printf(“c1=%d\n”,c1);
20. printf(“c2=%d\n”,c2);
21. printf(“c3=%d\n”,c3);
22. printf(“c4=%d\n”,c4);
23. system(“pause”);
24. }
输出结果为：
c1 = 1 c2= 2 c3= 2 c4= 1
注意：（-7）+7=0，其unsigned 的值还是0
但是 （-8）+7=-1，其unsigned的值远远大于0