目录

一、表达式求值

1.1 隐式类型转换

1.1.1 什么是整型提升（整型提升）

1.1.2 整型提升的意义

1.1.3 有符号（signed）与无符号（unsigned）的区别

1.1.4 有符号（signed）类型的整型提升

1.1.5 无符号（unsigned）整形提升

1.1.6 整型提升例子

1.2 算术转换

1.3 操作符的属性

二、位操作符的一些例题

三、数据类型大小

一、表达式求值

       表达式求值的顺序一部分是由操作符的优先级和结合性决定。同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型

1.1隐式类型转换

1.1.1 什么是整型提升（整型提升）

       C语言的整型算术运算总是至少以缺省整型类型的精度来进行的，为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升

1.1.2 整型提升的意义

       表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

       因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度

       通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算

1.1.3 有符号（signed）与无符号（unsigned）的区别

       首先在计算机中，有符号数是可以用来区分数值的正负，而无符号数仅有正值，没有负值

 其次当一个数是无符号数时，它的最高位仅用来表示该数的大小。而当一个数是有符号数时，此时的最高位称为符号位；该符号位为1时表示该数为负值，为 0 时则表示为正值

       最后有符号数和无符号数两者表示的范围不同，即同样长度的字节，有符号数比无符号数的最大值出现缩水

二者最明显的区别就是二者表示的范围不同：

• 无符号数中，所有的位都用于直接表示该值的大小
• 有符号数中最高位用于表示正负，所以，当为正值时，该数的最大值就会变小

1.1.4 有符号（signed）类型的整型提升

有符号类型整形提升的时候，高位补充符号位，即为 0 或 1

假设平台都是 32位

1）正数的整形提升

charb=1;
1的补码是：00000000000000000000000000000001变量b的类型是char，二进制位(补码)中只有8个比特位（一个字节）：b在内存中存储为：00000001（补码截取8个bit）因为char为有符号的char，如果b进行整型计算，就会发生整型提升整形提升的时候，高位补充符号位，即为0提升之后的结果是：00000000000000000000000000000001

简单说一下，char 虽然是字符类型，但字符类型储存的时候，储存的是字符的ASCII码值，ASCII值是整数，所以 char 的存储依旧与整型存储一样

       char 在我当前的编译器 vs2019 是有符号型，不同的编译器会有不同的情况，因为 char 在C语言中未定义为有符号还是无符号，有符号还是无符号取决的编译器

2）负数的整型提升

charb=-1;
-1的补码是：11111111111111111111111111111111变量b的类型是char，二进制位(补码)中只有8个比特位（一个字节）：b在内存中存储为：11111111（补码截取后8个bit）因为char为有符号的char，如果b进行整型计算，就会发生整型提升整形提升的时候，高位补充符号位，即为1提升之后的结果是：11111111111111111111111111111111

1.1.5 无符号（unsigned）整形提升

有符号类型整形提升的时候，高位补充 0

charb=-1;
-1的补码是：11111111111111111111111111111111变量b的类型是char，二进制位(补码)中只有8个比特位（一个字节）：b在内存中存储为：11111111（补码截取后8个bit）因为char为无符号的char，如果b进行整型计算，就会发生整型提升整形提升的时候，高位补0提升之后的结果是：00000000000000000000000011111111

之上简而言之，有符号与无符号的整型提升的区别就是

有符号的整型提升高位补 符号位

无符号的整型提升高位补 0

1.1.6 整型提升例子

例子1：

测试代码

#include <stdio.h>intmain()
{
chara=3;
charb=127;
charc=a+b;
printf("%d\n", c);
return0;
}

运行结果是：-126

原因解释如下：

首先，我们先看 3是一个整型，占 4 个字节，32 个bit位；127 也是如此，占4个字节

3 和 127 的二进制原码的补码

3的补码：00000000000000000000000000000011127的补码：00000000000000000000000001111111（正数的原、反、补相同）

int类型是 4 个字节，32 个bit位，而char类型只能储存 1 个字节，也就是 8 个 bit 位，所以 char 会发生截断，即选择 32 位中的最低位放入 char 中，也就是后八位

所以 3 和 127 在char类型中只能储存 8 个 bit，如下（补码）

1.   3：00000011
2. 127: 01111111

接下来 a 和 b 是如何相加的

       a 和 b自身的大小都是8个比特位占一个字节（char类型），没有达到一个整型的大小（4字节）。在计算时为了能够提升计算精度，要将a和b整型提升

整型提升是按照变量的数据类型的符号位来进行提升的

a 和 b，a 和 b 现在是有符号的字符型变量，最高位0是它的符号位。高位通通补0，补全32个比特位

a整型提升前:00000011//最高位的0是它的符号位a整型提升后:00000000000000000000000000000011b整型提升前:01111111//最高位的0是它的符号位b整型提升后:00000000000000000000000001111111

整型提升后 a 和 b 进行二进制相加，结果为

a+b:00000000 00000000 00000000 10000010

现在要将结果放入 c 中，而c又是 char 型，又要发生截断

c:100000010

此时还不能直接打印输出，因为 printf 函数中是以 %d 的形式进行打印，又要对 c 进行整型提升

c 的类型是有符号字符型，最高位 1 为他的符号位，高位通通补1，补全32个比特位

c整型提升前:10000010c整型提升后:11111111111111111111111110000010

此时 c 得到的是补码，还要反推原码才能打印

c的补码:11111111111111111111111110000010c的反码:11111111111111111111111110000001c的原码:10000000000000000000000001111110

接下来二进制转换成十进制就可以打印 c 了，结果是 -126

例子2：

测试代码

#include <stdio.h>intmain()
{
chara=0xb6;
shortb=0xb600;
intc=0xb6000000;
if (a==0xb6)
printf("a");
if (b==0xb600)
printf("b");
if (c==0xb6000000)
printf("c");
return0;
}

运行结果

解释：

       a,b要进行整形提升,但是c不需要整形提升；a,b整形提升之后,变成了负数，所以表达式 a==0xb6 , b==0xb600 的结果是假，但是c不发生整形提升，则表达式 c==0xb6000000 的结果是真，所以最后打印 c

例子3：

#include <stdio.h>intmain()
{
charc=1;
printf("%d\n", sizeof(c));
printf("%d\n", sizeof(+c));
printf("%d\n", sizeof(-c));
return0;
}

运行结果

解释：

       c 只要参与表达式运算，就会发生整形提升，表达式 +c 就会发生提升，所以 sizeof(+c) 是4个字节。表达式 -c 也会发生整形提升，所以 sizeof(-c) 是4个字节，但是 sizeof(c) ，就是1个字节

----------------我是分割线---------------  

1.2 算术转换

       如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行

下面的层次体系称为寻常算术转换

longdoubledoublefloatunsignedlongintlongintunsignedintint

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算，简单来说就是：从下往上转换。比如，a 的类型是 int，b 的类型是 double，进行 a+b 是，int 就会转换成 double 类型，再进行计算

例如

#include<stdio.h> intmain()
{
inta=3;
floatb=3.5;
floatc=a+b;
//算术转换，int-->float //结果为 6.5return0;
}

调试查看：

注意区分：整型提升是不足 4 个字节才会发生整型提升，像 char（1字节） short（2字节）...（32位平台下）,这些就会发生整型提升。如果超过了4个字节的不同类型计算，就会发生算术转换，向高位进行转换

警告：但是算术转换要合理，要不然会有一些潜在的问题

1. float f = 3.14;
2. int num = f;//隐式转换，会有精度丢失

----------------我是分割线---------------  

1.3 操作符的属性

复杂表达式的求值有三个影响的因素

• 1. 操作符的优先级

• 2. 操作符的结合性
• 3. 是否控制求值顺序

两个相邻的操作符先执行哪个？

取决于他们的优先级，如果两者的优先级相同，取决于他们的结合性

优先级图表

结合性说明：N/A 意思是同级运算没有顺序要求；L-R 意思是同级运算有顺序要求，方向为自左向右；R-L 意思是同级运算有顺序要求，方向为自右向左

注意：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的

二、位操作符的一些例题

1、编写代码实现：求一个整数存储在内存中的二进制中1的个数

思路：用位操作符解决比较优，也可以使用其它方法

inta=3;
00000000000000000000000000000011a&1000000000000000000000000000000110000000000000000000000000000000100000000000000000000000000000001//>> <<

代码如下：

#include <stdio.h>intmain()
{
intnum=-1;
inti=0;
intcount=0;//计数for (i=0; i<32; i++)
    {
if (num& (1<<i))
count++;
    }
printf("二进制中1的个数 = %d\n", count);
return0;
}

2、不能创建临时变量（第三个变量），实现两个数的交换

思路：使用位操作解决

3^3=0->a^a=03：0113：011结果：0000^5=5->0^a=a0001011013^3^5=53^5^3=5结论：异或操作符支持交换律

代码如下：

#include <stdio.h>intmain()
{
inta=10;
intb=20;
a=a^b;
b=a^b;
a=a^b;
printf("a = %d b = %d\n", a, b);
return0;
}

三、数据类型大小

char//字符数据类型short//短整型int//整形long//长整型longlong//更长的整形float//单精度浮点数double//双精度浮点数

代码如下：

#include <stdio.h>intmain()
{
printf("%d\n", sizeof(char));
printf("%d\n", sizeof(short));
printf("%d\n", sizeof(int));
printf("%d\n", sizeof(long));
printf("%d\n", sizeof(longlong));
printf("%d\n", sizeof(float));
printf("%d\n", sizeof(double));
printf("%d\n", sizeof(longdouble));
return0;
}

运行结果（32位平台）

文章就到这里