一、前言
运算符优先级一直是让人头疼的东西,趁着 字节取消大小周 的势头来临,通宵整理了一个思维导图出来,希望对你有所帮助。这篇文章,我会仔细分析这张思维导图。
所有的 C语言运算符的用法都在这里了,并且还有优先级的例子解析,总共 100 道题都在这篇文章里了,激(累)动(死)人(我)心(了)
二、运算符简介
- 运算符用于执行程序代码运算,会针对一个或几个操作数来进行运算。例如:1 / 2,其操作数是 1 和 2,而运算符则是 “/”(除号)。
- C语言把除了 控制语句 和 输入输出 以外的几乎所有的基本操作都作为运算符处理,可见其重要性。这么说来,学会了运算符的计算,就等于学会了C语言的 1 / 3,当然这是不可能的!
三、运算符概览
1、按功能分类
- 按照功能分类,可以分为:后缀运算符、单目运算符、算术运算符、关系运算符、位运算符、逻辑运算符、条件运算符、赋值运算符、逗号运算符。
- 本文会对这几大类的运算符的优先级进行一个全面的讲解,然后再引入 100 道例题 ,花 1个小时的时间,彻底掌握运算符的优先级问题吧。
- 想要原题文件的同学,可以 想尽一切办法,找到作者的微信,威逼利诱让他交出来!
2、按操作数个数分类
1)单目运算符
- 单目运算符(也可以叫一元运算符),是指运算表达式中只有一个操作数的运算符。
- 1)位运算符中的按位取反
~
,用法诸如:~a
、~(a + b)
。 - 有关于 按位取反 的具体功能,可以参考如下文章:光天化日学C语言(17)- 位运算 ~ 的应用。
- 2)逻辑运算符中的非
!
,用法诸如:!a
、!(a + b)
。 - 有关 非运算 的具体功能,可以参考如下文章:光天化日学C语言(11)- 逻辑运算符。
- 3)甚至 类型转换
(type)
也是一种单目运算符,用法诸如:(int)a
,(int)(a + b)
。 - 有关类型转换的具体功能,可以参考如下文章:光天化日学C语言(12)- 类型转换。
- 当然,还有很多,这里就不一一列举了,再讲 运算符优先级和结合性 时,我们会一个一个进行举例。
2)双目运算符
- 双目运算符(也可以叫二元运算符),是指运算表达式中有两个操作数的运算符。
- 1)算术运算符中的加 / 减 / 乘 / 除 / 取模(
+-*/%
),都是双目运算符,用法诸如:a + b
、a * b
、a - b
、a % b
。 - 有关 算术运算符 的具体功能,可以参考如下文章:光天化日学C语言(09)- 算术运算符。
- 2)关系运算符中的
==
、<=
、>
也都是双目运算符,用法诸如:a > b
、a <= b
、a != b
、a == b
。 - 有关 关系运算符 的具体功能,可以参考如下文章:光天化日学C语言(10)- 关系运算符 。
- 3)当然逻辑运算符也有双目的。
3)三目运算符
- 三目运算符(也可以叫三元运算符),是指运算表达式中有三个操作数的运算符。
- 在C语言中只有一个三目运算符,它叫条件表达式,表示为
?:
,考虑这样一句话:
if(a + b > 5) {
a++;
}else {
b++;
}
- 可以表示成如下一句话:
a + b > 5 ? a++ : b++;
- 这是C语言比较独特的语法糖,能够大大节省代码量。
四、运算符优先级和结合性
- 优先级可以认为是大分类,优先级不同的运算符,按照优先级高的优先计算。结合性可以认为是小分类,优先级相同的运算符,按照结合性进行计算,结合性只有两种:从左到右 和 从右到左。接下来,我们就围绕优先级和结合性来讨论下上述按照功能分类的运算符吧。
1、后缀运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
[] | 数组下标 | 数组名[常量表达式] | a[2] | a[2][3] |
() | 圆括号 | (表达式) 或 函数名(形参表) | (a+1) | fun(x,y,z) |
. | 对象的成员选择 | 对象.成员名 | a.b | a.b.c |
-> | 指针的成员选择 | 指针.成员名 | a->b | a->b->c |
2、单目运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
+ | 正号 | +表达式 | +5 | +a[3] |
- | 负号 | -表达式 | -5 | -a[3] |
(type) | 强制类型转换 | (数据类型)表达式 | (int)a | (int)a[0] |
++ | 自增运算符 | ++变量名 / 变量名++ | ++i | i++ |
-- | 自增运算符 | –变量名 / 变量名– | --i | i-- |
! | 逻辑非 | !表达式 | !a[0] | !a[0]++ |
~ | 按位取反 | ~表达式 | ~a | ~~a |
& | 取地址 | &变量名 | &a | &(a+1) |
* | 解引用 | *指针变量名 | *a | *(a+1) |
sizeof | 取长度 | sizeof(表达式) | sizeof(a) | sizeof(a + b) |
3、算术运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
* | 乘 | 表达式 * 表达式 | 3 * 5 | 3 * a |
/ | 除 | 表达式 / 表达式 | 3 / 5 | 3 / 5.0 |
% | 模 | 整型表达式 % 整型非零表达式 | 3 % 5 | b % -1 |
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
+ | 加 | 表达式 + 表达式 | a + b | (a++) + b |
- | 减 | 表达式 - 表达式 | a - b | a - b-- |
4、移位运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
<< | 左移 | 变量<<表达式 | 1<<5 | 1<<(i+j) |
>> | 右移 | 变量>>表达式 | x>>1 | x>>a |
5、关系运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
< | 小于 | 表达式<表达式 | 1 < 2 | x < y |
<= | 小于等于 | 表达式<=表达式 | 1 <= 2 | x <= y |
> | 大于 | 表达式>表达式 | 1 > 2 | x > y |
>= | 大于等于 | 表达式>=表达式 | 1 >= 2 | x >= y |
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
== | 等于 | 表达式==表达式 | 1 == 2 | x == y |
!= | 不等于 | 表达式!=表达式 | 1 != 2 | x != y |
6、双目位运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
& | 等于 | 表达式&表达式 | 1 & 2 | x & y |
^ | 等于 | 表达式^表达式 | 1 ^ 2 | x ^ y |
| | 等于 | 表达式\表达式 | 1 | 2 | x | y |
7、双目逻辑运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
&& | 逻辑与 | 表达式&&表达式 | a && b | a + 5 && b + 5 |
|| | 逻辑与 | 表达式|| 表达式 | a || b | a + 5 || b + 5 |
8、条件运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
?: | 条件运算符 | 表达式1? 表达式2: 表达式3 | a>b?a:b | a<b?a:b |
9、赋值运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
= | 赋值 | 变量=表达式 | a = b | a = 1 |
+= | 加后赋值 | 变量+=表达式 | a += b | a += 1 |
-= | 减后赋值 | 变量-=表达式 | a -= b | a -= 1 |
*= | 乘后赋值 | 变量*=表达式 | a *= b | a *= 1 |
/= | 除后赋值 | 变量/=表达式 | a /= b | a /= 1 |
%= | 模后赋值 | 变量%=表达式 | a %= b | a %= 1 |
>>= | 右移后赋值 | 变量>>=表达式 | a >>= b | a >>= 1 |
<<= | 左移后赋值 | 变量<<=表达式 | a <<= b | a <<= 1 |
&= | 位与后赋值 | 变量&=表达式 | a &= b | a &= 1 |
^= | 异或后赋值 | 变量^=表达式 | a ^= b | a ^= 1 |
|= | 位或后赋值 | 变量|= 表达式 | a |= b | a |= 1 |
10、逗号运算符
运算符 | 名称 | 形式 | 举例1 | 举例2 |
---|---|---|---|---|
, | 逗号运算符 | 表达式1,表达式2,… | a+b,a-b | a||b,a&b |
- 了解逗号表达式的优先级最低以后,我们就可以通过
,
将语句分隔,而无需添加多余的括号了。
五、运算符优先级和结合性总结
1、结合性
结合方向只有 3 个是 从右往左,其余都是 从左往右(比较符合人的直观感受)。
(1)一个是单目运算符;
(2)一个是双目运算符中的 赋值运算符;
(3)一个条件运算符,也就是C语言中唯一的三目运算符。
2、优先级
后缀运算符和单目运算符优先级一般最高,逗号运算符的优先级最低。快速记忆如下:
单目逻辑运算符 > 算术运算符 > 关系运算符 > 双目逻辑运算符 > 赋值运算符
六、运算符优先级面试错题100例
#include <stdio.h>
int a[2][2] = { {0, 1}, {2, 3}};
int main() {
printf("%d\n", a[1][0]);
return 0;
}
【运行结果】2
【结果答疑】这个例子体现的是下标运算符[]
的结合性是从左到右的。
#include <stdio.h>
int a[5] = {1, 2, 3, 4, 5};
int main() {
printf("%d\n", a[a[a[a[0]]]]);
return 0;
}
【运行结果】4
【结果答疑】这个例子体现的是下标运算符[]
的嵌套应用,从内层开始计算,a[0] == 1
,从而计算a[1]
,而a[1] == 2
,以此类推,得出最后的值为a[3]
,即 4。
#include <stdio.h>
int main() {
return 0;
}
【运行结果】
【结果答疑】这个例子就是给大家看一下圆括号的,大家看到了吗?没错!main()
是个函数,后面的括号里面跟的是参数列表,然而参数列表为空,就变成这个样子了。
#include <stdio.h>
int a[5] = {5, 4, 3, 2, 1};
int main() {
printf("%d\n", (a)[2] );
return 0;
}
【运行结果】3
【结果答疑】这个例子展示了()
和[]
的组合应用,这里的()
可有可无。
#include <stdio.h>
struct A {
int a;
}a;
int main() {
a.a = 5;
printf("%d\n", a.a );
return 0;
}
【运行结果】5
【结果答疑】这个例子体现了结构体的应用,并且我们可以通过.
获取到结构体的成员变量。
#include <stdio.h>
struct B {
int c;
};
struct A {
struct B b;
}a;
int main() {
a.b.c = 5;
printf("%d\n", a.b.c );
return 0;
}
【运行结果】5
【结果答疑】这个例子体现了结构体的嵌套,我们可以通过.
获取到结构体的成员变量,成员变量是一个结构体,所以可以继续通过.
获取它的成员变量,也间接了解了.
运算符的结合性是从左往右的。
#include <stdio.h>
struct A {
int b;
}a[10];
int main() {
a[0].b = 5;
printf("%d\n", a[0].b);
return 0;
}
【运行结果】5
【结果答疑】这个例子体现了结构体数组的应用,即当数组元素是一个结构体时,我们如何去访问它的成员变量。体现了[]
和.
的混合应用:优先级相同,结合性从左到右。
#include <stdio.h>
struct A {
int b;
}a;
struct A *pa;
int main() {
a.b = 9;
pa = &a;
printf("%d\n", pa->b);
return 0;
}
【运行结果】9
【结果答疑】这个例子体现了指针的的应用,->
左边的操作数是指针本针,右边的就指针指向对象的成员变量。有关于指针的内容,在后面的例题中会反复提到,现在只需要知道pa->b
是取成员变量就行了。
#include <stdio.h>
int a = 3, b = 4;
int main() {
printf("%d\n", a++b);
return 0;
}
【运行结果】编译报错!
【结果答疑】编译报错的原因就是编译器不知道如何解析a++b
这个语句,但是我们只需要在两个加号之间加个空格,结果就截然不同了,看【例题10】。
#include <stdio.h>
int a = 3, b = 4;
int main() {
printf("%d\n", a+ +b);
return 0;
}
【运行结果】7
【结果答疑】原因就是因为加了空格以后,他就把+
理解成b
的前缀了,也就是+b
和b
等价,这样一来。
#include <stdio.h>
int a[3] = {0, 1, 2};
int main() {
printf("%d\n", -a[2]);
return 0;
}
【运行结果】-2
【结果答疑】这个例子体现了[]
的优先级高于-
,即-a[2]
等价于-(a[2])
。
#include <stdio.h>
struct A {
int a;
}a;
int main() {
a.a = 5;
printf("%d\n", - a.a );
return 0;
}
【运行结果】-5
【结果答疑】这个例子体现了.
的优先级高于-
。
#include <stdio.h>
double a[3] = {1.1, 2.2, 3.3};
int main() {
printf("%d\n", (int)a[2] );
return 0;
}
【运行结果】3
【结果答疑】这个例子体现了[]
的优先级高于(type)
。
#include <stdio.h>
struct A {
double a;
}a;
int main() {
a.a = 5.6;
printf("%d\n", (int)a.a );
return 0;
}
【运行结果】5
【结果答疑】这个例子体现了.
的优先级高于(type)
。
#include <stdio.h>
struct A {
double a;
}a;
int main() {
a.a = 5.6;
printf("%d\n", (int)a.a );
return 0;
}
【运行结果】5
【结果答疑】这个例子体现了.
的优先级高于(type)
。
#include <stdio.h>
int a[5] = {1, 2, 3, 4, 5};
int main() {
printf("%d\n", ++a[2] );
return 0;
}
【运行结果】4
【结果答疑】这个例子体现了[]
的优先级高于++
,且++
作为前缀运算符时,返回的是自增后的结果。
#include <stdio.h>
int a[5] = {1, 2, 3, 4, 5};
int main() {
printf("%d\n", ++a[2]++ );
return 0;
}
【运行结果】编译错误!
【结果答疑】这个例子说明 ++ 这个运算符只能作用在变量上,不能作用在表达式上。
#include <stdio.h>
int a[4] = {1, 2, 3, 4};
int main() {
printf("%d\n", a[2]++ );
return 0;
}
【运行结果】3
【结果答疑】这个例子体现了[]
的优先级高于++
,且++
作为后缀运算符时,返回的是自增前的结果。
#include <stdio.h>
int a = 0;
int main() {
printf("%d\n", !++a );
return 0;
}
【运行结果】0
【结果答疑】这个例子是要告诉读者,++
和!
都是右结合的,即++
运算会在!
运算之前,所以相当于!1
,所以值为0
。
#include <stdio.h>
int a = 0;
int main() {
printf("%d\n", ~~~~~~a );
return 0;
}
【运行结果】0
【结果答疑】这个例子展示了按位取反的右结合性,总共取反六次,相当于没有取反。表达式的效果是等价于~(~(~(~(~(~a)))))
的。
#include <stdio.h>
int a = 0;
int main() {
printf("%d\n", &a );
return 0;
}
【运行结果】未知整数
【结果答疑】这个例子告诉我们&a
得到的是a
这个变量的地址,而非其本身的值。
#include <stdio.h>
int a = 6;
int main() {
printf("%d\n", *&a );
return 0;
}
【运行结果】6
【结果答疑】这个例子的含义是为了说明*
和&
是互逆的关系:&
是取变量的地址,*
是根据变量地址取值,而地址又叫指针,所以*
又叫解指针,也可以叫解引用。
#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf("%d %d\n", &a[1], (&a)[1] );
return 0;
}
【运行结果】两个不同的值
【结果答疑】得到的是两个不同的值,为什么呢?继续来看【例题24】。
#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf("%d %d\n", &a[1], &(a[1]) );
return 0;
}
【运行结果】两个相同的值
【结果答疑】得到的是两个相同的值,这里简单解释一下,就是因为[]
的优先级比&
高,&a[1]
相当于取数组的第1个元素后再取地址,相当于基地址a
加四个字节(int
的大小是4个字节);但是(&a)[1]
相当于先取地址变成了指针,指针在目前64位机器上是8个字节的,再进行一次下标运算,相当于基地址a
加8个字节,完美!(不懂的话我将来会在 光天化日写C语言 (50) - 指针初探 里面详细讲解,尽请关注 🌞《光天化日学C语言》🌞)
#include <stdio.h>
struct A {
int *b;
}a;
struct A *pa;
int x = 996;
int main() {
a.b = &x;
printf("%d\n", *a.b);
return 0;
}
【运行结果】996
【结果答疑】这个例子体现了指针的的应用,并且说明了.
的优先级高于*
。其中a.b
是一个指针,指向的是x
,经过*
解引用以后,得到了x
变量的值,即996
,有点伤感……
#include <stdio.h>
struct A {
int *b;
}a;
struct A *pa;
int x = 996;
int main() {
a.b = &x;
printf("%d\n", *(a.b));
return 0;
}
【运行结果】996
【结果答疑】这个例子的运算过程和【例题25】是等价的。
#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf("%d\n", **a );
return 0;
}
【运行结果】编译错误
【结果答疑】这个例子是想要说明*
只能对指针类型解引用,直接来看【例题28】再来进行详细解释。
#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf("%d\n", *a );
return 0;
}
【运行结果】3
【结果答疑】这个例子是想要说明数组的首地址,就是指针指向的位置,所以直接解引用拿到的就是数组的第一个元素。
#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf("%p %p\n", a, &*a );
return 0;
}
【运行结果】两个相同的值
【结果答疑】这个例子是进一步说明数组的首地址,就是指针指向的位置,a
代表数组首地址,对首地址解引用,得到的就是a[0]
,然后再取地址&
,得到的就是数组a
的首地址了(刚接触指针的话,这块可能比较绕,建议自己写一下代码看看效果)。
#include <stdio.h>
int a[2] = {99, 6};
int *pa[1];
int main() {
pa[0] = a;
printf("%d\n", *pa[0] );
return 0;
}
【运行结果】99
【结果答疑】这个例子表明[]
的优先级高于解引用*
。
#include <stdio.h>
int a[2] = {10, 7};
int main() {
printf("%d\n", a[0] * a[1] );
return 0;
}
【运行结果】70
【结果答疑】这个例子表明[]
的优先级高于乘法*
。
#include <stdio.h>
int a[2] = {10, 5};
int main() {
printf("%d\n", a[0] / a[1] );
return 0;
}
【运行结果】2
【结果答疑】这个例子表明[]
的优先级高于除法/
。
#include <stdio.h>
int a[2] = {10, 3};
int main() {
printf("%d\n", a[0] / a[1] );
return 0;
}
【运行结果】3
【结果答疑】整数间的除法是取下整。
#include <stdio.h>
int a[2] = {10, 0};
int main() {
printf("%d\n", a[0] % a[1] );
return 0;
}
【运行结果】异常
【结果答疑】会产生除零错误,因为取模时除数不能为零。
#include <stdio.h>
int main() {
printf("%d\n", 1 + 1 % 2);
return 0;
}
【运行结果】2
【结果答疑】取模运算符%
的优先级高于加法运算符+
。
#include <stdio.h>
int a = 1;
int main() {
printf("%d\n", a++ + ++a);
return 0;
}
【运行结果】4
【结果答疑】千万别写出这种代码,因为不同编译器可能产生不同的编译结果。
#include <stdio.h>
int a = 1;
int main() {
printf("%d\n", a++ + ++a);
return 0;
}
【运行结果】4
【结果答疑】千万别写出这种代码,因为不同编译器可能产生不同的编译结果。
#include <stdio.h>
int a = 7;
int *fun(int *p) {
return p;
}
int main() {
printf("%d\n", *fun(&a));
return 0;
}
【运行结果】7
【结果答疑】这段代码将全局变量的地址作为函数传参传到函数中,然后再返回出来,再解引用得到全局变量的值。这里想说明的是int *fun(...)
是一个指针函数,即返回int *
的函数,所以它等价于int *(fun(...))
,因为()
的优先级高于指针运算符*
。
#include <stdio.h>
int a = 5;
int main() {
printf("%p %p\n", &a, &a + 1);
return 0;
}
【运行结果】两个相差4的地址
【结果答疑】这个例子说明几个问题:首先,指针是可以进行加法运算的,并且不是作为整数来进行加法运算,指针的加1,相当于按照指针指向的类型偏移对应的单位,且取地址&
的优先级高于加号+
。
#include <stdio.h>
int a = 5;
int main() {
printf("%p %p\n", &a, &a - 1);
return 0;
}
【运行结果】两个相差4的地址
【结果答疑】这个例子说明几个问题:首先,指针是可以进行减法运算的,并且不是作为整数来进行减法运算,指针的减1,相当于按照指针指向的类型偏移对应的单位,且取地址&
的优先级高于加号-
。
#include <stdio.h>
int main() {
printf("%d\n", 1 << 3 - 1);
return 0;
}
【运行结果】4
【结果答疑】1 << 3 - 1
等价于1 << (3 - 1)
,因为算术运算符的优先级高于移位运算符。
#include <stdio.h>
int main() {
printf("%d\n", 1 << 3 + 1);
return 0;
}
【运行结果】16
【结果答疑】1 << 3 + 1
等价于1 << (3 + 1)
,因为算术运算符的优先级高于移位运算符。
#include <stdio.h>
int a[5] = {9, 8, 7, 6, 5};
int main() {
int *p = a;
printf("%d\n", *p++);
return 0;
}
【运行结果】9
【结果答疑】这个例子中,*
和++
的优先级是相同的,但是无奈这两个的结合性是从右到左的,所以它等价于*(p++)
,而且p++
表达式的值等于p
。所以最后解引用的还是数组的第一个元素。
#include <stdio.h>
int a[5] = {9, 8, 7, 6, 5};
int main() {
int *p = a;
printf("%d\n", *++p);
return 0;
}
【运行结果】8
【结果答疑】这个例子是用来类比【例题43】的,它输出则是数组的第2个元素的值。
#include <stdio.h>
int a[5] = {9, 8, 7, 6, 5};
int main() {
int *p = a;
printf("%d\n", *p<<1);
return 0;
}
【运行结果】18
【结果答疑】这个例子中,解引用*
的优先级高于左移运算符<<
。
#include <stdio.h>
int a[5] = {9, 8, 7, 6, 5};
int main() {
int *p = a;
printf("%d\n", *p>>1);
return 0;
}
【运行结果】4
【结果答疑】这个例子中,解引用*
的优先级高于右移运算符>>
。
#include <stdio.h>
int main() {
printf("%d\n", 1<<1>>1<<1>>1);
return 0;
}
【运行结果】1
【结果答疑】这个例子中,左移运算符<<
和左移运算符>>
的优先级优先级相同,结合性从左到右。
#include <stdio.h>
int main() {
printf("%d\n", 1<<1.6);
return 0;
}
【运行结果】编译错误
【结果答疑】这个例子是为了说明<<
右边的操作数一定要是整数。
#include <stdio.h>
int main() {
printf("%d\n", 1.6<<1);
return 0;
}
【运行结果】编译错误
【结果答疑】这个例子是为了说明<<
左边的操作数一定要是整数。
#include <stdio.h>
int main() {
printf("%d\n", 1 > 2);
printf("%d\n", 1 < 2);
return 0;
}
【运行结果】0[换行]1
【结果答疑】这个例子告诉我们关系运算符的运算结果,如果为真返回1,否则返回0。
#include <stdio.h>
int main() {
printf("%d\n", 1 < 1 << 2);
return 0;
}
【运行结果】1
【结果答疑】左移运算符<<
的优先级高于关系运算符<
。
#include <stdio.h>
int main() {
printf("%d\n", 1 > 2 > -1);
return 0;
}
【运行结果】1
【结果答疑】由于1 > 2
的结果为0,所以1 > 2 > -1
等价于0 > -1
,显然是成立的,所以输出的结果为:1
。
#include <stdio.h>
int main() {
printf("%d\n", 1 < 2 > 1);
return 0;
}
【运行结果】0
【结果答疑】由于1 < 2
的结果为1,所以1 < 2 > 1
等价于1 > 1
,显然是不成立的,所以输出的结果为:0
。
#include <stdio.h>
int main() {
printf("%d\n", 3 > 2 > 1);
return 0;
}
【运行结果】0
【结果答疑】由于3 > 2
的结果为1,所以3 > 2 > 1
等价于1 > 1
,显然是不成立的,所以输出的结果为:0
。
#include <stdio.h>
int main() {
printf("%d\n", 1 < 2 == 1);
return 0;
}
【运行结果】1
【结果答疑】我们可以做出两种假设:
假设1:==
优先级低于<
;1 < 2
优先计算,则表达式等价于1 == 1
,成立,输出1
。
假设2:==
优先级高于<
;2 == 1
优先计算,则表达式等价于1 < 0
,不成立,输出0
。
实际上,这段代码的结果为:1
,即==
的优先级低于<
。
#include <stdio.h>
int main() {
printf("%d\n", 1 < 2 != 1);
return 0;
}
【运行结果】0
【结果答疑】类似【例题55】。
#include <stdio.h>
int main() {
int a;
printf("%d\n", a = 0);
return 0;
}
【运行结果】0
【结果答疑】这里其实是想进行a == 0
的关系判定,结果=
少写了一个,所以结果变成了赋值号=
右边表达式的值。
#include <stdio.h>
int main() {
printf("%d\n", 5 <= 6);
return 0;
}
【运行结果】1
【结果答疑】当然是成立的啦。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0110;
printf("%d\n", a & b );
return 0;
}
【运行结果】2
【结果答疑】这个例子展示了位与的基本运算。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0110;
printf("%d\n", a & b == 2);
return 0;
}
【运行结果】0
【结果答疑】延续【例题59】继续看,之前a & b
输出的是2
,那为什么加上等于==
判定后,输出结果反而变成0
了呢?原因是因为==
的优先级高于位与&
,所以相当于进行了a & 0
的操作,结果自然就是0了。
#include <stdio.h>
int main() {
int a = 0b1010;
printf("%d\n", a & 1 << 3);
return 0;
}
【运行结果】8
【结果答疑】这个例子体现了左移运算符<<
优先级高于位与&
。a & 1 << 3
相当于a & (1 << 3)
。
#include <stdio.h>
int main() {
int a = 0b1010;
printf("%d\n", a | 1 << 2);
return 0;
}
【运行结果】14
【结果答疑】这个例子体现了左移运算符优先级高于位或。
#include <stdio.h>
int main() {
int a = 0b1010;
printf("%d\n", a ^ 1 << 2 == 4);
return 0;
}
【运行结果】11
【结果答疑】这个例子中运算符优先级:<<
高于==
高于^
。好了,当到达这种复杂情况的时候,你就应该想到要加括号了。
#include <stdio.h>
int main() {
int a = 0b1010;
printf("%d\n", a ^ ( (1 << 2) == 4 ) );
return 0;
}
【运行结果】11
【结果答疑】和【例题63】等价。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1000;
printf("%d\n", a ^ b & c );
return 0;
}
【运行结果】10
【结果答疑】这个例子表明了位与运算符&
高于异或运算符^
。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf("%d\n", a | b & c );
return 0;
}
【运行结果】11
【结果答疑】这个例子表明了位与运算符&
高于位或运算符 | 。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf("%d\n", a | b ^ c );
return 0;
}
【运行结果】14
【结果答疑】这个例子表明了异或运算符^
高于位或运算符 | 。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf("%d\n", a | b ^ c );
return 0;
}
【运行结果】14
【结果答疑】这个例子表明了异或运算符^
高于位或运算符 | 。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf("%d\n", a | b | c );
return 0;
}
【运行结果】15
【结果答疑】位或运算符 | 的结合性是从左到右的,不过如果全是 | ,其实它是满足结合律的,所以顺序不太重要。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf("%d\n", a & b & c );
return 0;
}
【运行结果】0
【结果答疑】位与运算符&
的结合性是从左到右的,不过如果全是&
,其实它是满足结合律的,所以顺序不太重要。
#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf("%d\n", a ^ b ^ c );
return 0;
}
【运行结果】6
【结果答疑】异或运算符^
的结合性是从左到右的,不过如果全是^
,其实它是满足结合律的,所以顺序不太重要。
#include <stdio.h>
int main() {
int x = 64;
printf("%d\n", (x & x - 1) == 0 );
return 0;
}
【运行结果】1
【结果答疑】这个例子是用来判断一个数是不是2的幂的。由于减号-
的优先级高于&
,所以x & x - 1
等价于x & (x - 1)
,但是==
的优先级高于&
,所以(x & x - 1)
中的括号不能省。当然也可以写成!(x & x - 1)
。
#include <stdio.h>
int main() {
int a = 0b10000;
int x = 0b01011;
printf("%d\n", (x | a) - a );
return 0;
}
【运行结果】11
【结果答疑】这个例子是用来消除x
的第5位的,首先利用位或运算符 | 将第5位强制变成1,然后消除掉这个1。由于减法运算符-
优先级高于位或运算符 | ,所以需要加上括号。
#include <stdio.h>
int main() {
int x = 0b010000;
printf("%d\n", x | x - 1 );
return 0;
}
【运行结果】31
【结果答疑】这个例子是是将低位连续的零变成一,但是一般这样的写法会报警告,因为编译程序并不知道你的诉求,到底是想先计算 | 还是先计算-
,由于这个问题我们实际要计算的是x | (x - 1)
,并且减法运算符-
优先级高于位或运算符 | ,所以括号是可以省略的。
#include <stdio.h>
int main() {
printf("%d\n", 1 && 2 && 3 );
return 0;
}
【运行结果】1
【结果答疑】这个例子是展示了逻辑与&&
的用法。
#include <stdio.h>
int main() {
int a = 0;
printf("%d\n", ++a && a-1 );
return 0;
}
【运行结果】0
【结果答疑】这个例子是展示逻辑与运算符&&
的结合性是从左到右的,先计算++a
,再计算a-1
,结果为1 && 0
即0
。
#include <stdio.h>
int main() {
int a = 0;
printf("%d\n", a-1 && ++a );
return 0;
}
【运行结果】1
【结果答疑】这个例子是展示逻辑与运算符&&
的结合性是从左到右的,先计算a-1
,再计算++a
,结果为-1 && 1
即1
。
#include <stdio.h>
int main() {
int a = 1;
printf("%d\n", a-1 || --a );
return 0;
}
【运行结果】0
【结果答疑】这个例子是展示逻辑或运算符&&
的结合性是从左到右的,先计算a-1
,结果为0,再计算--a
,结果为0
。所以逻辑或的结果为0
。
#include <stdio.h>
int main() {
int a = 1;
printf("%d\n", --a || a-1 );
return 0;
}
【运行结果】1
【结果答疑】这个例子是展示逻辑或运算符&&
的结合性是从左到右的,先计算--a
,结果为0,再计算a-1
,结果为-1
。所以逻辑或的结果为1
。
#include <stdio.h>
int main() {
int a = 1;
--a && --a;
printf("%d\n", a);
return 0;
}
【运行结果】0
【结果答疑】这个例子是展示逻辑或运算符&&
从左往右计算过程中,一旦遇到 0 就不再进行运算了,所以--a
实际上只执行了一次。
#include <stdio.h>
int main() {
int a = 1;
--a && --a;
printf("%d\n", a);
return 0;
}
【运行结果】0
【结果答疑】这个例子是展示逻辑与运算符&&
从左往右计算过程中,一旦遇到 0 就不再进行运算了,所以--a
实际上只执行了一次。
#include <stdio.h>
int main() {
int a = 0;
--a || --a;
printf("%d\n", a);
return 0;
}
【运行结果】1
【结果答疑】这个例子是展示逻辑或运算符从左往右计算过程中,一旦遇到 1 就不再进行运算了,所以--a
实际上只执行了一次。
#include <stdio.h>
int main() {
int a = 1, b = 1;
printf("%d\n", a || a && b );
return 0;
}
【运行结果】1
【结果答疑】这个例子是表示&&
的优先级高于 || 。
#include <stdio.h>
int main() {
int a, b, c;
a = b = c = 6;
printf("%d\n", a );
return 0;
}
【运行结果】6
【结果答疑】这个例子是容易得出a b c
的值均为6
,但是却很难看出赋值运算符的结合性,实际上a = b = c = 6
等价于a = (b = (c = 6))
。 因为赋值运算符是右结合的,并且赋值运算符的值等于赋值运算符=
右边表达式的值。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a += b += c;
printf("%d\n", a );
return 0;
}
【运行结果】6
【结果答疑】这个例子是比较容易看懂,基本知道a
的值等于a b c
三个变量的和,所以值为6
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a -= b -= c;
printf("%d\n", a );
return 0;
}
【运行结果】2
【结果答疑】由于赋值运算符的结合性是从右到左的,所以a -= b -= c
的计算方式等价于a = (a - (b - c))
,值为2
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a *= b *= c;
printf("%d\n", a );
return 0;
}
【运行结果】6
【结果答疑】a *= b *= c
的计算方式等价于a = (a * (b * c))
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a /= b /= c;
printf("%d\n", a );
return 0;
}
【运行结果】异常
【结果答疑】a /= b /= c
的计算方式等价于a = (a / (b / c))
,所以除数b / c
等于0
,所以导致除法异常。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a %= b %= c;
printf("%d\n", a );
return 0;
}
【运行结果】1
【结果答疑】a %= b %= c
的计算方式等价于a = (a % (b % c))
,结果为1
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a <<= b <<= c;
printf("%d\n", a );
return 0;
}
【运行结果】65536
【结果答疑】a <<= b <<= c
的计算方式等价于a = (a << (b << c))
,结果为1 << 16
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a >>= b >>= c;
printf("%d\n", a );
return 0;
}
【运行结果】1
【结果答疑】a >>= b >>= c
的计算方式等价于a = (a >> (b >> c))
,结果为1 >> 0
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a &= b &= c;
printf("%d\n", a );
return 0;
}
【运行结果】0
【结果答疑】a &= b &= c
的计算方式等价于a = (a & (b & c))
,由于&
满足结合律,结果等价于a = (a & b & c)
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a |= b |= c;
printf("%d\n", a );
return 0;
}
【运行结果】3
【结果答疑】同【例题92】,位或运算符同样满足结合律。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a ^= b ^= c;
printf("%d\n", a );
return 0;
}
【运行结果】0
【结果答疑】a ^= b ^= c
的计算方式等价于a = (a ^ (b ^ c))
,由于^
满足结合律,结果等价于a = (a ^ b ^ c)
。
#include <stdio.h>
int main() {
int a = 1, b = 2;
printf("%d\n", a > b ? a + b : a - b );
return 0;
}
【运行结果】-1
【结果答疑】条件运算符的优先级较低,低于关系运算符和算术运算符,所以a > b ? a + b : a - b
等价于1 > 2 ? 3 : -1
。
#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
printf("%d\n", a < b ? b > c ? 9 : 7 : a - b );
return 0;
}
【运行结果】7
【结果答疑】这个例子主要是用来解释条件运算符的结合性是从右到左的,等价于a < b ? (b > c ? 9 : 7) : a - b
。
#include <stdio.h>
int main() {
int a = 2, b = 3;
printf("%d\n", a <<= a < b ? a + b : a - b );
return 0;
}
【运行结果】64
【结果答疑】这个例子主要是说明赋值运算符的优先级低于条件运算符。即a <<= a < b ? a + b : a - b
等价于a <<= (a < b ? a + b : a - b)
。
#include <stdio.h>
int main() {
int a = 2, b = 3;
printf("%d\n", a *= a < b ? a + b : a - b );
return 0;
}
【运行结果】10
【结果答疑】这个例子主要是说明赋值运算符的优先级低于条件运算符。即a *= a < b ? a + b : a - b
等价于a *= (a < b ? a + b : a - b)
。
#include <stdio.h>
int main() {
int a = 2, b = 3;
printf("%d\n", a += a < b ? a + b : a - b );
return 0;
}
【运行结果】7
【结果答疑】这个例子主要是说明赋值运算符的优先级低于条件运算符。即a += a < b ? a + b : a - b
等价于a += (a < b ? a + b : a - b)
。
#include <stdio.h>
int main() {
int tmp, a = 2, b = 3;
tmp = a, a = b, b = tmp;
printf("%d\n", a << b );
return 0;
}
【运行结果】12
【结果答疑】这个例子主要是说明逗号运算符的优先级是最低的,可以放心使用。
🙉饭不食,水不饮,题必须刷🙉
还不会C语言,和我一起打卡! 🌞《光天化日学C语言》🌞
LeetCode 太难?上简单题! 🧡《C语言入门100例》🧡
LeetCode 太简单?大神盘他! 🌌《夜深人静写算法》🌌