【C语言】操作符（上）： -- 算数 -- 移位 -- 位操作符 -- 赋值 -- 单目 -- 关系 -- 逻辑操作符

痛定思痛。 2023-09-27 15:44 84阅读 0赞

**目录**

1、算数操作符

2、移位操作符

2.1 原码、反码、补码

2.2 左移操作符

2.3 右移操作符

3、位操作符

3.1 按位与

3.2 按位或

3.3 按位异或

3.4 练习

4、赋值操作符

4.1 复合赋值符

5、单目操作符

5.1 ! -- 逻辑反操作

5.2 & -- 取地址操作符

5.3 \* -- 解引用操作符（间接访问操作符）

5.4 sizeof

5.4.1 sizeof练习

5.5 ~ -- 二进制按位取反

5.6 ++、--操作符

5.6.1 后置++ 、--

5.6.2 后置++、--

5.7 (类型) -- 强制类型转换

6、关系操作符

7、逻辑操作符

7.1练习

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

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*正文开始\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

## 1、算数操作符 ##

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

1.  **除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数；**
2.  **对于 / 操作符如果两个数都为整数，执行整数除法，而只要有浮点数执行的就是整数除法；**
3.  **% 操作符的两个操作数必须为整数，返回的是整除之后的余数。**

**我们看看代码来对这三点加深印象：**

**我们先来看 / 和 % ：**

#include <stdio.h>
    int main()
    {
        //  / 除法 - 得到的是商
        //  % 取模（取余）- 得到的是余数
        printf("%d\n", 10/2.0);
        printf("%lf\n", 10/3.0);
        printf("%d\n", 10/2.0);
        printf("%d\n", 10%2);
        return 0;
    }

*效果展示：*

![fbc44702e8942c43d0a2136dbfd50367.png][]

**第三行打印怎么不是 5 呢，我们来分析一下：**

![8b63b2627f2fa1b81b6001c150300f7c.png][]

**因此应该使用 %lf 打印。**

**我们对代码进行改正：**

#include <stdio.h>
    int main()
    {
        //  / 除法 - 得到的是商
        //  % 取模（取余）- 得到的是余数
        printf("%d\n", 10/2);
        printf("%lf\n", 10/3.0);
        printf("%lf\n", 10/2.0);
        printf("%d\n", 10%2);
        return 0;
    }

*效果展示：*

![a1dd968e3626de6004d52a7ef52b0388.png][]

这个例子就是验证了第二条：**对于 / 操作符如果两个数都为整数，执行整数除法，而只要有浮点数执行的就是整数除法。**

**我们再来看看 % ：**

![42f64b982f7fef6293925d75bc7a3a87.png][]

这里就印证了第三条：**% 操作符的****两个操作数必须为整数****，返回的是整除之后的余数。**

## 2、移位操作符 ##

> **<< 左移操作符**
> 
> **>> 右移操作符**
> 
> **注：****移位操作符的操作数只能是整数。移动的是二进制的位。**

**10进制的数据中：都是0~9的数字组成的；**

**8进制的数据中：都是0~7的数字组成的；**

**2进制的数据中：都是0~1的数字组成的。**

10进制的数字都有自己的权重，比如 123：

![91ee6cf4a3ed6e9b8f14770ab808f764.png][]

2进制的数字也是一样有自己的权重，比如 1010：

![c2dacaab1fdf02562857cebdd1152174.png][]

8进制的数字也是一样，比如 12：

![779380b29c6032fbcb4b432810d2ae6d.png][]

16进制（范围：0~15）的每一位：0 1 2 3 4 5 6 7 8 9 A B C D E F

因此，16进制表示10就是 A。

### 2.1 原码、反码、补码 ###

**整数：**

**整数的二进制表示形式有 3 种方式：****原码、反码、补码**

**原码：把一个数按照正负直接翻译成二进制就是原码。**

**反码：符号位不变，其他位按位取反。**

**补码：反码 +1。**

**注：正整数的原码反码补码是相同的。（正整数写出原码就是反码和补码。负整数的原反补码需要根据以上规律计算）**

**举例：写出 5，-5的原码、反码、补码**

**5，-5是整数，整数是存放在整型变量中的，一个整型变量是 4 个字节 -- 32个比特位。**

**我们以 32 位来描述 5，5 用二进制表示为 101（这已经是3个比特位了），高位我们用 0 来补齐。因此5的二进制表示为：**

00000000 00000000 00000000 00000101

**注：第一个 0 表示的是最高位，最高位是符号位，正数的符号位表示为 0，负数的符号位表示为 1。**

**因为 -5 的二进制表示为：**

10000000 00000000 00000000 00000101

**5的原、反、补码：**

00000000 00000000 00000000 00000101

**-5的原、反、补码：**

**原码：**10000000 00000000 00000000 00000101

**反码：**11111111 11111111 11111111 11111010

**补码：**11111111 11111111 11111111 11111011

**整数在内存中存储的是补码二进制。**

**我们验证一下：**

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

*内存中的 -5 存储展示：*

![c0d8dbb89f5a70b7de8ca7a4f4c510d1.png][]

我们来分析一下为什么是这样

**内存中是以十六进制存储的，f 代表了 15。**

![b9029051ce710d2e1195dae11412e4b0.png][]

**编译器中是反着存的，所以是 fb ff ff ff 。这就验证了，二进制在内存中存的是补码。**

### 2.2 左移操作符 ###

**移位规则：***左边抛弃，右边补0*

**我们来看一段代码：**

#include <stdio.h>
    int main()
    {
        int a = 3;
        //3的二进制序列：00000000 00000000 00000000 00000011
        int b = a << 1;
    
        printf("%d\n", b);
        printf("%d\n", a);
        return 0;
    }

*效果展示：*

![033e902591e9ad19f27f416444809f6f.png][]

**Q：为什么 a << 1 变成了6呢？**

A：我们使用图解：

**3是正整数，原码就是补码。**

![bf04787e7f59f4a9f17273556ae42b19.png][]

**这里应该注意的是 a ，对 a 进行了左移并将值赋给 b ，a 本身是不发生变化的。a << 1 这个表达式结果是 6 ，但是 a 是不变的。并且舍弃的确实是符号位，舍弃后紧挨着的那个数字充当符号位。**

**这次我们来看看 -3**

#include <stdio.h>
    int main()
    {
        int a = -3;
        //原码二进制序列：10000000 00000000 00000000 00000011
        //反码二进制序列：11111111 11111111 11111111 11111100
        //补码二进制序列：11111111 11111111 11111111 11111101
        int b = a << 1;
        //补码二进制序列：11111111 11111111 11111111 11111010
        //反码二进制序列：10000000 00000000 00000000 00000101
        //原码二进制序列：10000000 00000000 00000000 00000110
        printf("%d\n", b);//打印是以原码来打印
        printf("%d\n", a);
        return 0;
    }

*效果展示：*

![6e8dd052f5d16c85b56fc2f0e6a6d5d1.png][]

**我们继续画图分析：**

![a6313e51000adb6800e096633f6e44d1.png][]

**注：负数的补码转换成反码有两种方式：-1，取反；取反+1。两种方式都是可以的。**

### 2.3 右移操作符 ###

**移位规则：**

**右移运算分两种：**

> 1.逻辑移位
> 
> 左边用 0 补充，右边丢弃
> 
> 2.算术移位
> 
> 左边用原来值的符号位填充，右边丢弃

**注：两种都是移几位相应补几位。**

**我们继续以代码来深入了解：**

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

*效果展示：*

![fde15310223390aadf4021ac4f1ee7f7.png][]

**Q：为什么 b 变成了-3 呢？**

**我们来分析一下，有了左移的经验，这里就会容易不少。**

![5af8b2214c62ce8996f767d0f9fabe34.png][]

**这里我们也可以了解到 vs 2019 编译器做的是算数右移。**

**如果这里是逻辑右移的话符号位就是 0 ，得出来的就是 3。**

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

## 3、位操作符 ##

> 位操作符有：
> 
> & //按位与
> 
> | //按位或
> 
> ^ //按位异或
> 
> 注：它们的操作数必须是整数。

这里的位：是二进制位。

### 3.1 按位与 ###

**我们来看一段代码：**

#include <stdio.h>
    int main()
    {
    	int a = 3;
    	int b = -5;
    	int c = a & b;//按位与：对应的二进制位上有0为0，双1为1
    	//00000000 00000000 00000000 00000011 -- 3的补码
    	//10000000 00000000 00000000 00000101 -- -5的原码
    	//11111111 11111111 11111111 11111010 -- -5的反码
    	//11111111 11111111 11111111 11111011 -- -5的补码
    	//00000000 00000000 00000000 00000011 -- 3的补码
    	//00000000 00000000 00000000 00000011 -- &的结果，这里的补码和3的补码是一样的，因此打印的就是3
    	printf("%d\n", c);
    	return 0;
    }

**按位与的规则是：对应的二进制位上有0为0，同是1为1。**

**按照这个规则我们来分析一下 c 的补码是：**

**11111111 11111111 11111111 11111011 -- -5的补码**

**00000000 00000000 00000000 00000011 -- 3的补码**

**00000000 00000000 00000000 00000011 -- &的结果，符号位是 0 (表示正数)，原反补码是相同的。**

**这里的补码和3的补码是一样的，因此打印的就是3。**

*效果展示：*

![3a6581e3f71b691509608015eb0c9843.png][]

### 3.2 按位或 ###

**按位或的规则是：对应的二进制位上有1为1，同是0为0**

**我们来看一段代码：**

#include <stdio.h>
    int main()
    {
    	int a = 3;
    	int b = -5;
    	int c = a | b;//按位或：对应的二进制位上有1为1，双0为0
    	//00000000 00000000 00000000 00000011 -- 3的补码
    	//10000000 00000000 00000000 00000101 -- -5的原码
    	//11111111 11111111 11111111 11111010 -- -5的反码
    	//11111111 11111111 11111111 11111011 -- -5的补码
    	//00000000 00000000 00000000 00000011 -- 3的补码
    	//11111111 11111111 11111111 11111011 -- |的结果
    	printf("%d\n", c);
    	return 0;
    }

**按照这个规则我们来分析一下 c 的补码是：**

**11111111 11111111 11111111 11111011 -- -5的补码**

**00000000 00000000 00000000 00000011 -- 3的补码**

**11111111 11111111 11111111 11111011 -- |的结果（这里的补码和 -5 的补码是一样的）**

**这里的符号位为 1 (代表是负数)，因此这需要将补码转为原码。**

**原码：10000000 00000000 00000000 00000101**

**c 的原码转为 10 进制就是 -5。**

*效果展示：*

![ac7bacbc3530eefdfe43f6cd05e8fb6d.png][]

### 3.3 按位异或 ###

**按位异或的规则是：对应的二进制位上相同为0，相异为1**

**我们来看一段代码：**

#include <stdio.h>
    int main()
    {
    	int a = 3;
    	int b = -5;
    	int c = a ^ b;//按位异或：对应的二进制位上相同为0，相异为1
    	//00000000 00000000 00000000 00000011 -- 3的补码
    	//10000000 00000000 00000000 00000101 -- -5的原码
    	//11111111 11111111 11111111 11111010 -- -5的反码
    	//11111111 11111111 11111111 11111011 -- -5的补码
    	//00000000 00000000 00000000 00000011 -- 3的补码
    	//11111111 11111111 11111111 11111000 -- ^的结果
    	printf("%d\n", c);
    	return 0;
    }

**按照这个规则我们来分析一下 c 的补码是：**

**11111111 11111111 11111111 11111011 -- -5的补码**

**00000000 00000000 00000000 00000011 -- 3的补码**

**11111111 11111111 11111111 11111000 -- ^的结果**

**这里的符号位为 1 (代表是负数)，因此这需要将补码转为原码。**

**原码：10000000 00000000 00000000 00001000**

**c 的原码转化为 10 进制就是 -8。**

*效果展示：*

![c3e336d17c60c593ce809c85d9d03836.png][]

### 3.4 练习 ###

**Q：不创建临时变量怎么交换两个数？**

**法一：**

#include <stdio.h>
    //a^a = 0; 相同为 0
    //a^0 = a; 相异为 1
    //3^5^3 = 5 二进制码来做
    //3^5^3 = 5
    //异或支持交换律
    int main()
    {
    	int a = 3;
    	int b = 5;
    	a = a ^ b;//1式
    	b = a ^ b;// 将1式代入此式当中，得出b = a
    	a = a ^ b;// 将1式带入此式当中，得出a = b
    	printf("a = %d, b = %d\n", a, b);
    	return 0;
    }

*效果展示：*

![2be39e7e5a969dc03ecb4e8938835bc3.png][]

**法二：**

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

*效果展示：*

![c2e01a7846345a6ada68a5c0e90aecd4.png][]

**但是这种方法存在弊端，如果 a 和 b 过大 a+b 就会存在栈溢出的问题，存在缺陷。因此****法一是符合要求的方法，但是只是针对不创建临时变量来讲更合理。^ 交换两个数存在 3 个弊端：**

**1.是 ^ 只针对整形可以交换，浮点型不可以；**

**2.它的可读性比较差：**

**3.如果可以创建临时变量，效率会高点。**

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

#include <stdio.h>
    int main()
    {
        int n = 0;
        scanf("%d", &n);
        int count = 0;//计数器
        int i = 0;
        while (i<32)
        {
            if(1 == (n&1))
                count++;
            n = n >> 1;
            i++;
        }
        printf("%d\n", count);
        return 0;
    }

我们来分析一下此代码是如何实现问题的：

**1的补码与任何数与只会得到两个数：0 / 1（因为按位与的规则是：有 0 得 0 ，同为 1 得 1。1 的二进制序列除了最后一个数字是 1 之外全是 0 ，因此任何数与 1 按位与只会得到 0 / 1）。按照这个规律我们展开想，假设我们输入了一个 3 ，3 的二进制序列是00000000 00000000 00000000 00000011，我们让它与 1 的二进制序列00000000 00000000 00000000 00000001，按位与，如果得到的数是 1 ，我们就让计数器+1，然后对 3 进行右移，得到下一个二进制数再进行按位与操作，得到的是 1 就再让计数器+1，循环 32 次，这样就可以得出一个整数的二进制序列到底有多少个 1。**

![793fbdf2881979c424289c3f60ce63cd.png][]

## 4、赋值操作符 ##

**赋值操作符是一个很棒的操作符，它可以让你得到一个你满意的值。也就是你可以对自己重新赋值。**

**初始化的 = 与赋值的 = 是不一样的，创建变量的时候的 = 是初始化，后面对变量的值进行更改用到的 = 才是赋值操作符。**

int weight = 120;//体重，这里的=不是赋值操作符，这是初始化
    weight = 90;//不满意就重新赋值
    //赋值操作符可以连续使用，比如：
    int a = 10;
    int x = 0;
    int y = 20;
    a = x = y+1;//连续赋值，先把y+1赋给x，再把x赋给a
    //这样的可读性并不好，因此下面的代码可读性会更好一点
    x = y + 1;
    a = x;
    //这样的写法更加清晰明了，而且易于调试

### 4.1 复合赋值符 ###

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

这些运算符都可以写成符合的效果。

例如：

#include <stdio.h>
    int main()
    {
        int a = 3;
        a = a + 3;
        a += 3;
    
        a = a >> 3;
        a >>= 3;
    
        a = a * 3;
        a *= 3;
    
        a = a / 3;
        a /= 3;
        return 0;
    }

## 5、单目操作符 ##

> ！ 逻辑反操作
> 
> \- 负值
> 
> \+ 正值
> 
> & 取地址
> 
> sizeof 操作数的类型长度（以字节为单位）
> 
> ~ 对一个数的二进制按位取反
> 
> \-- 前置、后置--
> 
> \++ 前置、后置++
> 
> \* 间接访问操作符（解引用操作符）
> 
> (类型) 强制类型转换

**我们这里只讲一部分：**

### 5.1 ! -- 逻辑反操作 ###

一般是在判断句中做判断调价的调整。

例如：

int main()
    {
        int flag = 1;
        if(flag)//flag为真就进入if语句里面
        {
            
        }
        if(!flag)//这里就是flag为假的时候进到if语句里面去
            	//（flag为假，!flag就变成了真，这样就实现了为假进入）
        {
            
        }
        return 0;
    }

### 5.2 & -- 取地址操作符 ###

一般用于指针，取某个地址。

例如：

#include <stdio.h>
    int main()
    {
        int a = 3;
        &a;//取出变量a的地址
    
        int arr[10] = { 0 };
        &arr;//取出数组arr的地址（这里是拿到整个数组的地址）
        return 0;
    }

### 5.3 \* -- 解引用操作符（间接访问操作符） ###

#include <stdio.h>
    int main()
    {
        int a = 3;
        int* p = &a;//p里面存放变量a的地址，*p是通过p里面存放的地址找到a，因此*p也就是a
        *p = 5;//承接上一句，这里看到的是改*p，实则通过地址改了a
        printf("%d\n", a);
        
        return 0;
    }

*效果展示：*

![d8c024ba77ae61f43db54b48d3a85d0b.png][]

**因此&和\*是一对，一般都是在一起用的。**

### 5.4 sizeof ###

**sizeof是计算所占内存空间大小或者类型的长度的（单位：字节）。**

例如：

#include <stdio.h>
    int main()
    {
        int a = 3;
        printf("%d\n", sizeof(a));//我们这里打印的就是a所占空间的大小
        //a两端的()可以不写
        printf("%d\n", sizeof a);
        printf("%d\n", sizeof(int));//我们这打印a的类型是一样的，因为a是整形
    
        int arr[10] = { 0 };
        printf("%d\n", sizeof(arr));//sizeof可以计算数组总大小
        //引申
        printf("%d\n", sizeof(arr[0]));//还可以计算数组首元素大小
        printf("%d\n", sizeof(arr)/sizeof(arr[0]));//也可以计算数组长度
        return 0;
    }

*效果展示：*

![a20a692d5231636a433844ae4a07b756.png][]

**总结：sizeof在计算变量的时候可以省略( )，但是计算类型的时候不可以省略。**

#### 5.4.1 sizeof练习 ####

**我们看一段代码给出答案：**

#include <stdio.h>
    void test1(int arr[])
    {
        printf("%d\n", sizeof(arr));
    }
    void test2(char arr[])
    {
        printf("%d\n", sizeof(arr));
    }
    int main()
    {
        int arr1[10] = { 0 };
        char arr2[10] = { 0 };
        printf("%d\n", sizeof(arr1));
        printf("%d\n", sizeof(arr2));
    
        test1(arr1);
        test2(arr2);
        return 0;
    }

**我们分析一下：**

**sizeof(数组名)求的是整个数组的大小，因此打印的一二行分别是40，10。**

**数组传参传的是首元素地址，是一个指针，test1，test2函数计算的都是指针的大小，在X32的环境下就是4，X64的环境下就是8。****我们来看看结果：**

*效果展示：*

![6a0f8b1a404531c4b6ebb93cb9a0d077.png][]

### 5.5 ~ -- 二进制按位取反 ###

**我们以一段代码来看看~ 操作符：**

#include <stdio.h>
    int main()
    {
        int a = 0;
        //二进制
        //a的补码: 00000000 00000000 00000000 00000000
        //~a的补码:11111111 11111111 11111111 11111111
        //~a的反码:10000000 00000000 00000000 00000000
        //~a的原码:10000000 00000000 00000000 00000001
        //原码转化为10进制数为-1
        printf("%d\n", ~a);
        return 0;
    }

**分析：**

**a的二进制补码：00000000 00000000 00000000 00000000**

**~a的二进制补码：11111111 11111111 11111111 11111111**

**~a的二进制反码：10000000 00000000 00000000 00000000**

**~a的二进制原码：10000000 00000000 00000000 00000001**

**~a的二进制原码转化为10进制数是 -1。**

*效果展示：*

![d33cc10c8812348a713c24c86c1b2e60.png][]

**Q：如何将3的二进制序列00000000 00000000 00000000 0000****0****011中标记的0改为1，最后再改回来？**

**我们来分析一下这个问题：**

![a3f7ffc2bc3526e2b6dc82f6a97de177.png][]

**我们按照此分析来写代码：**

#include <stdio.h>
    int main()
    {
        int a = 3;
        //处理
        a |= (1 << 3);
        printf("%d\n", a);
        //回到原来的a
        a &= (~(1 << 3));
        printf("%d\n", a);
        return 0;
    }

*效果展示：*

![bb183cbe1156ab557c3cd574fd0be9c2.png][]

### 5.6 ++、--操作符 ###

#### 5.6.1 后置++ 、-- ####

**规则：先使用，再++/--**

**怎么理解呢，我们来看一段代码：**

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

*效果展示：*

![9c1c70b4c4bf33ba958a1d861ac13afb.png][]

**这里是先把 a 的值赋给 b ，再对 a 进行+1。先把 c 的值赋给 d ，再对 d 进行-1。**

#### 5.6.2 后置++、-- ####

**规则：先++/--，再使用**

**理解是和上面的代码反着来，我们继续来看代码：**

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

*效果展示：*

![23f33f1af05bdd053bb4706a18a147cf.png][]

**这里是对 a 先++（因此 a 的值就改变了），再赋给 b 。先对 c --（因此 c 的值就改变了）， 再赋给 d。**

### 5.7 (类型) -- 强制类型转换 ###

**强制类型转换只是临时的一种状态，只在强制转换的那一行是所强转的类型，后面再使用时，仍然是本来的类型。**

**我们来看一段强转的例子：**

#include <stdio.h>
    int main()
    {
        float a = 0.0f;
        int b = a;
        return 0;
    }

![f2646786daccdc7ce40b638f5750d5f5.png][]

**强转后：**

#include <stdio.h>
    int main()
    {
        float a = 0.0f;
        int b = (int)a;
        return 0;
    }

![2915c34a68a6e7467ae1667d8f1fb473.png][]

**这里就不会再报警告。**

## 6、关系操作符 ##

> >
> 
> <
> 
> >=
> 
> <=
> 
> != 用于测试”不相等“
> 
> == 用于测试”相等“

**警告：在判断相等的时候一定要注意是 == 不是 = 。**

## 7、逻辑操作符 ##

> && 逻辑与（并且）
> 
> || 逻辑或（或者）

**逻辑操作符与位操作符不一样，一定要能区分开来。****逻辑操作符只关注真假。**

**来看一段代码：**

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

*效果展示：*

![2ad6f1f47a78eae46cbd4c7c3ad06b66.png][]

![64c10fc68cff482001db0ddfaa93943d.png][]

**都为真，打印真（真为1，假为0）。若两个数有一个是0（表示假），打印的就为假（0）。**

**逻辑或（||），两个数有一个为真就为真，同为假就为假。**

### 7.1练习 ###

**看这段代码，给出答案：**

#include <stdio.h>
    int main()
    {
        int i = 0, a = 0, b = 2, c = 3, d = 4;
        i = a++ && ++b && d++;
        printf("a = %d\nb = %d\nc = %d\nd = %d", a, b, c, d);
        return 0;
    }

**因为逻辑操作符只看真假，a++是先使用再++，因此a++是 0 ，为假，为假就不执行&&后面的代码++b，d++。打印的时候 a 的值就变成了 1 ，b，c，d 的值不变，打印的就是1 2 3 4。**

*效果展示：*

![665cb56628dbda2dfafca43199c0aa90.png][]

**我们将 a 改为 1 ，再来看看：**

#include <stdio.h>
    int main()
    {
        int i = 0, a = 1, b = 2, c = 3, d = 4;
        i = a++ && ++b && d++;
        printf("a = %d\nb = %d\nc = %d\nd = %d", a, b, c, d);
        return 0;
    }

**这里的 a,b,c 都是非 0 数，因此&&的整个式子都走了一遍，按照前置后置++的规则得出：a = 2，b = 3，c = 3， d = 5。**

*效果展示：*

![4bf3b90ef28a41a7ffd1ce9241833389.png][]

**我们再来看或者：**

#include <stdio.h>
    int main()
    {
        int i = 0, a = 1, b = 2, c = 3, d = 4;
        i = a++ || ++b || d++;
        printf("a = %d\nb = %d\nc = %d\nd = %d", a, b, c, d);
        return 0;
    }

**a是非 0 数，因此 | | 整个式子就为真，只执行a++，| |后面的式子++b，d++不执行，因此 a = 2，b = 2，c = 3，d = 4。**

*效果展示：*

![5d1b7ecdd341a92af7b0711daf9cb3b6.png][]

**将 a 改为 0 ，又是什么结果呢？**

#include <stdio.h>
    int main()
    {
        int i = 0, a = 0, b = 2, c = 3, d = 4;
        i = a++ || ++b || d++;
        printf("a = %d\nb = %d\nc = %d\nd = %d", a, b, c, d);
        return 0;
    }

**a = 0为假，走到++b（b = 3），为真，d++不执行，打印出来为：a = 1，b = 3，c = 3，d = 4。**

*效果展示：*

![1753570fcad922f06b43a2fb03fdc162.png][]

**总结：&&操作符，左边为假右边不再计算；||操作符，左边为真右边不再计算。（短路）**

[fbc44702e8942c43d0a2136dbfd50367.png]: https://img-blog.csdnimg.cn/img_convert/fbc44702e8942c43d0a2136dbfd50367.png
[8b63b2627f2fa1b81b6001c150300f7c.png]: https://img-blog.csdnimg.cn/img_convert/8b63b2627f2fa1b81b6001c150300f7c.png
[a1dd968e3626de6004d52a7ef52b0388.png]: https://img-blog.csdnimg.cn/img_convert/a1dd968e3626de6004d52a7ef52b0388.png
[42f64b982f7fef6293925d75bc7a3a87.png]: https://img-blog.csdnimg.cn/img_convert/42f64b982f7fef6293925d75bc7a3a87.png
[91ee6cf4a3ed6e9b8f14770ab808f764.png]: https://img-blog.csdnimg.cn/img_convert/91ee6cf4a3ed6e9b8f14770ab808f764.png
[c2dacaab1fdf02562857cebdd1152174.png]: https://img-blog.csdnimg.cn/img_convert/c2dacaab1fdf02562857cebdd1152174.png
[779380b29c6032fbcb4b432810d2ae6d.png]: https://img-blog.csdnimg.cn/img_convert/779380b29c6032fbcb4b432810d2ae6d.png
[c0d8dbb89f5a70b7de8ca7a4f4c510d1.png]: https://img-blog.csdnimg.cn/img_convert/c0d8dbb89f5a70b7de8ca7a4f4c510d1.png
[b9029051ce710d2e1195dae11412e4b0.png]: https://img-blog.csdnimg.cn/img_convert/b9029051ce710d2e1195dae11412e4b0.png
[033e902591e9ad19f27f416444809f6f.png]: https://img-blog.csdnimg.cn/img_convert/033e902591e9ad19f27f416444809f6f.png
[bf04787e7f59f4a9f17273556ae42b19.png]: https://img-blog.csdnimg.cn/img_convert/bf04787e7f59f4a9f17273556ae42b19.png
[6e8dd052f5d16c85b56fc2f0e6a6d5d1.png]: https://img-blog.csdnimg.cn/img_convert/6e8dd052f5d16c85b56fc2f0e6a6d5d1.png
[a6313e51000adb6800e096633f6e44d1.png]: https://img-blog.csdnimg.cn/img_convert/a6313e51000adb6800e096633f6e44d1.png
[fde15310223390aadf4021ac4f1ee7f7.png]: https://img-blog.csdnimg.cn/img_convert/fde15310223390aadf4021ac4f1ee7f7.png
[5af8b2214c62ce8996f767d0f9fabe34.png]: https://img-blog.csdnimg.cn/img_convert/5af8b2214c62ce8996f767d0f9fabe34.png
[3a6581e3f71b691509608015eb0c9843.png]: https://img-blog.csdnimg.cn/img_convert/3a6581e3f71b691509608015eb0c9843.png
[ac7bacbc3530eefdfe43f6cd05e8fb6d.png]: https://img-blog.csdnimg.cn/img_convert/ac7bacbc3530eefdfe43f6cd05e8fb6d.png
[c3e336d17c60c593ce809c85d9d03836.png]: https://img-blog.csdnimg.cn/img_convert/c3e336d17c60c593ce809c85d9d03836.png
[2be39e7e5a969dc03ecb4e8938835bc3.png]: https://img-blog.csdnimg.cn/img_convert/2be39e7e5a969dc03ecb4e8938835bc3.png
[c2e01a7846345a6ada68a5c0e90aecd4.png]: https://img-blog.csdnimg.cn/img_convert/c2e01a7846345a6ada68a5c0e90aecd4.png
[793fbdf2881979c424289c3f60ce63cd.png]: https://img-blog.csdnimg.cn/img_convert/793fbdf2881979c424289c3f60ce63cd.png
[d8c024ba77ae61f43db54b48d3a85d0b.png]: https://img-blog.csdnimg.cn/img_convert/d8c024ba77ae61f43db54b48d3a85d0b.png
[a20a692d5231636a433844ae4a07b756.png]: https://img-blog.csdnimg.cn/img_convert/a20a692d5231636a433844ae4a07b756.png
[6a0f8b1a404531c4b6ebb93cb9a0d077.png]: https://img-blog.csdnimg.cn/img_convert/6a0f8b1a404531c4b6ebb93cb9a0d077.png
[d33cc10c8812348a713c24c86c1b2e60.png]: https://img-blog.csdnimg.cn/img_convert/d33cc10c8812348a713c24c86c1b2e60.png
[a3f7ffc2bc3526e2b6dc82f6a97de177.png]: https://img-blog.csdnimg.cn/img_convert/a3f7ffc2bc3526e2b6dc82f6a97de177.png
[bb183cbe1156ab557c3cd574fd0be9c2.png]: https://img-blog.csdnimg.cn/img_convert/bb183cbe1156ab557c3cd574fd0be9c2.png
[9c1c70b4c4bf33ba958a1d861ac13afb.png]: https://img-blog.csdnimg.cn/img_convert/9c1c70b4c4bf33ba958a1d861ac13afb.png
[23f33f1af05bdd053bb4706a18a147cf.png]: https://img-blog.csdnimg.cn/img_convert/23f33f1af05bdd053bb4706a18a147cf.png
[f2646786daccdc7ce40b638f5750d5f5.png]: https://img-blog.csdnimg.cn/img_convert/f2646786daccdc7ce40b638f5750d5f5.png
[2915c34a68a6e7467ae1667d8f1fb473.png]: https://img-blog.csdnimg.cn/img_convert/2915c34a68a6e7467ae1667d8f1fb473.png
[2ad6f1f47a78eae46cbd4c7c3ad06b66.png]: https://img-blog.csdnimg.cn/img_convert/2ad6f1f47a78eae46cbd4c7c3ad06b66.png
[64c10fc68cff482001db0ddfaa93943d.png]: https://img-blog.csdnimg.cn/img_convert/64c10fc68cff482001db0ddfaa93943d.png
[665cb56628dbda2dfafca43199c0aa90.png]: https://img-blog.csdnimg.cn/img_convert/665cb56628dbda2dfafca43199c0aa90.png
[4bf3b90ef28a41a7ffd1ce9241833389.png]: https://img-blog.csdnimg.cn/img_convert/4bf3b90ef28a41a7ffd1ce9241833389.png
[5d1b7ecdd341a92af7b0711daf9cb3b6.png]: https://img-blog.csdnimg.cn/img_convert/5d1b7ecdd341a92af7b0711daf9cb3b6.png
[1753570fcad922f06b43a2fb03fdc162.png]: https://img-blog.csdnimg.cn/img_convert/1753570fcad922f06b43a2fb03fdc162.png