初始C语言（6）——详细讲解表达式求值以及其易错点

我就是我 2023-10-14 18:38 26阅读 0赞

## 系列文章目录 ##

第一章 [“C“浒传——初识C语言（1）（更适合初学者体质哦！）][C_C_1]

第二章 [初始C语言（2）——详细认识分支语句和循环语句以及他们的易错点][C_2]

第三章 [初阶C语言（3）——特别详细地介绍函数][C_3]

第四章 [初始C语言（4）——详细地讲解数组的内容以及易错点][C_4]

第五章 [初始C语言（5）——详细讲解操作符以及操作符的易错点][C_5]

第六章 初始C语言（6）——详细讲解表达式求值以及其易错点

--------------------

**目录**

系列文章目录

前言

一、隐式类型转换

1.1 整形提升：

1.1.1 整形提升的意义：

1.1.2 如何进行整形提升呢？

1.1.3 整形提升的一些例子及题目：

1.2 算术转换

二、显式类型转换

三、操作符的属性

3.1 操作符的优先级

3.2 一些问题表达式

总结

--------------------

## **前言** ##

> 在上一章内，小编带领大家详细学习了**有关操作符的相关内容**，学习了**操作符有多少个，各种操作符是什么，各个操作符都有几个操作数，操作符的用法以及操作符的具体应用。**
> 
> 而在这一章内，**小编将要带领大家进行学习表达式求值的内容**，大家从目录也不难看出这章内容不是很多，已经囊括了所有可能见到的表达式，希望大家也能有耐心地将这一章看完。另外，在提一嘴：**我会不定时地将之前所写的内容进行更新，希望大家可以进行观看和点赞！**

--------------------

## 一、隐式类型转换 ##

**表达式求值的顺序一部分是由操作符的优先级和结合性决定的**，在学习表达式求值之前，我们需要进行一些铺垫，**有些表达式的操作数在求值的过程中可能需要转换为其他类型。首先，我们先来看一看隐式类型转换（就是系统默认的、不需要加以声明就可以进行转换），隐式类型转换分为两种：1.整形提升、2.算术转换。**

### 1.1 整形提升： ###

先随小编来看一下**整形提升的概念：C语言的整形算术运算总是至少以缺省整形类型***（这个大家可能不懂，具体解释请看下面）***的精度来进行的，为了获得这个精度，表达式中的字符和短整形操作数在使用之前被转换为普通整形，这种转换称为整形提升。**

> **缺省整形类型：就是int类型。**
> 
> **何为缺省呢？**
> 
>  **就是不特别说明时，拥有隐含的条件背景。这个隐含的条件是被众人熟知的，所以可以省去这个条件来简化表达。缺省，就是省掉，不显式的指明。**  
> 例如，我们都知道（包括[编译器][Link 1]它也知道），在C语言中，int 就等价于signed int。那么在表示一个有符号整数的时候，就可以省掉了int前面的signed，直接写int。所以说：在缺省情况下，int等价于signed int。

#### **1.1.1 整形提升的意义：** ####

*  表达式的整形运算要在CPU的相应运算器内执行，CPU内整形运算器（[ALU的功能与结构][ALU]）的操作数的字节长度一般就是**int的字节长度**，而**通用寄存器的字节大小与ALU操作数的字节大小保持一致。**
 *  > **为什么通用寄存器的字节大小与ALU操作数的字节大小保持一致？**
    > 
    > 此时，我们还要明晰一个事情，那就是**数据在被运算时，数据并不是直接在ALU上存储的，而是存储在CPU的寄存器（register）中。**
 *  因此，**即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整形操作数的标准长度。**
 *  **通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加的指令）。**所以，**表达式中各种长度可能小于int长度的整形值，都必须先转换为int或unsigned int，**然后才能送入CPU去执行运算。
 *  > **为什么难以实现两个8比特位字节进行直接相加运算？**
    > 
    > 这又怎样？**空间大又不是不能存储字节数少的数据。**是的，话没错，能存，但问题在于我是4个字节的空间（大房间里有四个小房子），你是少于4个字节的数据（不能完全占据整个大房间），**我到底该把你安排在哪个小房间里？我把你随便放进去的话，我要用你时又要在4个小房间里查找你到底在哪些房间里，这样势必会让我的效率变低。**所以，你在住进来时，不好意思，**你至少得把自己变成4个字节的，我再把你直接放进去，用你时我也不用查你在哪，我找到大房间就找到了你。**
    > 
    > **![a0ae792f7b9245a98b5f2817a6ec541d.png][]**
    > 
    > 可能这会有人会问，那我多于4个字节怎么办？不要担心，你多于4个字节，大不了我给你再安排一间大房子，你一个人住两间总该够了。在64位平台，C语言非自定义数据类型的字节数只有4种（1,2,4,8）。两间大房子妥妥把你舒舒服服住好喽！

**讲了那么多，我们先来举个例子让大家看看什么情况编译器会进行隐形提升：**

>     //实例1
>     char a, b, c;
>     //......
>     a = b + c;
> 
> a，b，c都是char类型的，在进行计算时，b和c的值被提升为普通类型，然后再执行加法运算，加法运算完成后，结果会被截断，然后再存储在a中。

#### 1.1.2 如何进行整形提升呢？ ####

> **运算规则：整形提升是按照变量的数据类型的符号位来提升的。**
> 
>  **a. 如果是无符号数，则高位直接补0；**  
>  **b. 如果是有符号数，则高位全补符号位。**

> 我们先来说说**字符char类型的符号位： char到底是signed还是unsigned是不能确定的，**C语言中没有明确规定，是**取决于编译器**的，**在我使用的VS中，char类型==signed char类型。**（和右移操作的分类有点像，都是编译器决定的）

下面，我来举几个例子，要知道计算机在存储变量时，存储的是二进制位，在说直白点就是补码。

> **整数的整形提升：** 
> 
>     char a1 = 6;
> 
> 变量a1的二进制位（补码）中只有8个比特位：0000 0110，因为char类型只有一个字节，且**char类型为有符号的char**，所以整形提升的时候，高位补充符号位，**即为0**，提升之后的结果是：00000000 00000000 00000000 00000110。

> **负数的整形提升：**
> 
>     char a2 = -1;
> 
> 同理，变量a2的二进制位（补码）中也只有8个比特位：1111 1111，因为char类型只有一个字节，且**char类型为有符号的char**，所以整形提升的时候，高位补充符号位，**即为1**，提升之后的结果是：11111111 11111111 11111111 11111111。

> **无符号数的整形提升：**
> 
>     unsigned short a3 = -1;
> 
> 变量a3的二进制位（补码）中有16个比特位：11111111 11111111，因为short类型有两个字节，且**short类型为无符号的short**，所以在整形提升的时候，**高位直接补0**，不用考虑其他的，提升之后的结果是：00000000 00000000 11111111 11111111。

**不要觉得`char`和`short`在存储时，就发生了整型提升！发生这个整型提升的前提是它们参与整型运算！！而且整型运算结束后，4个字节的数据将发生截断，再返回值。也就是说，运算完成后，CPU返回值的字节数仍为这个数据原本类型的字节数，而不是提升后的字节数。截断的规则是留低位弃高位。**

#### 1.1.3 整形提升的一些例子及题目： ####

>  **题目1：**
> 
>     int main()
>     {
>         char a = 0xb6;
>         short b = 0xb600;
>         int c = 0xb6000000;
>         if(a == 0xb6)
>             printf("a");
>         if(b == 0xb600)
>             printf("b");
>         if(c == 0xb6000000)
>             printf("c");
>         return 0;
>     }
> 
> **分析：**if语句中的所有式子是一个表达式，所以变量a，b都经过了运算，需要进行整形提升，而c本来就是int类型，不需要进行整形提升。a的二进制位（补码）为：1011 0110，因为char为有符号的char，所以整形提升的时候，高位补充符号位，**即为1**，提升之后的结果是：11111111 11111111 11111111 10110110，是一个负数，与0x000000b6不相同。同理得b整形提升之后的结果是：11111111 11111111 10110110 00000000，与0x0000b600不相同。
> 
> **答案：**程序输出的结果是：c

> **题目2：**
> 
>     int main()
>     {
>         char c = 1;
>         printf("%u\n", sizeof(c));
>         printf("%u\n", sizeof(+c)); 
>         printf("%u\n", sizeof(-c));  
>         return 0;
>     }
> 
> **分析：**题目2中，变量c只要参与表达式运算，就会发生整形提升，表达式 **+c** 就会发生整形提升，所以 **sizeof(+c)** 是**4个字节**，表达式 **-c** 就会发生整形提升，所以 **sizeof(-c)** 是**4个字节**，但是 **sizeof(c)** 就是**1个字节**。
> 
> **答案：**1 4 4

### 1.2 算术转换 ###

**如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数转换为另一个操作数的类型，否则操作就无法进行。**下面的层次体系称为**寻常算术转换**。

![ec5984de288a4fc29381985634d6a501.png][]

**如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。**但是算术转换需要合理，**不能从高类型向地类型转换，否则会有精度缺失。**

float f = 3.14;
    int num = f; //隐式转换，会有精度缺失

--------------------

## 二、显式类型转换 ##

显式类型转换与隐式类型转换是相反的，**显式类型转换的概念：当系统默认转换不能转换的时候，而我们又需要把某一类型改为另一个类型，这个过程我们称之为显示转换也叫做强制转换。**

--------------------

## 三、操作符的属性 ##

在了解完上面的数据转换后，接下来进行了解**操作符的属性：优先级、结合性、求值顺序。**

> **复杂表达式的求值有三个影响因素：**
> 
> 1.  操作符的优先级
> 2.  操作符的结合性
> 3.  是否控制求值顺序

两个相邻的操作符先执行哪个呢？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

举个例子吧！

> 优先级：相邻操作符，优先级高的先计算
> 
>     int a = 3 + 5 * 4;
> 
> 结合性：相邻操作符优先级相同的情况下，结合性才有作用
> 
>     int a = 3 + 5 + 4;

### 3.1 操作符的优先级 ###

![b2c842de27c642b5b336ab052ad46cbc.png][]注释：用红方块画出的操作符是可以控制求值顺序的，而其他是不可以控制求值顺序的

小编认为只需要记住**单目操作符优先级比双目操作符优先级高，赋值操作符优先级比逗号表达式优先级高即可**，这个上面的表格是不需要全部记住的。

### **3.2 一些问题表达式** ###

>     //表达式的求值部分由操作符的优先级决定。
>     //表达式1
>     a*b + c*d +e*f;
> 
> **分析：**表达式1在计算的时候，由于 \* 比 + 的优先级高，只能保证 \* 计算是比 + 早，但是优先级并不能决定第三个 \* 比第一个 + 早执行。
> 
> 所以表达式1的计算机顺序就可能是：
> 
>     a * b
>     c * d
>     a * b + c * d
>     e * f
>     a * b + c * d + e * f
>     或者
>     a * b
>     c * d
>     e * f
>     
>     a * b + c * d
>     a * b + c * d + e * f

>     //表达式2
>     c + --c;
> 
> **分析：**同上，操作符的优先级只能决定自减 -- 的运算在 + 的运算的前面，但是我们并没有办法得知， + 操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。

>     //表达式3
>     int main()
>     {
>         int i = 10;
>         i = i-- - --i * (i=-3) * i++ + ++i;
>         printf("i = %d\n", i);
>         return 0;
>     }
> 
> 表达式3在不同编译器中测试结果：非法表达式程序的结果
> 
> <table style="width:500px;"> 
>  <tbody> 
>   <tr> 
>    <td>&nbsp; 值</td> 
>    <td>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;编译器</td> 
>   </tr> 
>   <tr> 
>    <td> <p>-128</p> </td> 
>    <td>Tandy 6000 Xenix 3.2</td> 
>   </tr> 
>   <tr> 
>    <td>-95</td> 
>    <td>ThinkC5.02（Macintosh)</td> 
>   </tr> 
>   <tr> 
>    <td>-86</td> 
>    <td>IBM PowerPC AIX 3.2.5</td> 
>   </tr> 
>  </tbody> 
> </table>

>     //表达式4
>     int fun()
>     {
>         static int count = 1;
>         return ++count;
>     }
>     int main()
>     {
>         int answer = 0;
>         answer = fun() - fun() * fun();
>         printf("%d\n", answer);
>         return 0;
>     }
> 
> **分析：**这个代码还是有问题的，虽然在大多数编译器上求得结果是相同的，但是上述代码 answer = fun() - fun() \* fun(); 中，我们只能通过操作符的优先级得知：先算乘法，在算加法。函数的调用先后顺序是无法通过操作符的优先级来决定的。

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

--------------------

## **总结** ##

在这一部分，小编详细地编写了有关表达式求值详解的一篇博客。希望大家看完以后，进行点评，谢谢大家！

[C_C_1]: http://t.csdn.cn/Rt8VK
[C_2]: http://t.csdn.cn/pTO5k
[C_3]: http://t.csdn.cn/R6aDv
[C_4]: http://t.csdn.cn/z7pdJ
[C_5]: http://t.csdn.cn/NcxMW
[Link 1]: https://zhidao.baidu.com/search?word=%E7%BC%96%E8%AF%91%E5%99%A8&fr=iknow_pc_qb_highlight
[ALU]: http://t.csdn.cn/OkEsC
[a0ae792f7b9245a98b5f2817a6ec541d.png]: https://img-blog.csdnimg.cn/a0ae792f7b9245a98b5f2817a6ec541d.png
[ec5984de288a4fc29381985634d6a501.png]: https://img-blog.csdnimg.cn/ec5984de288a4fc29381985634d6a501.png
[b2c842de27c642b5b336ab052ad46cbc.png]: https://img-blog.csdnimg.cn/b2c842de27c642b5b336ab052ad46cbc.png