【C语言】操作符详解

这期博客，给大家讲讲C语言中的操作符家族！ 

1. 操作符的分类

操作符的种类如下：

• 算术操作符： + 、- 、* 、/ 、%

• 移位操作符: << >>

• 位操作符: & | ^ 

• 赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=

• 单⽬操作符： ！、++、--、&、*、+、-、~ 、sizeof、(类型)

• 关系操作符: > 、>= 、< 、<= 、 == 、 !=

• 逻辑操作符： && 、||

• 条件操作符： ? :

• 逗号表达式： , ,

• 下标引⽤： [ ]

• 函数调⽤： ()

• 结构成员访问： . 、->

接下来我们详细学习一下！

2. 算术操作符：+、-、*、/、%

在写代码时候，⼀定会涉及到计算。

C语⾔中为了⽅便运算，提供了⼀系列操作符，其中有⼀组操作符叫：算术操作符。

分别是： + - * / % ，这些操作符都是双⽬操作符。

2.1 + 和 -

+ 和 - ⽤来完成加法和减法。

+ 和 - 都是有2个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双⽬操作符。

#include <stdio.h>

int main()
{
    int x = 4 + 22;
    int y = 61 - 23;

    printf("%d\n", x);//26
    printf("%d\n", y);//38

    return 0;
}

2.2 *

运算符 * ⽤来完成乘法。

#include <stdio.h>

int main()
{
    int num = 5;
    printf("%d\n", num * num); // 输出 25
    return 0;
}

2.3 /

运算符 / ⽤来完成除法。

除号的两端如果是整数，执⾏的是整数除法，得到的结果也是整数

#include <stdio.h>
int main()
{
    float x = 6 / 4;
    int y = 6 / 4;
    printf("%f\n", x); // 输出 1.000000
    printf("%d\n", y); // 输出 1
    return 0;
}

尽管x 的类型是 float （浮点数），但是 6 / 4 得到的结果是 1.0 ，⽽不是1.5 。

原因就在于 C 语⾔⾥⾯的整数除法是整除，只会返回整数部分，丢弃⼩数部分。

而让结果得到的是小数，则需让除号两边至少一个数为小数

#include <stdio.h>

int main()
{
	float x = 6.0 / 4;
	float y = 6 / 4.0;
	float z = 6.0 / 4.0;

	printf("%f\n", x); 
	printf("%f\n", y);
	printf("%f\n", z);

	return 0;
}

运行结果： 

这样计算就都是小数了。

2.4 %

运算符 % 表示求模运算，即返回两个整数相除的余值。

取模的对象不能为0，且不能为浮点型，必须为整数！

#include <stdio.h>
int main()
{
	int x = 6 % 4; //6/4 商1余数2，所以6%4是2
	return 0;
}

负数求模的规则是，结果的正负号由第⼀个运算数的正负号决定。
 

#include <stdio.h>

int main()
{
    printf("%d\n", 11 % -5); // 1
    printf("%d\n",-11 % -5); // -1
    printf("%d\n",-11 % 5); // -1
    return 0;
}

上面示例中，11 或 -11 决定了结果的正负号。

2. 赋值操作符：=和复合赋值

在变量创建的时候给⼀个初始值叫初始化，

在变量创建好后，再给⼀个值，这叫赋值。

int a = 100;//初始化
a = 200;//赋值，这⾥使⽤的就是赋值操作符

赋值操作符 = 是⼀个随时可以给变量赋值的操作符。

 2.1 连续赋值

赋值操作符也可以连续赋值，如

int a = 3;
int b = 5;
int c = 0;
c = b = a+3;//连续赋值，从右向左依次赋值的。

 但是写出的代码不容易理解，建议还是拆开来写

int a = 3;
int b = 5;
int c = 0;
b = a+3;
c = b;

这样写，让我们通俗易懂他的复制整个过程 

2.2 复合赋值符

在写代码时，我们经常可能对⼀个数进⾏⾃增、⾃减的操作，如下代码：

int a = 10;
a = a+3;
a = a-2;

 C语⾔提供了更加⽅便的写法：

int a = 10;
a += 3;
a -= 2;

C语⾔中提供了复合赋值符，⽅便我们编写代码，这些赋值符有：
 

+= -=
*= /= %=
>>= <<=
&= |= ^=

3. 单⽬操作符：++、--、+、-

前⾯介绍的操作符都是双⽬操作符，有2个操作数的。C语⾔中还有⼀些操作符只有⼀个操作数，被称为单⽬操作符。 ++（自增）、-- (自减) 、+(正)、-(负) 就是单⽬操作符的。

3.1 ++和--

++是⼀种⾃增的操作符，⼜分为前置++和后置++，--是⼀种⾃减的操作符，也分为前置--和后置--.

3.1.1 前置++

int a = 10;
int b = ++a;//++的操作数是a，是放在a的前⾯的，就是前置++
printf("a=%d b=%d\n",a , b);

计算⼝诀：先+1，后使⽤；

 a原来是10，先++，后a变成了11，再使⽤就是赋值给b，b得到的也是11，所以a和b都是11

3.1.2 后置++

int a = 10;
int b = a++;//++的操作数是a，是放在a的后⾯的，就是后置++
printf("a=%d b=%d\n",a , b);

 计算⼝诀：先使⽤，后+1

a原来是10，先使⽤，就是先赋值给b，b得到了10，然后再+1，然后a变成了11，

所以a是11，b是10

3.1.3 前置--

与前置++同理，前置--类似，只是把加1，换成了减1； 计算⼝诀：先-1，后使⽤
 

int a = 10;
int b = --a;//--的操作数是a，是放在a的前⾯的，就是前置--
printf("a=%d b=%d\n",a , b);//输出的结果是：9 9

3.1.4 后置--

同理后置--类似于后置++，只是把加⼀换成了减⼀ 计算⼝诀：先使⽤，后-1
 

int a = 10;
int b = a--;//--的操作数是a，是放在a的后⾯的，就是后置--
printf("a=%d b=%d\n",a , b);//输出的结果是：9 10

3.2 + 和 -

这⾥的+是正号，-是负号，都是单⽬操作符。

运算符 + 对正负值没有影响，是⼀个完全可以省略的运算符，但是写了也不会报错。

int a = +10;// 等价于 int a = 10;

运算符 - ⽤来改变⼀个值的正负号，负数的前⾯加上 - 就会得到正数，

正数的前⾯加上 - 会得到负数。

int a = 10;
int b = -a;
int c = -10;
printf("b=%d c=%d\n", b, c);//b=c=-10

int a = -10;
int b = -a;
printf("b=%d\n", b); //b=-(-10)=10 

4. 强制类型转换

在操作符中还有⼀种特殊的操作符是强制类型转换，语法形式很简单，形式如下：

(类型)

如： 

int a = 3.14;
//a是int类型, 3.14是double类型，两边的类型不⼀致，编译器会报警告

为了消除这个警告，我们可以使⽤强制类型转换：

int a = (int)3.14;//意思是将3.14强制类型转换为int类型，只取整数部分

我们已经讲过算术操作符、赋值操作符、逻辑操作符、条件操作符和部分的单⽬操作符，

剩下这些操作符中有⼀些操作符和⼆进制有关系，我们先铺垫⼀下⼆进制的和进制转换的知识。

5. ⼆进制和进制转换

其实我们经常能听到2进制、8进制、10进制、16进制这样的讲法，那是什么意思呢？其实2进制、8进制、10进制、16进制是数值的不同表⽰形式⽽已。

我们重点介绍⼀下⼆进制：

⾸先我们还是得从10进制讲起，其实10进制是我们⽣活中经常使⽤的，

我们对10进制数字有以下的认知

• 10进制中满10进1

• 10进制的数字每⼀位都是0~9的数字组成

其实⼆进制也是类似的

• 2进制中满2进1

• 2进制的数字每⼀位都是0，1的数字组成

如：1101 就是⼆进制数字

5.1.1 2进制转10进制

其实10进制的123表⽰的值是⼀百⼆⼗三，为什么是这个值呢？

其实10进制的每⼀位是权重的，10进制的数字从右向左是个位、⼗位、百位....，分别每⼀位的权重是10^1, 10^2, 10^3...

2进制和10进制是类似的，只不过2进制的每⼀位的权重，从右向左是: 2^0, 2^1, 2^2......

如果是2进制的1101，该怎么理解呢？

5.1.2 10进制转2进制数字

5.2 2进制转8进制和16进制

5.2.1 2进制转8进制

进制的数字每⼀位是0~7的，0~7的数字，各⾃写成2进制，最多有3个2进制位就⾜够了，⽐如7的⼆进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算⼀个8进制位，剩余不够3个2进制位的直接换算。

如：2进制的01101011，换成8进制：

5.2.2 2进制转16进制

16进制的数字每⼀位是0~9, A~F 的，0~9, A~F的数字，各⾃写成2进制，最多有4个2进制位就⾜够了，⽐如 f 的⼆进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算⼀个16进制位，剩余不够4个⼆进制位的直接换算。

 如：2进制的01101011，换成16进制：0x6B，16进制表⽰的时候一般前⾯加0x修饰

0110 1011
//0110 - 1*2^2+1^2^1=6
//1011 - 1*2^3+1*2^2+1*2^1=8+2+1=11 是十六进制的B

6. 原码、反码、补码

整数的2进制表示⽅法有三种，即原码、反码和补码

有符号整数的三种表示⽅法均有符号位和数值位两部分，2进制序列中，

最⾼位的1位是被当做符号位，剩余的都是数值位。

符号位都是⽤0表示“正”，⽤1表示“负”。

正整数的原、反、补码都相同。

负整数的三种表示⽅法各不相同。

原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。

反码：将原码的符号位不变，其他位按位取反就可以得到反码。

补码：反码+1就得到补码。

其实还有方法，反码得到原码也是可以使⽤：取反，+1的操作。

对于整形来说：数据存放内存中其实存放的是补码。

这是为什么呢？

使⽤补码，可以将符号位和数值域统⼀处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

如：1-1怎么算？

因为CPU只有加法器，1-1可以转换成1+（-1） 

🌟所以科学家就发明出了“补码”这个东西，你说神不神奇？ 

7. 移位操作符: << >>

<< 左移操作符

>> 右移操作符

注：移位操作符的操作数只能是整数。

7.1 左移操作符

移位规则：左边丢弃、右边补0

如：

#include <stdio.h>
int main()
{
	int num = 10;
	int n = num << 1;

	printf("n= %d\n", n);
	printf("num= %d\n", num);

	return 0;
}

左移过程：

10100 转换成十进制：1*2^4 + 1*2^2 = 16 + 4 = 20 

 所以 n = 20, num = 10

运行结果也是如此

 

 其实也能看出，<< 有把一个数乘2的效果。

7.2 右移操作符

移位规则：⾸先右移运算分两种：

1. 逻辑右移：左边⽤0填充，右边丢弃

2. 算术右移：左边⽤原该值的符号位填充，右边丢弃

 如：

#include <stdio.h>

int main()
{
	int num = -1;
	int n = num >> 1;

	printf("n= %d\n", n);
	printf("num= %d\n", num);
	return 0;
}

 右移过程：

如果是采用算术右移，得到的是32个全1，是补码，但打印的是原码，需要转换

11111111111111111111111111111111 补码
11111111111111111111111111111110 反码：补码-1
10000000000000000000000000000001 原码：反码符号位不变，其他位按位取反
所以是 -1

 如果是采用逻辑右移，得到的是01111111111111111111111111111111 

因为最高位是0，是正数，补码=原码，则打印的就是这个数，这将是一个很大的数字

那么得到的是什么呢？

我们运行代码发现， 得到的结果是-1，说明编译器采用的是算术右移

 

再看一个代码：

 

#include <stdio.h>

int main()
{
	int num = 10;
	int n = num >> 1;

	printf("n=%d\n", n);
	printf("num=%d\n", num);

	return 0;
}

 右移过程：

 运行结果：

 其实也能看出，>> 有把一个数除2的效果。 

 

 警告⚠ ：对于移位运算符，不要移动负数位，这个是标准未定义的。

如：

int num = 10;
num>>-1;//error

 8. 位操作符：&、|、^、~

位操作符有：

&	按位与
|	按位或
^	按位异或
~	按位取反

注：他们的操作数必须是整数

   &叫按（2进制）位与，规则：a和b对应计算有0则为0，2个同时为1才为1.

   |叫按（2进制）位或，规则：a和b对应计算只要有1就是1，两个同时为0才为0.

   ^叫按（2进制）位异或，规则：a和b对应计算相同为0才为0，相异为1.

   ~叫按（2进制）位取反，规则：a和b对应计算1取反为0，0取反为1.

8.1 & | ^

看下面这个代码

#include <stdio.h>

int main()
{
    int a = 3;
    int b = -5;
   
     int c = a & b;
    //00000000000000000000000000000011 -  3的补码
    //11111111111111111111111111111011 -  (-5)的补码
    //00000000000000000000000000000011 -  3&(-5)的结果（补码也是原码）  
    //按位与：补码位都为1则为1，其他情况都是0，求出来的数是补码，转回原码就是输出值。
    
    int d = a | b;
    //11111111111111111111111111111011 -  3|(-5)的结果（补码）
    //10000000000000000000000000000101 -  3|(-5)的结果（原码码）
    //按位或：补码位只要其中一个为1则为1，都是0才为0，求出来的数是补码，转回原码就是输出值。
    
    int k = a ^ b;
    //11111111111111111111111111111000  -  3^(-5)的结果（补码）
    //10000000000000000000000000001000  -  3^(-5)的结果（原码） 
    //按位异或：相同则为0，相异为1，求出来的是补码，要把原码换回原码。
    
    printf("%d\n", c);
    printf("%d\n", d);
    printf("%d\n", k);
    return 0;
}

这里有一道思考题：不能创建临时变量（第三个变量），能不能实现两个数的交换呢？

如果我们创建第三个变量，实现两个数的交换其实不难。

就像在桌子上，有一瓶酱油，有一瓶醋，现在让你把装酱油的瓶子换成醋，装醋的瓶子换成酱油，你会怎么做？

我们就可以拿一个空瓶，把酱油先倒在空瓶里，接着把醋倒原来的酱油瓶，再把空瓶里的酱油倒在原来的醋瓶中，这样把装酱油的瓶子换成醋，装醋的瓶子换成酱油了！

 

 

 

 

 

类比上面的思路，我们有两个变量a和b，我们就可以创建一个临时变量tmp，

把a的值先存到tmp变量中，接着把b的值存到a中，再把tmp存的值放到b变量中，

这样a和b的值就发生交换了！

我们就可以实现代码了！

#include <stdio.h>

int main()
{
	int a = 10;
	int b = 20;
	
	printf("交换前：a=%d, b=%d\n", a, b);
	
	//交换
    int tmp = 0;
	tmp = a;
	a = b;
	b = tmp;
	
	printf("交换后：a=%d, b=%d\n", a, b);
	
	return 0;
}

运行结果： 这样a,b的值就交换了！

 那么刚才的思考题怎么解决呢？

这里提供几种可行方法，同学们可以下去自己实践一下，培养自己的编程思维！

方法一：加减法

int main()
{
	int a = 3;
	int b = 5;
	int c = 0;

	c = a + b;//c=8
	a = c - a;//a=8-3=5
	b = c - b;//b=8-5=3

	printf("变量a=%d\n", a);
	printf("变量b=%d\n", b);

	return 0;
}

这种方法，确实能实现两个数的交换，但是缺点在于，如果a,b的数值太大，超出整形的范围，有时会溢出。只适用于部分数值。

方法2：使用异或操作符（^）实现两个数的交换

根据异或操作符的运算规则：相同为0，相异为1

我们可以写出下面这个代码：

int main()
{
	int a = 3;
	int b = 5;
	a = a ^ b;
	b = a ^ b;
	a = b ^ a;

	printf("变量a=%d\n", a);
	printf("变量b=%d\n", b);

	return 0;
}

这个代码是什么意思呢？ 它的运算过程是这样的：

int a = 3;
int b = 5;
//3的二进制是011,5的二进制是101

a = a ^ b;
//011
//101
//异或
//110 
b = a ^ b;
//110
//101
//异或
//011 - 3
//b = 3
a = b ^ a;
//011
//110
//异或
//101 - 5
//a = 5

这样就实现交换了！是一种效率很高的算法，不会存在数值溢出的情况，

但是缺点在于，对于初学者来说，理解该代码有点难度，要熟练掌握这种操作符的用法！

对于异或操作符（^）来说，它也有很多奇妙的性质，同学们可以使用这种操作符的用法证明以下结论哦~

①一个数与0异或，就是这个数

a ^ 0 = a;

b ^ 0 = b;

②两个相同的数字异或为0

a ^ a = 0;

那么可以得到：

①a ^ a ^ b = b;

②b ^ b ^ a = a;

8.2 ~

按位取反是补码二进制位如果是1则变为0，如果是0则变为1。

#include <stdio.h>

int main()
{
	int a = 3;
	// 补：00000000000000000000000000000011
	// 反：11111111111111111111111111111100  补码变负
	// -1：11111111111111111111111111111011
	// 原：10000000000000000000000000000100  -4
	printf("%d", ~a);

	return 0;
}

9. 单目操作符

单⽬操作符有这些：！、++、--、&、*、+、-、~ 、sizeof、(类型)

这里把前面博客忘记讲的sizeof给大家详细讲讲，

还有&和*没有介绍，这2个操作符，我们讲到 指针 的时候再来探究。

9.1 sizeof操作符

sizeof 是⼀个关键字，也是操作符，专⻔是⽤来计算sizeof操作符数的类型⻓度的，单位是字节。

sizeof 操作符的操作数可以是类型，也可是变量或者表达式。

sizeof (类型)
sizeof 表达式

sizeof 的操作数如果不是类型，是表达式的时候，可以省略掉后边的括号的。

sizeof 后边的表达式是不真实参与运算的，根据表达式的类型来得出⼤⼩。

sizeof 的计算结果是 size_t 类型的。

比如：

#include <stdio.h>

int main()
{
    int a = 10;
    printf("%zd\n", sizeof(a));//括号里可以放变量名 
    printf("%zd\n", sizeof(int));//括号里可以放类型
    printf("%zd\n", sizeof a);//a是变量的名字，可以省略掉sizeof后边的()
    printf("%zd\n", sizeof int);//类型的括号不可以省略，容易报错

    return 0;
}

 9.2 数据类型⻓度

#include <stdio.h>

int main()
{
	printf("%zd\n", sizeof(char));
	printf("%zd\n", sizeof(_Bool));
	printf("%zd\n", sizeof(short));
	printf("%zd\n", sizeof(int));
	printf("%zd\n", sizeof(long));
	printf("%zd\n", sizeof(long long));
	printf("%zd\n", sizeof(float));
	printf("%zd\n", sizeof(double));
	printf("%zd\n", sizeof(long double));
	return 0;
}

在VS2019 X86配置下的输出：
 

9.3 sizeof中表达式不计算
 

int main()
{
	short s = 2;
	int b = 10;
	printf("%d\n", sizeof(s = b + 1));
	printf("s = %d\n", s);
	return 0;
}

测试发现：

首先，sizeof 操作符返回的是其操作数的类型所占用的字节数。在这里，s = b + 1 这个表达式并不会真正改变 s 的值，因为 sizeof 并不计算表达式的值，只是获取表达式的类型大小。

对于 short 类型，其大小通常为 2 个字节。所以 sizeof(s = b + 1) 输出的是 short 类型的字节数，即 2 。

而对于 s 的值，由于 s = b + 1 这个赋值操作在 sizeof 中没有实际执行，所以 s 的值仍然是初始值 2 ，因此 printf("s = %d\n", s); 输出的是 2 。

10. 逗号表达式

 exp1, exp2, exp3, …expN

逗号表达式，就是⽤逗号隔开的多个表达式。

逗号表达式，从左向右依次执⾏。整个表达式的结果是最后⼀个表达式的结果。

11. 下标访问[]、函数调⽤()

11.1 [ ] 下标引⽤操作符

操作数：⼀个数组名 + ⼀个索引值

如：

int arr[10];//创建数组

arr[9] = 10;//实⽤下标引⽤操作符。[ ]的两个操作数是arr和9。

11.2 函数调⽤操作符

接受⼀个或者多个操作数：第⼀个操作数是函数名，剩余的操作数就是传递给函数的参数。

如：

#include <stdio.h>

void test1()
{
	printf("hehe\n");
}

void test2(const char* str)
{
	printf("%s\n", str);
}

int main()
{
	test1(); //这⾥的()就是作为函数调⽤操作符。
	test2("hello bit.");//这⾥的()就是函数调⽤操作符。
	return 0;
}

12. 结构成员访问操作符

要学会使用这种操作符，有必要给大家铺垫结构体的概念 

12.1 结构体

我们知道，C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的！假设我想描述学⽣，或者描述⼀本书，不能说学生 = 5，书 = 3.14之类的。所以单一的数值是无法描述这样复杂对象的，

描述⼀个学⽣需要名字、年龄、学号、⾝⾼等属性；描述⼀本书需要作者、出版社、定价等属性。

C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

12.1.1 结构的声明

struct tag
{
    member-list;
}variable-list;

//struct 结构体关键字
//tag 结构体名字
//member-list 所列的成员变量
//variable-list 该定义结构体的类型创建的变量

比如说，我们描述⼀个学⽣，我们就可以这样定义一个结构体

struct Stu
{
	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}; //分号不能丢

12.1.2 结构体变量的定义和初始化

struct Stu //类型声明
{
    char name[15];//名字
    int age; //年龄
};

struct Stu s1 = {"zhangsan", 20};//初始化
struct Stu s2 = {.age=20, .name="lisi"};//指定顺序初始化

12.2 结构成员访问操作符

12.2.1 结构体成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。

如下所示：

#include <stdio.h>

struct Point
{
    int x;
    int y;
}p = {1,2};

int main()
{
    printf("x: %d y: %d\n", p.x, p.y);
    return 0;
}

使用方式：结构体变量 . 成员名

12.2.2 结构体成员的间接访问

有时候我们得到的不是⼀个结构体变量，⽽是得到了⼀个指向结构体的指针。如下所⽰：

#include <stdio.h>
struct Point
{
    int x;
    int y;
};

int main()
{
    struct Point p = {3, 4};
    struct Point *ptr = &p;

    ptr->x = 10;
    ptr->y = 20;

    printf("x = %d y = %d\n", ptr->x, ptr->y);
    
return 0;
}

使⽤⽅式：结构体指针 -> 成员名 

这里只是初步认识结构体以及结构体的访问，后期会深入讲解更多结构体的知识。

13. 操作符的属性：优先级、结合性

C语⾔的操作符有2个重要的属性：优先级、结合性，

这两个属性决定了表达式求值的计算顺序。

13.1 优先级

优先级指的是，如果⼀个表达式包含多个运算符，

哪个运算符应该优先执⾏。各种运算符的优先级是不⼀样的。

如：3 + 4 * 5;

上面示例中，表达式 3 + 4 * 5 ⾥⾯既有加法运算符（ + ），⼜有乘法运算符（ * ）。由于乘法的优先级⾼于加法，所以会先计算 4 * 5 ，⽽不是先计算 3 + 4 。

13.2 结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，

则根据运算符是左结合，还是右结合，决定执⾏顺序。

⼤部分运算符是左结合（从左到右执⾏），少数运算符是右结合（从右到左执⾏）， 

⽐如赋值运算符（ = ）。

如：

5 * 6 / 2;

因为 * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执⾏，

先计算 5 * 6 ，再计算 6 / 2 。

运算符的优先级顺序很多，有同学会问，这些操作符优先级需不需要背下来？

建议⼤概记住这些操作符的优先级就⾏，其他操作符在使⽤的时候查看下⾯表格就可以了。

表格参考链接：C 运算符优先级 - cppreference.com

14. 表达式求值

其实计算机运算本质就是计算表达式的值，但是有些运算我们能看得到，有些我们看不到，它是偷偷地执行运算。譬如隐式类型转换，他就是偷偷进行类型的转换（并不会直观的展现出来）

那这种隐式类型转换是什么呢？隐式类型转换包含哪些呢？我们来看看，

以下内容，理解有难度，但是是对表达式求值这一块更深入的认识！

14.1 整型提升

C语⾔中整型算术运算总是⾄少以缺省整型类型的精度来进⾏的。

为了获得这个精度，表达式中的字符和短整型操作数在使⽤之前被转换为普通整型，这种转换称为整型提升。

整型提升的意义：

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

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

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

如何进行整型提升呢？

我们通过下面的例子来说明

#include <stdio.h>
int main()
{
	char a = 3;
	char b = 127;
	char c = a + b;
	printf("%d\n", c);
	return 0;
}

分析：

这里的char c = a + b这句执行的时候会发生整型提升

首先a和b要进行加法运算，a和b都要提升为整型

a和b原本为char类型，8bit

00000011-----a

01111111-----b

进行整型提升，因为 char 为有符号的 char，所以整形提升的时候，高位补充符号位，即为0

00000000000000000000000000000011-----a提升后

00000000000000000000000001111111-----b提升后

00000000000000000000000010000010-----相加结果

要赋给c，但c是char类型，只能存8位，存进去的应该是

10000010-----c里面

在进行打印的时候%d以整型进行打印，这里还要发生整型提升char 为有符号的 char，所以整形提升的时候，高位补充符号位

11111111111111111111111110000010-----c提升之后的补码

11111111111111111111111110000001-----c提升之后的反码

10000000000000000000000001111110-----c提升之后的原码

为-126

14.2 算术转换

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

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

long double
↑
double
↑
float
↑
unsigned long int
↑
long int
↑
unsigned int
↑
int

14.3 错误示范

我们在写表达式求值的代码时，不要写出让人有歧义的代码，那样会产生意想不到的结果。

这里给出几个错误案例：

14.3.1 表达式1：

a*b + c*d + e*f

这是一个有问题的代码

分析：

我们都知道 * 优先级比 + 高，但是存在的问题是：

1. 这三个乘号谁先算
2. 第三个*和第一个＋谁先算

出现多种计算方式

1 a*b c*d

2 a*b + c*d
3 e*f

4 a*b + c*d + e*f

或者

1 a*b c*d

2 e*f

3 a*b + c*d

4 a*b + c*d + e*f

 如果我们想象成数学的计算，a b c d e f都是自然数，计算结果可能是相同的

但如果  a b c d e f 各自都是表达式的话，那他的执行结果就不一样了，

所以他是一个有问题的代码

14.3.2 表达式2
 

c + --c;

分析：

这个表达式先算＋还是先算--可以由优先级来确定

存在的问题是谁先准备好

到底是先准备好c还是先准备好--c,这是很重要的

有以下两种：

1.

int c = 2;
c + --c;
//先算--c
//--c执行后c是1
//表达式就是1 + 1

2.

int c = 2;
c + --c;
//先准备好c
//整个表达式就成了2 + 1

这两种计算出来的结果是不一样的

14.3.3 表达式3

#include <stdio.h>
int main()
{
    int i = 10;
    i = i-- - --i * (i = -3) * i++ + ++i;
    printf("i = %d\n", i);
    return 0;
}

表达式3在不同编译器中测试结果：

这样的代码，纯粹是让编译器都凌乱了。😂

14.3.4 表达式4

#include <stdio.h>
int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	answer = fun() - fun() * fun();
	printf("%d\n", answer);//输出多少？
	return 0;
}

这段代码的执行结果是什么呢？

分析：

这段代码中的answer = fun() - fun() * fun();这个表达式是个问题表达式，我们只能知道先算*再算-，但到底先调用哪个fun()是不确定的，所以结果不是唯一的

注意：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，

那这个表达式就是存在问题的。

14.3 总结

即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的计算路径，那这个表达式就是存在潜在⻛险的，建议不要写出特别负责的表达式。

至此，C语言操作符我们就都有清晰的认识啦！本篇整理内容较多，希望对大家熟练掌握，练习！

对大家C语言学习有很大帮助！

---

完