《C语言运算符100例》优先级面试错题_c语言运算符优先级题目

最新推荐文章于 2024-10-17 16:11:40 发布

2401_85013892

最新推荐文章于 2024-10-17 16:11:40 发布

阅读量328

点赞数 3

分类专栏： 2024年程序员学习文章标签：物联网嵌入式硬件面试

本文链接：https://blog.csdn.net/2401_85013892/article/details/138932185

版权

2024年程序员学习专栏收录该内容

23 篇文章 1 订阅

订阅专栏

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

如果你需要这些资料，可以戳这里获取



> 
> 【运行结果】-2  
> 【结果答疑】这个例子体现了`[]`的优先级高于`-`，即`-a[2]`等价于`-(a[2])`。
> 
> 
> 




---



**🧡例题12🧡**

#include <stdio.h>
struct A {
int a;
}a;
int main() {
a.a = 5;
printf(“%d\n”, - a.a );
return 0;
}



> 
> 【运行结果】-5  
> 【结果答疑】这个例子体现了`.`的优先级高于`-`。
> 
> 
> 




---



**🧡例题13🧡**

#include <stdio.h>
double a[3] = {1.1, 2.2, 3.3};
int main() {
printf(“%d\n”, (int)a[2] );
return 0;
}



> 
> 【运行结果】3  
> 【结果答疑】这个例子体现了`[]`的优先级高于`(type)`。
> 
> 
> 




---



**🧡例题14🧡**

#include <stdio.h>
struct A {
double a;
}a;
int main() {
a.a = 5.6;
printf(“%d\n”, (int)a.a );
return 0;
}



> 
> 【运行结果】5  
> 【结果答疑】这个例子体现了`.`的优先级高于`(type)`。
> 
> 
> 




---



**🧡例题15🧡**

#include <stdio.h>
struct A {
double a;
}a;
int main() {
a.a = 5.6;
printf(“%d\n”, (int)a.a );
return 0;
}



> 
> 【运行结果】5  
> 【结果答疑】这个例子体现了`.`的优先级高于`(type)`。
> 
> 
> 




---



**🧡例题16🧡**

#include <stdio.h>
int a[5] = {1, 2, 3, 4, 5};
int main() {
printf(“%d\n”, ++a[2] );
return 0;
}



> 
> 【运行结果】4  
> 【结果答疑】这个例子体现了`[]`的优先级高于`++`，且`++`作为前缀运算符时，返回的是自增后的结果。
> 
> 
> 




---



**🧡例题17🧡**

#include <stdio.h>
int a[5] = {1, 2, 3, 4, 5};
int main() {
printf(“%d\n”, ++a[2]++ );
return 0;
}



> 
> 【运行结果】编译错误！  
> 【结果答疑】这个例子说明 ++ 这个运算符只能作用在变量上，不能作用在表达式上。
> 
> 
> 




---



**🧡例题18🧡**

#include <stdio.h>
int a[4] = {1, 2, 3, 4};
int main() {
printf(“%d\n”, a[2]++ );
return 0;
}



> 
> 【运行结果】3  
> 【结果答疑】这个例子体现了`[]`的优先级高于`++`，且`++`作为后缀运算符时，返回的是自增前的结果。
> 
> 
> 




---



**🧡例题19🧡**

#include <stdio.h>
int a = 0;
int main() {
printf(“%d\n”, !++a );
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这个例子是要告诉读者，`++`和`!`都是右结合的，即`++`运算会在`!`运算之前，所以相当于`!1`，所以值为`0`。
> 
> 
> 




---



**🧡例题20🧡**

#include <stdio.h>
int a = 0;
int main() {
printf(“%d\n”, ~~~~~~a );
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这个例子展示了按位取反的右结合性，总共取反六次，相当于没有取反。表达式的效果是等价于`~(~(~(~(~(~a)))))`的。
> 
> 
> 




---



**🧡例题21🧡**

#include <stdio.h>
int a = 0;
int main() {
printf(“%d\n”, &a );
return 0;
}



> 
> 【运行结果】未知整数  
> 【结果答疑】这个例子告诉我们`&a`得到的是`a`这个变量的地址，而非其本身的值。
> 
> 
> 




---



**🧡例题22🧡**

#include <stdio.h>
int a = 6;
int main() {
printf(“%d\n”, *&a );
return 0;
}



> 
> 【运行结果】6  
> 【结果答疑】这个例子的含义是为了说明`*`和`&`是互逆的关系：`&`是取变量的地址，`*`是根据变量地址取值，而地址又叫指针，所以`*`又叫解指针，也可以叫解引用。
> 
> 
> 




---



**🧡例题23🧡**

#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf(“%d %d\n”, &a[1], (&a)[1] );
return 0;
}



> 
> 【运行结果】两个不同的值  
> 【结果答疑】得到的是两个不同的值，为什么呢？继续来看【例题24】。
> 
> 
> 




---



**🧡例题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语言》🌞**](https://bbs.csdn.net/topics/618679757)）
> 
> 
> 




---



**🧡例题25🧡**

#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`，有点伤感……
> 
> 
> 




---



**🧡例题26🧡**

#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】是等价的。
> 
> 
> 




---



**🧡例题27🧡**

#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf(“%d\n”, **a );
return 0;
}



> 
> 【运行结果】编译错误  
> 【结果答疑】这个例子是想要说明`*`只能对指针类型解引用，直接来看【例题28】再来进行详细解释。
> 
> 
> 




---



**🧡例题28🧡**

#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf(“%d\n”, *a );
return 0;
}



> 
> 【运行结果】3  
> 【结果答疑】这个例子是想要说明数组的首地址，就是指针指向的位置，所以直接解引用拿到的就是数组的第一个元素。
> 
> 
> 




---



**🧡例题29🧡**

#include <stdio.h>
int a[2] = {3, 4};
int main() {
printf(“%p %p\n”, a, &*a );
return 0;
}



> 
> 【运行结果】两个相同的值  
> 【结果答疑】这个例子是进一步说明数组的首地址，就是指针指向的位置，`a`代表数组首地址，对首地址解引用，得到的就是`a[0]`，然后再取地址`&`，得到的就是数组`a`的首地址了（刚接触指针的话，这块可能比较绕，建议自己写一下代码看看效果）。
> 
> 
> 




---



**🧡例题30🧡**

#include <stdio.h>
int a[2] = {99, 6};
int *pa[1];
int main() {
pa[0] = a;
printf(“%d\n”, *pa[0] );
return 0;
}



> 
> 【运行结果】99  
> 【结果答疑】这个例子表明`[]`的优先级高于解引用`*`。
> 
> 
> 




---



**🧡例题31🧡**

#include <stdio.h>
int a[2] = {10, 7};
int main() {
printf(“%d\n”, a[0] * a[1] );
return 0;
}



> 
> 【运行结果】70  
> 【结果答疑】这个例子表明`[]`的优先级高于乘法`*`。
> 
> 
> 




---



**🧡例题32🧡**

#include <stdio.h>
int a[2] = {10, 5};
int main() {
printf(“%d\n”, a[0] / a[1] );
return 0;
}



> 
> 【运行结果】2  
> 【结果答疑】这个例子表明`[]`的优先级高于除法`/`。
> 
> 
> 




---



**🧡例题33🧡**

#include <stdio.h>
int a[2] = {10, 3};
int main() {
printf(“%d\n”, a[0] / a[1] );
return 0;
}



> 
> 【运行结果】3  
> 【结果答疑】整数间的除法是取下整。
> 
> 
> 




---



**🧡例题34🧡**

#include <stdio.h>
int a[2] = {10, 0};
int main() {
printf(“%d\n”, a[0] % a[1] );
return 0;
}



> 
> 【运行结果】异常  
> 【结果答疑】会产生除零错误，因为取模时除数不能为零。
> 
> 
> 




---



**🧡例题35🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 + 1 % 2);
return 0;
}



> 
> 【运行结果】2  
> 【结果答疑】取模运算符`%`的优先级高于加法运算符`+`。
> 
> 
> 




---



**🧡例题36🧡**

#include <stdio.h>
int a = 1;
int main() {
printf(“%d\n”, a++ + ++a);
return 0;
}



> 
> 【运行结果】4  
> 【结果答疑】千万别写出这种代码，因为不同编译器可能产生不同的编译结果。
> 
> 
> 




---



**🧡例题37🧡**

#include <stdio.h>
int a = 1;
int main() {
printf(“%d\n”, a++ + ++a);
return 0;
}



> 
> 【运行结果】4  
> 【结果答疑】千万别写出这种代码，因为不同编译器可能产生不同的编译结果。
> 
> 
> 




---



**🧡例题38🧡**

#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(...))`，因为`()`的优先级高于指针运算符`*`。
> 
> 
> 




---



**🧡例题39🧡**

#include <stdio.h>
int a = 5;
int main() {
printf(“%p %p\n”, &a, &a + 1);
return 0;
}



> 
> 【运行结果】两个相差4的地址  
> 【结果答疑】这个例子说明几个问题：首先，指针是可以进行加法运算的，并且不是作为整数来进行加法运算，指针的加1，相当于按照指针指向的类型偏移对应的单位，且取地址`&`的优先级高于加号`+`。
> 
> 
> 




---



**🧡例题40🧡**

#include <stdio.h>
int a = 5;
int main() {
printf(“%p %p\n”, &a, &a - 1);
return 0;
}



> 
> 【运行结果】两个相差4的地址  
> 【结果答疑】这个例子说明几个问题：首先，指针是可以进行减法运算的，并且不是作为整数来进行减法运算，指针的减1，相当于按照指针指向的类型偏移对应的单位，且取地址`&`的优先级高于加号`-`。
> 
> 
> 




---



**🧡例题41🧡**

#include <stdio.h>

int main() {
printf(“%d\n”, 1 << 3 - 1);
return 0;
}



> 
> 【运行结果】4  
> 【结果答疑】`1 << 3 - 1`等价于`1 << (3 - 1)`，因为算术运算符的优先级高于移位运算符。
> 
> 
> 




---



**🧡例题42🧡**

#include <stdio.h>

int main() {
printf(“%d\n”, 1 << 3 + 1);
return 0;
}



> 
> 【运行结果】16  
> 【结果答疑】`1 << 3 + 1`等价于`1 << (3 + 1)`，因为算术运算符的优先级高于移位运算符。
> 
> 
> 




---



**🧡例题43🧡**

#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`。所以最后解引用的还是数组的第一个元素。
> 
> 
> 




---



**🧡例题44🧡**

#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个元素的值。
> 
> 
> 




---



**🧡例题45🧡**

#include <stdio.h>
int a[5] = {9, 8, 7, 6, 5};
int main() {
int *p = a;
printf(“%d\n”, *p<<1);
return 0;
}



> 
> 【运行结果】18  
> 【结果答疑】这个例子中，解引用`*`的优先级高于左移运算符`<<`。
> 
> 
> 




---



**🧡例题46🧡**

#include <stdio.h>
int a[5] = {9, 8, 7, 6, 5};
int main() {
int *p = a;
printf(“%d\n”, *p>>1);
return 0;
}



> 
> 【运行结果】4  
> 【结果答疑】这个例子中，解引用`*`的优先级高于右移运算符`>>`。
> 
> 
> 




---



**🧡例题47🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1<<1>>1<<1>>1);
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】这个例子中，左移运算符`<<`和左移运算符`>>`的优先级优先级相同，结合性从左到右。
> 
> 
> 




---



**🧡例题48🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1<<1.6);
return 0;
}



> 
> 【运行结果】编译错误  
> 【结果答疑】这个例子是为了说明`<<`右边的操作数一定要是整数。
> 
> 
> 




---



**🧡例题49🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1.6<<1);
return 0;
}



> 
> 【运行结果】编译错误  
> 【结果答疑】这个例子是为了说明`<<`左边的操作数一定要是整数。
> 
> 
> 




---



**🧡例题50🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 > 2);
printf(“%d\n”, 1 < 2);
return 0;
}



> 
> 【运行结果】0[换行]1  
> 【结果答疑】这个例子告诉我们关系运算符的运算结果，如果为真返回1，否则返回0。
> 
> 
> 




---



**🧡例题51🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 < 1 << 2);
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】左移运算符`<<`的优先级高于关系运算符`<`。
> 
> 
> 




---



**🧡例题52🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 > 2 > -1);
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】由于`1 > 2`的结果为0，所以`1 > 2 > -1`等价于`0 > -1`，显然是成立的，所以输出的结果为：`1`。
> 
> 
> 




---



**🧡例题53🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 < 2 > 1);
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】由于`1 < 2`的结果为1，所以`1 < 2 > 1`等价于`1 > 1`，显然是不成立的，所以输出的结果为：`0`。
> 
> 
> 




---



**🧡例题54🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 3 > 2 > 1);
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】由于`3 > 2`的结果为1，所以`3 > 2 > 1`等价于`1 > 1`，显然是不成立的，所以输出的结果为：`0`。
> 
> 
> 




---



**🧡例题55🧡**

#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`，即`==`的优先级低于`<`。
> 
> 
> 




---



**🧡例题56🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 < 2 != 1);
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】类似【例题55】。
> 
> 
> 




---



**🧡例题57🧡**

#include <stdio.h>
int main() {
int a;
printf(“%d\n”, a = 0);
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这里其实是想进行`a == 0`的关系判定，结果`=`少写了一个，所以结果变成了赋值号`=`右边表达式的值。
> 
> 
> 




---



**🧡例题58🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 5 <= 6);
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】当然是成立的啦。
> 
> 
> 




---



**🧡例题59🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0110;
printf(“%d\n”, a & b );
return 0;
}



> 
> 【运行结果】2  
> 【结果答疑】这个例子展示了位与的基本运算。
> 
> 
> 




---



**🧡例题60🧡**

#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了。
> 
> 
> 




---



**🧡例题61🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
printf(“%d\n”, a & 1 << 3);
return 0;
}



> 
> 【运行结果】8  
> 【结果答疑】这个例子体现了左移运算符`<<`优先级高于位与`&`。`a & 1 << 3`相当于`a & (1 << 3)`。
> 
> 
> 




---



**🧡例题62🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
printf(“%d\n”, a | 1 << 2);
return 0;
}



> 
> 【运行结果】14  
> 【结果答疑】这个例子体现了左移运算符优先级高于位或。
> 
> 
> 




---



**🧡例题63🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
printf(“%d\n”, a ^ 1 << 2 == 4);
return 0;
}



> 
> 【运行结果】11  
> 【结果答疑】这个例子中运算符优先级：`<<`高于`==`高于`^`。好了，当到达这种复杂情况的时候，你就应该想到要加括号了。
> 
> 
> 




---



**🧡例题64🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
printf(“%d\n”, a ^ ( (1 << 2) == 4 ) );
return 0;
}



> 
> 【运行结果】11  
> 【结果答疑】和【例题63】等价。
> 
> 
> 




---



**🧡例题65🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1000;
printf(“%d\n”, a ^ b & c );
return 0;
}



> 
> 【运行结果】10  
> 【结果答疑】这个例子表明了位与运算符`&`高于异或运算符`^`。
> 
> 
> 




---



**🧡例题66🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf(“%d\n”, a | b & c );
return 0;
}



> 
> 【运行结果】11  
> 【结果答疑】这个例子表明了位与运算符`&`高于位或运算符 | 。
> 
> 
> 




---



**🧡例题67🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf(“%d\n”, a | b ^ c );
return 0;
}



> 
> 【运行结果】14  
> 【结果答疑】这个例子表明了异或运算符`^`高于位或运算符 | 。
> 
> 
> 




---



**🧡例题68🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf(“%d\n”, a | b ^ c );
return 0;
}



> 
> 【运行结果】14  
> 【结果答疑】这个例子表明了异或运算符`^`高于位或运算符 | 。
> 
> 
> 




---



**🧡例题69🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf(“%d\n”, a | b | c );
return 0;
}



> 
> 【运行结果】15  
> 【结果答疑】位或运算符 | 的结合性是从左到右的，不过如果全是 | ，其实它是满足结合律的，所以顺序不太重要。
> 
> 
> 




---



**🧡例题70🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf(“%d\n”, a & b & c );
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】位与运算符`&`的结合性是从左到右的，不过如果全是`&`，其实它是满足结合律的，所以顺序不太重要。
> 
> 
> 




---



**🧡例题71🧡**

#include <stdio.h>
int main() {
int a = 0b1010;
int b = 0b0101;
int c = 0b1001;
printf(“%d\n”, a ^ b ^ c );
return 0;
}



> 
> 【运行结果】6  
> 【结果答疑】异或运算符`^`的结合性是从左到右的，不过如果全是`^`，其实它是满足结合律的，所以顺序不太重要。
> 
> 
> 




---



**🧡例题72🧡**

#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)`。
> 
> 
> 




---



**🧡例题73🧡**

#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。由于减法运算符`-`优先级高于位或运算符 | ，所以需要加上括号。
> 
> 
> 




---



**🧡例题74🧡**

#include <stdio.h>
int main() {
int x = 0b010000;
printf(“%d\n”, x | x - 1 );
return 0;
}



> 
> 【运行结果】31  
> 【结果答疑】这个例子是是将低位连续的零变成一，但是一般这样的写法会报警告，因为编译程序并不知道你的诉求，到底是想先计算 | 还是先计算 `-`，由于这个问题我们实际要计算的是`x | (x - 1)`，并且减法运算符`-`优先级高于位或运算符 | ，所以括号是可以省略的。
> 
> 
> 




---



**🧡例题75🧡**

#include <stdio.h>
int main() {
printf(“%d\n”, 1 && 2 && 3 );
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】这个例子是展示了逻辑与`&&`的用法。
> 
> 
> 




---



**🧡例题76🧡**

#include <stdio.h>
int main() {
int a = 0;
printf(“%d\n”, ++a && a-1 );
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这个例子是展示逻辑与运算符`&&`的结合性是从左到右的，先计算`++a`，再计算`a-1`，结果为`1 && 0`即`0`。
> 
> 
> 




---



**🧡例题77🧡**

#include <stdio.h>
int main() {
int a = 0;
printf(“%d\n”, a-1 && ++a );
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】这个例子是展示逻辑与运算符`&&`的结合性是从左到右的，先计算`a-1`，再计算`++a`，结果为`-1 && 1`即`1`。
> 
> 
> 




---



**🧡例题78🧡**

#include <stdio.h>
int main() {
int a = 1;
printf(“%d\n”, a-1 || --a );
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这个例子是展示逻辑或运算符`&&`的结合性是从左到右的，先计算`a-1`，结果为0，再计算`--a`，结果为`0`。所以逻辑或的结果为`0`。
> 
> 
> 




---



**🧡例题79🧡**

#include <stdio.h>
int main() {
int a = 1;
printf(“%d\n”, --a || a-1 );
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】这个例子是展示逻辑或运算符`&&`的结合性是从左到右的，先计算`--a`，结果为0，再计算`a-1`，结果为`-1`。所以逻辑或的结果为`1`。
> 
> 
> 




---



**🧡例题80🧡**

#include <stdio.h>
int main() {
int a = 1;
–a && --a;
printf(“%d\n”, a);
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这个例子是展示逻辑或运算符`&&`从左往右计算过程中，一旦遇到 0 就不再进行运算了，所以`--a`实际上只执行了一次。
> 
> 
> 




---



**🧡例题81🧡**

#include <stdio.h>
int main() {
int a = 1;
–a && --a;
printf(“%d\n”, a);
return 0;
}



> 
> 【运行结果】0  
> 【结果答疑】这个例子是展示逻辑与运算符`&&`从左往右计算过程中，一旦遇到 0 就不再进行运算了，所以`--a`实际上只执行了一次。
> 
> 
> 




---



**🧡例题82🧡**

#include <stdio.h>
int main() {
int a = 0;
–a || --a;
printf(“%d\n”, a);
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】这个例子是展示逻辑或运算符从左往右计算过程中，一旦遇到 1 就不再进行运算了，所以`--a`实际上只执行了一次。
> 
> 
> 




---



**🧡例题83🧡**

#include <stdio.h>
int main() {
int a = 1, b = 1;
printf(“%d\n”, a || a && b );
return 0;
}



> 
> 【运行结果】1  
> 【结果答疑】这个例子是表示`&&`的优先级高于 || 。
> 
> 
> 




---



**🧡例题84🧡**

#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))`。 因为赋值运算符是右结合的，并且赋值运算符的值等于赋值运算符`=`右边表达式的值。
> 
> 
> 




---



**🧡例题85🧡**

#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`。
> 
> 
> 




---



**🧡例题86🧡**

#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`。
> 
> 
> 




---



**🧡例题87🧡**

#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))`。
> 
> 
> 




---



**🧡例题88🧡**

#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`，所以导致除法异常。
> 
> 
> 




---



**🧡例题89🧡**

#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`。
> 
> 
> 




---



**🧡例题90🧡**

#include <stdio.h>
int main() {
int a = 1, b = 2, c = 3;
a <<= b <<= c;
printf(“%d\n”, a );
return 0;
}

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。

如果你需要这些资料，可以戳这里获取

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

】1

【结果答疑】这个例子是表示&&的优先级高于 || 。

🧡例题84🧡

#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))。因为赋值运算符是右结合的，并且赋值运算符的值等于赋值运算符=右边表达式的值。

🧡例题85🧡

#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。

🧡例题86🧡

#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。

🧡例题87🧡

#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))。

🧡例题88🧡

#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，所以导致除法异常。

🧡例题89🧡

#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。

🧡例题90🧡

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


**收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。**
[外链图片转存中...(img-EME5FWNn-1715796475204)]
[外链图片转存中...(img-eAqKgRHh-1715796475204)]

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**

**需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人**

**都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**