初始C语言——详细讲解操作符以及操作符的易错点

- 日理万妓 2023-10-14 16:12 41阅读 0赞

## 系列文章目录 ##

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

第二章 [详细认识分支语句和循环语句以及他们的易错点][Link 1]

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

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

第五章 初始C语言——详细讲解操作符以及操作符的易错点

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

**目录**

系列文章目录

前言

一、操作符分类

二、算术操作符（两个操作数）

三、移位操作符（两个操作数）

3.1 左移操作符 <<

3.2 右移操作符 >>

3.3 警告

四、位操作符（两个操作数）

4.1 按位与 &

按位与的具体应用：

4.2 按位或 |

4.3 按位异或 ^

按位异或的具体应用：

4.4 有关二进制位的练习

五、赋值操作符

复合赋值符

六、单目操作符（一个操作数）

6.1 单目操作符介绍

6.2 逻辑反操作符 ！

6.3 取地址操作符 & 和解引用操作符 \*

6.4 计算操作数的类型长度 sizeof

6.5 ++ 和 -- 操作符

七、关系操作符（两个操作符）

八、逻辑操作符（两个操作符）

8.1 逻辑与操作符 &&

8.2 逻辑或操作符 ||

8.3 逻辑短路

九、条件操作符（三目操作符）

十、逗号表达式

十一、下标引用、函数调用和结构成员

11.1 \[ \]下标引用操作符（两个操作数）

11.2 （ ）函数调用操作符（至少一个操作数）

11.3 访问一个结构的成员

总结

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

## 前言 ##

> 在上一章内，小编带领大家详细地学习了**有关数组的相关内容，**学习了**一维数组和二维数组的创建与初始化，一维数组和二维数组在内存中如何存储，数组越界，数组作为函数参数怎么办？**
> 
> 而在这一章内，**小编将要带领大家进行学习操作符的内容**，大家从目录也不难看出这章内容也是很多，已经囊括了所有操作符，希望大家也能有耐心地将这一章看完。

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

## 一、操作符分类 ##

**为什么要学习操作符？是为了进行表达式求值。**在学习操作符之前，先跟着小编进行学习操作符的分类吧！

>  *  算术操作符：**+、-、\*、/、%**
>  *  移位操作符：**<<、>>**
>  *  位操作符：**&、|、^**
>  *  赋值操作符：**=、+=、-=、/=、\*=、%=……**
>  *  单目操作符：**！、-、+、sizeof、~、（类型）**
>  *  关系操作符：**>、<、>=、<=、!=、==**
>  *  逻辑操作符：**&&、||**
>  *  条件操作符：**exp1？exp2：exp3**
>  *  逗号表达式：**exp1，exp2，exp3，……expN**
>  *  下标引用、函数调用和结构成员：**\[ \]、（）、.、->**

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

## 二、算术操作符（两个操作数） ##

![55736390edc9430f89ee592b2fba42c0.png][]

在这一部分，小编认为没什么可以讲的，但是这篇博客是详细讲解操作符，所以还是要讲解一下易错点吧！**算术操作符，顾名思义就是数学上的一些运算**：**+、-、\*、/、%。****+、-、\***这三个运算符没有什么可以讲的，接下来，小编重点讲解**：/、%。**

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

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

## 三、移位操作符（两个操作数） ##

![d77d4af77da74c0aa452a442ed9f7808.png][]

小编在讲之前先提一嘴，**移位操作符移动的是二进制的位**。在这里，我们先来讲一下C语言的二进制。

> 对于**一个整数来说是四个字节**，也就是**==32bit位**。一个整数写成二进制序列的时候，就是32个bit位。下面看图理解：
> 
> ![aa51aa6ba4fa4838803d8e26539115b6.png][]
> 
>  **1）对于有符号的整数来说，最高位的一位是符号位：符号位是1，表示负数；符号位是0，表示正数。** 
> 
> ![3abfc1a264bb418fa53870ce356dfa9e.png][]
> 
> **2）对于无符号整数来说，没有符号位，所有位都是有效位。**

> **整数的二进制表示形式有三种：原码、反码、补码。**
> 
> **原码：按照数值的正负，直接写出的二进制序列就是原码。**
> 
> ![bb513a309b1343edaa9eebb80dde03ba.png][]
> 
> **反码：原码的符号位不变，其他位按位取反。**
> 
> ![4319ef07fb0240d18ecb2e7eb4876037.png][]
> 
> **补码：反码的二进制 +1 就是补码。**
> 
> ![c5d81a570bea46fcbc344864329f8fed.png][]
> 
> 从例子中，我们可以看出**对于正的整数原码，反码，补码是相同的，无需计算；对于负的整数原码，反码，补码是需要进行计算的。**
> 
>  **整数在内存中存放的都是补码，整数在计算的时候也是用二进制进行计算。**

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

### 3.1 左移操作符 << ###

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

在常规的数字里面是不会出现特殊情况的，**一般地，在效果上，左移一位相当于乘2。**对于**正数**来说，还是对于**负数**来说，其实都一样，只是在一些特别大的数是不一样的，**基本都遵循：丢弃符号位，不管左边高位是什么，后面补的数字成为符号位。**

> 下面举个例子：
> 
> ![87b1e4c116c743e7a587947fe4fdd7db.png][]

###  ###

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

### 3.2 右移操作符 >> ###

小编先说一句：右移操作符比较难。首先**右移运算分为两种：1.逻辑右移；2.算术右移。**这两种主要的区别是：**关键看左边补什么**。

> **移位规则：1.逻辑移位：左边用0填充，右边丢弃；2.算术移位：左边用原该值的符号位填充，右边丢弃。**

同样地，在常规的数字里面是不会出现特殊情况的，**一般地，在效果上，右移一位相当于除以2。**对于**正数**来说，**遵循：丢弃右边一位，左边直接补0。**而对于**负数**来说，有两种情况，所以一般请先了解你所使用的编译器是哪种右移运算，方法在下面。**遵循：如果是算术右移：左边用原改制的符号位填充；如果是逻辑右移：左边补0。**

> 下面举个例子：
> 
> ![b9d3c4c27947483490f7ce178e88733d.png][]

**对于正整数来说，这两种右移操作都一样；而对于负整数来说，这两种右移操作不太一样，所以要重点来看负整数。**我们可以根据这个差异，编写一个代码看你们所使用的编译器支持哪种右移操作。**vs用的是算术右移，大部分编译器用的都是算术右移**。下面看代码：

#include <stdio.h>
    int main()
    {
    	int a = -10 >> 1;
    	if (a < 0)
    		printf("该编译器用的是算术右移!\n");
    	else
    		printf("该编译器用的是逻辑右移!\n");
    	return 0;
    }

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

### 3.3 警告 ###

> 对于移位操作符，不要移动负数位，这个是标准未定义的。看下图：
> 
> ![d08da408c6ad4e7fb7d589cd0996cb9e.png][]

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

## 四、位操作符（两个操作数） ##

![4c0fbb9f4cf94ce9b6855d5877ecdfe4.png][]

在初学C语言时，老师应该是不会讲这一部分的，起码我们老师没有讲，但**这一部分是非常重要的， 他在二进制的一些题目中有大作用。但大家不要将位操作符与逻辑操作符搞混！**下面，就由小编我来带领大家进行分开学习吧！

### **4.1 按位与 &** ###

> **运算规则：同时为1，才为1；一旦有0，则为0。**

我们**记住这个运算规则后进行计算**即可，下面进行代码讲解：

int main()
    {
    	int a = 7;
    	int b = -10;
    	int c = a & b;//按二进制的位与
    	//00000000 00000000 00000000 00000111 ----- 7的补码
    	//10000000 00000000 00000000 00001010
    	//11111111 11111111 11111111 11110101
        //*************************************
    	//*11111111 11111111 11111111 11110110*----- -10的补码
    	//*00000000 00000000 00000000 00000111*----- 7的补码
        //*************************************
    	//同1为1，有0则0
    	//00000000 00000000 00000000 00000110 ----- 6
    	printf("%d", c);
    	return 0;
    }

#### 按位与的具体应用： ####

如果我想得到某个数的二进制补码上某一位到底是1还是0，我们可以使用按位与运算进行得到。为什么呢？

**基本思路是：因为按位与的运算规则是：同1为1，有0则0。假如你想要求某个数的二进制补码上最后一位的数，你只需按位与上1(2^0)，则可以得出某个数的二进制补码上最后一位的数是什么，如果按位与上1等于1的话，最后一个数是1，如果是0，则最后一个数是0。同理，如果你想要求某个数的二进制补码上倒数第二位的数，你只需按位与上2(2^1)。**

> **题目一：**求某个数的二进制补码上某一位的数是什么？
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **方法：**由上面的基本思路可以总结出一个公式：如果你想要**求某个数的二进制补码上倒数第N位的数，你只需要用某个数按位与上2的(N-1)次方(2^(N-1))即可。**
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **代码：**
> 
>     int main()
>     {
>     	int num = 10;
>     	//如果想要求10的二进制补码中最后一位数
>     	int ans = num & 1;
>     	printf("ans = %d\n", ans);
>     	return 0;
>     }

> **题目二：** 求出某一个数的二进制补码的最后一个为1的位置的数。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **方法：**
> 
> ![29a1ff573d944278b6a448dbae9c1c07.png][]
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **代码：**
> 
>     int onlyone = eor & (~eor + 1);

### 4.2 按位或 | ###

> **运算规则：同时为0，才为0；一旦有1，则为1。**

这种运算是不需要进行讲解的，只要**记住运算规则就会做运算**，下面进行代码讲解：

int main()
    {
    	int a = 7;
    	int b = -10;
    	int c = a | b;//按二进制的位或
    	//00000000 00000000 00000000 00000111 ----- 7的补码
    	//10000000 00000000 00000000 00001010
    	//11111111 11111111 11111111 11110101
    	//*************************************
    	//*11111111 11111111 11111111 11110110*----- -10的补码
    	//*00000000 00000000 00000000 00000111*----- 7的补码
    	//*************************************
    	//同0为0，有1则1
    	// 11111111 11111111 11111111 11110111 补码
    	// 11111111 11111111 11111111 11110110 反码
    	// 10000000 00000000 00000000 00001001 原码 --- -9
    	printf("%d", c);
    	return 0;
    }

### **4.3 按位异或 ^**  ###

> **运算规则：相同为0，不同为1。****在这里提两个式子要记住：****a ^ a = 0;a ^ 0 = a。**
> 
> **性质：按位运算遵循交换律和结合律。**

虽然，按位异或的运算规则比较简单，但是以后还要学习一个**按位同或的运算规则：相同为1，不同为0。**所以，这两种运算容易搞混。

那怎么记按位异或呢？**按位异或——就是无进制相加。**怎么理解无进制相加呢？看下图：

![429c8d5355644e128d288256a35c009e.png][]

int main()
    {
    	int a = 7;
    	int b = -10;
    	int c = a ^ b;//按二进制的位异或
    	//00000000 00000000 00000000 00000111 ----- 7的补码
    	//10000000 00000000 00000000 00001010
    	//11111111 11111111 11111111 11110101
    	//*************************************
    	//*11111111 11111111 11111111 11110110*----- -10的补码
    	//*00000000 00000000 00000000 00000111*----- 7的补码
    	//*************************************
    	//相同为0，不同为1
    	// 11111111 11111111 11111111 11110001 补码
    	// 11111111 11111111 11111111 11110000 反码
    	// 10000000 00000000 00000000 00001111 原码 --- -15
    	printf("%d", c);
    	return 0;
    }

#### 按位异或的具体应用： ####

**一道很变态的面试题：**

> **题目一：**不能创建临时变量（第三个变量），实现两个数的交换。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **方法1：**先将a，b两个数进行相加赋给a，然后用a减去b赋给b，这样b中存的就是a，然后再用a减去b（b的值此时是a）赋给a，则a的值就是b的值了。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **代码：**
> 
>     int main()
>     {
>     	int a = 10;
>     	int b = 90;
>     	printf("交换前：a = %d, b = %d\n", a, b);
>     	//方法一：
>     	a = a + b;
>     	b = a - b;
>     	a = a - b;
>     	printf("交换后：a = %d, b = %d\n", a, b);
>     	return 0;
>     }
> 
> **缺陷：**如果变量的值非常大的话，就会出现数据截断。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **方法2：**用按位异或，根据**a ^ a = 0，a ^ 0 = a**，就可以得出。在这个过程中不会产生进位，则数据不会溢出。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **代码：**
> 
>     int main()
>     {
>     	int a = 10;
>     	int b = 90;
>     	printf("交换前：a = %d, b = %d\n", a, b);
>     	//方法二：
>     	a = a ^ b;
>     	b = a ^ b;
>     	a = a ^ b;
>     	printf("交换后：a = %d, b = %d\n", a, b);
>     	return 0;
>     }
> 
> **缺陷：**这个代码可读性不高，效率也不高。

> **题目二：** 给定一个数字arr，其中只有两个数字出现了奇数次，其它数字都出现了偶数次，按照从小到大顺序输出这两个数。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **方法：**先将这些数全部异或一下，可以得到出现奇数次的两个数的异或结果赋给eor，说明这两个数一定不相等，**而且eor的二进制中一定有一个位置是1，求出此位置为1的数（看4.1 按位与的具体应用）**，然后将数组里的数分成两个部分，一个部分是此位置为1的数，另一部分是此位置为0的数。那么这两个数就分开了，随便挑一组数据进行异或就可以求出一个数，再用eor异或就求出了另一个数。
> 
> **\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\***
> 
> **代码：**
> 
>     #include <stdio.h>
>     int main() 
>     {
>         int n = 0;
>         int eor = 0, eor1 = 0;
>         int temp = 0, ans = 0;
>         scanf("%d", &n);
>         int arr[100000];
>         for(int i = 0; i < n; i++)
>         {
>             scanf("%d", &arr[i]);
>         }
>         for(int i = 0; i < n; i++)
>         {
>             eor ^= arr[i];
>         }
>         int onlyone = eor & (~eor + 1);
>         for(int i = 0; i < n; i++)
>         {
>             if((onlyone & arr[i]) != 0)
>                 eor1 ^= arr[i];
>         }
>         ans = eor ^ eor1;
>         if(eor1 > ans)
>         {
>             temp = eor1;
>             eor1 = ans;
>             ans = temp;
>         }
>         printf("%d %d\n", eor1, ans);
>         return 0;
>     }

### 4.4 有关二进制位的练习 ###

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

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

## 五、赋值操作符 ##

![1234603019314d8c83fe8b1e05327624.png][]

赋值操作符是一个很棒的操作符，如果之前的值你不满意，使用这个操作符你可以给自己重新赋值。

> 举个例子：
> 
>     int weight = 120;//体重
>     weight = 80;//不满意就赋值
>     double salary = 100000.0;
>     salary = 200000.0; //使用赋值操作符赋值

> **赋值操作符可以连续使用，不过要从右向左依次执行。** 
> 
>     int a = 10;
>     	int x = 0;
>     	int y = 20;
>     	a = x = y + 1; //连续赋值，可读性不高
>     	//改进
>     	x = y + 1;
>     	a = x;//这样写更加清晰爽朗而且便于调试

### 复合赋值符 ###

>     +=
>     -=
>     *=
>     /=
>     %=
>     >>=
>     <<=
>     &=
>     |=
>     ^=
> 
> 这些运算符都可以写成复合的效果，**使代码更加整洁**。

> 举个例子：
> 
>     int x = 10;
>     	x = x + 10;
>     	x += 10; //这样写比较整洁

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

## 六、单目操作符（一个操作数） ##

### 6.1 单目操作符介绍 ###

![000c978475b840eeabffb2123a17dcc0.png][]

### 6.2 逻辑反操作符 ！ ###

> **运算规则：将真的变成假的，将假的变成真的。**

下面看使用场景：

int main()
    {
        int a = 0;
        if(!a)
            printf("hehe\n");
        return 0;
    }

### 6.3 取地址操作符 & 和解引用操作符 \* ###

取地址操作符是**将一个变量的地址取出来存放在p中**，解引用操作符是**通过p所存放的地址找到p所指向的对象。**

### 6.4 计算操作数的类型长度 sizeof ###

int main()
    {
    	int a = 10;
    	printf("%d\n", sizeof(a));
        printf("%d\n", sizeof a); //这种写法是正确的，证明了sizeof不是函数，函数后的括号省略不了
    	printf("%d\n", sizeof(int));
    	return 0;
    }

由上图代码可知，**sizeof既能计算变量的长度，也能计算类型长度。**此代码运行后，为什么会出现下图情况：

![020a618d2822411d96a004212e1eabc1.png][]

因为**sizeof计算的结果是size\_t类型的**，**size\_t是无符号整形的**，对size\_t类型的数据进行打印，**可以使用%zd**。 在一些古老的编译器是不支持%zd的，也**可以使用%u**。

### 6.5 ++ 和 -- 操作符 ###

> **运算规则：前置++（--）：先+（-）1，后使用；后置++（--）：先使用，后+（-）1。**

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

## 七、关系操作符（两个操作符） ##

![548d70ea1f6d4d6b9afacdff598dc48f.png][]

这些操作符比较简单，没有什么可以讲的，但是我们要注意一些运算符使用时候的陷阱。

> **警告：在编程的过程中 == 和 = 不小心写错，导致的错误。**

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

## 八、逻辑操作符（两个操作符） ##

![155550bdeb134bfd877cfa94ebda131e.png][]

### 8.1 逻辑与操作符 && ###

> **运算规则： 逻辑与就是并且，全真为真，有假即假。**

区分**逻辑与**和**按位与**

1 & 2  -------->0
    1 && 2 -------->1

### 8.2 逻辑或操作符 || ###

> **运算规则：逻辑或就是或者，全假为假，有真即真。**

区分**逻辑或**和**按位或**

1 | 2 -------->3
    1 || 2 ------->1

### 8.3 逻辑短路 ###

> **运算规则：&& 左边操作数如果为假，右边的运算式可以不算；|| 右边操作数如果为真，右边的运算式可以不算 。**

学到这个操作符后，我突然想到了我同学问我的一道题目：

![0b66f0f3ebf94f4bb8fbb80522d4f184.png][]

我刚看到这个题是有疑惑的，因为b和c选项感觉都是错的，其实并不是。因为c选项是涉及一些知识点是我不知道的，**因为有逻辑短路，在C语言中，我们进行运算的时候，我们需要进行优化代码，不让这个程序进行超负荷的运算。在程序中，因为，a||(b = c)是这个逻辑运算，为什么会有逻辑短路呢？为了减少程序的计算量，在进行这个逻辑运算的时候，C语言采用了在保持原逻辑运算正确的同时，通过已确定表达式的确切值的情况下，不计算后面的运算来简化运算。**

**在或运算中，如果a为真，后面的值不管是什么，我们都不需要进行计算，因为程序的结果已经知道了，就应该进行逻辑短路，**然后就不计算b = c,所以没有将c赋值给b, b还是等于原值。如果a为假，说明后面的结果可能会影响整个结果，所以就不能进行逻辑短路。

> **下面有一道笔试题：**
> 
> **题目：**
> 
>     int main()
>     {
>     	int i = 0, a = 0, b = 2, c = 3, d = 4;
>     	i = a++ && ++b && d++;
>     	printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c, d);
>     	return 0;
>     }
> 
> **答案：**
> 
> ![ce30520488f945b7baad34364ab29a05.png][]

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

## 九、条件操作符（三目操作符） ##

![ed56099d46804cbfb845a5d04e15ea65.png][]

我感觉这个操作符是用来简化代码的，具体看下面代码：

if (a > 5)
    	b = 3;
    else
    	b = -3;
    //等价于
    b = a > 5 ? 3 : -3;

**具体应用：**

> **题目：**使用条件表达式实现找两个数中的较大值
> 
> **方法：**利用条件表达式
> 
> **代码：**
> 
>     int main()
>     {
>     	int a = 90, b = 78;
>     	int ans = a > b ? a : b;
>     	printf("%d\n", ans);
>     	return 0;
>     }

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

## 十、逗号表达式 ##

![38d0c6b4eafe4173ae10ab431448715e.png][]

> **运算规则：从左向右依次执行计算，整个表达式的结果是最后一个表达式的结果，前面的计算可能会影响后面的结果。**

下面看使用场景：

a = get_val();
    	couny_val(a);
    	while (a > 0)
    	{
    		//业务处理
    		a = get_val();
    		couny_val(a);
    	}
    	//如果使用逗号表达式，改写：
    	while (a = get_val(), couny_val(a), a > 0)
    	{
    		//业务处理
    	}

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

## 十一、下标引用、函数调用和结构成员 ##

### 11.1 \[ \]下标引用操作符（两个操作数） ###

> **操作数：一个数组名 + 一个索引值**

int arr[10]; //创建数组
    arr[9] = 10; //使用下标引用操作符
    [ ]的两个操作数是arr和9。

### 11.2 （ ）函数调用操作符（至少一个操作数） ###

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

### 11.3 访问一个结构的成员 ###

> **. 结构体.成员名**
> 
> **-> 结构体指针->成员名**

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

## 总结 ##

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

[C_C]: http://t.csdn.cn/Rt8VK
[Link 1]: http://t.csdn.cn/pTO5k
[C]: http://t.csdn.cn/R6aDv
[C 1]: http://t.csdn.cn/z7pdJ
[55736390edc9430f89ee592b2fba42c0.png]: https://img-blog.csdnimg.cn/55736390edc9430f89ee592b2fba42c0.png
[d77d4af77da74c0aa452a442ed9f7808.png]: https://img-blog.csdnimg.cn/d77d4af77da74c0aa452a442ed9f7808.png
[aa51aa6ba4fa4838803d8e26539115b6.png]: https://img-blog.csdnimg.cn/aa51aa6ba4fa4838803d8e26539115b6.png
[3abfc1a264bb418fa53870ce356dfa9e.png]: https://img-blog.csdnimg.cn/3abfc1a264bb418fa53870ce356dfa9e.png
[bb513a309b1343edaa9eebb80dde03ba.png]: https://img-blog.csdnimg.cn/bb513a309b1343edaa9eebb80dde03ba.png
[4319ef07fb0240d18ecb2e7eb4876037.png]: https://img-blog.csdnimg.cn/4319ef07fb0240d18ecb2e7eb4876037.png
[c5d81a570bea46fcbc344864329f8fed.png]: https://img-blog.csdnimg.cn/c5d81a570bea46fcbc344864329f8fed.png
[87b1e4c116c743e7a587947fe4fdd7db.png]: https://img-blog.csdnimg.cn/87b1e4c116c743e7a587947fe4fdd7db.png
[b9d3c4c27947483490f7ce178e88733d.png]: https://img-blog.csdnimg.cn/b9d3c4c27947483490f7ce178e88733d.png
[d08da408c6ad4e7fb7d589cd0996cb9e.png]: https://img-blog.csdnimg.cn/d08da408c6ad4e7fb7d589cd0996cb9e.png
[4c0fbb9f4cf94ce9b6855d5877ecdfe4.png]: https://img-blog.csdnimg.cn/4c0fbb9f4cf94ce9b6855d5877ecdfe4.png
[29a1ff573d944278b6a448dbae9c1c07.png]: https://img-blog.csdnimg.cn/29a1ff573d944278b6a448dbae9c1c07.png
[429c8d5355644e128d288256a35c009e.png]: https://img-blog.csdnimg.cn/429c8d5355644e128d288256a35c009e.png
[1234603019314d8c83fe8b1e05327624.png]: https://img-blog.csdnimg.cn/1234603019314d8c83fe8b1e05327624.png
[000c978475b840eeabffb2123a17dcc0.png]: https://img-blog.csdnimg.cn/000c978475b840eeabffb2123a17dcc0.png
[020a618d2822411d96a004212e1eabc1.png]: https://img-blog.csdnimg.cn/020a618d2822411d96a004212e1eabc1.png
[548d70ea1f6d4d6b9afacdff598dc48f.png]: https://img-blog.csdnimg.cn/548d70ea1f6d4d6b9afacdff598dc48f.png
[155550bdeb134bfd877cfa94ebda131e.png]: https://img-blog.csdnimg.cn/155550bdeb134bfd877cfa94ebda131e.png
[0b66f0f3ebf94f4bb8fbb80522d4f184.png]: https://img-blog.csdnimg.cn/0b66f0f3ebf94f4bb8fbb80522d4f184.png
[ce30520488f945b7baad34364ab29a05.png]: https://img-blog.csdnimg.cn/ce30520488f945b7baad34364ab29a05.png
[ed56099d46804cbfb845a5d04e15ea65.png]: https://img-blog.csdnimg.cn/ed56099d46804cbfb845a5d04e15ea65.png
[38d0c6b4eafe4173ae10ab431448715e.png]: https://img-blog.csdnimg.cn/38d0c6b4eafe4173ae10ab431448715e.png