C：操作符介绍-学习笔记

引言：

1、操作符的分类：

2、原码，反码，补码

2.1 介绍

2.2 作用

3、移位操作符：>>、 <<

3.1 左移操作符：<<

3.1.1 正整数移动

3.1.2 负整数移动

3.2 右移操作符：>>

3.3 一些总结

4、位操作符：&、|、^、~

4.1 按位与：&

4.2 按位或： |

4.3 按位异或：^

4.4 按位取反： ~

5、逗号表达式：,

6、下标访问[ ]、函数调用()

6.1 下标引用操作符: [ ]

6.2 函数调用操作符：()

7、算数操作符：+、-、*、/、%

7.1 + 和 -

7.2 *

7.3 /

7.4 %

8、赋值操作符:=和复合赋值

8.1 连续赋值

8.2 复合赋值法

8.2.1 += 、 -=

8.2.2 *= 、 /= 、 %=

8.2.3 >>= <<=

8.2.4 &= |= ^=

1、按位与（&=）&符号名为按位与

2、按位或 ( |=)

3、按位异或：^=

9、单目操作符：++、--、+、- 、sizeof(类型）

9.1 ++和--

9.1.1 前置++

9.1.2 后置++

9.1.3 前置--

9.1.4 后置--

9.2 +、 -

9.3 sizeof 操作符

补充 size_t

10、逻辑操作符：!、&&、||

10.1 逻辑取反运算符！

10.2 逻辑与运算符 &&

10.3 逻辑或运算符 ||

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

11.1 优先级

11.2 结合性

结语：

引言：

本篇文章将为您带来C语言操作符的全面解析，您可以将其视为操作符的百科全书。无论您对哪个操作符的使用有所遗忘，都可以在这里找到所需的知识，让您的编程之路更加顺畅。

注意：本篇文章需要使用到二进制的知识，如果有对二进制不太清楚的，可以点下面链接先看一看，相信对您会有点帮助的！！！

二、八、十、十六进制介绍及相互转换-CSDN博客

1、操作符的分类：

移位操作符：>>、 <<
位操作符：&、|、^、~
逗号操作符：,
下标引用：[ ]
函数调用：()
算术操作符：+、 -、 * 、/、 %
赋值操作符：=、+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=
单目操作符：++、--、&、*、+、-、~、sizeof(类型)
关系操作符：>、>=、<、<=、==、、!=
逻辑操作符：&&、||、！
条件操作符：? :
结构成员访问： .

2、原码，反码，补码

2.1 介绍

整数的2进制表示方法有三种，即是原码，反码和补码。

有符号的整数的三种表示方法均有符号位和数值位两部分，2进制序列中，最高位的1位是被当作符号位，剩余的都是数值位。

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

举个例子：int a = -15 int b =10

符号位	数值位
1	0000000000000000000000000001111
0	0000000000000000000000000001010

一个整型是4个字节，一个字节又有8个bit位，因此，当整数想放到a或b里面，就需要有32个bit位

正整数的原，反，补码都相同。负整数的三种表示方法各不相同。

原码：根据数值正负的情况，直接写出翻译成2进制序列，得到的就是原码；

反码：符号位不变，其他位置按位取反；按位取反就是0变为1，1变为0；

补码：反码+1就是补码。

int a = -15

1 0000000000000000000000000001111 原码

1 1111111111111111111111111111110000 反码（符号位不变，按位取反）

1 1111111111111111111111111111110001 补码（反码+1)

补码得到原码也是可以使用：取反+1的操作得到。

2.2 作用

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

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

图理关系：（感觉图片怪怪的）

3、移位操作符：>>、 <<

<< 左移操作符

>> 右移操作符

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

3.1 左移操作符：<<

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

注：左移移动的是2进制序列。

3.1.1 正整数移动

#include <stdio.h>
int main()
{
	int n = 10;
	int m = n << 1;    //把n向左移动一位(右边数字是多少，就移动多少位)
	printf("%d", m);
	return 0;
}

移动的效果展示：

如上图，左移一位后结果变为00000000000000000000000000010100

此时的 m = 20，代码结果展示：

从上图我们还能知道：移动后原来的值（n）是不会改变的

比如说：int n = 10;

int m = n + 1;

n原来是10，+1后的表达式结果11赋给m，但n本身是不会改变的。

上面的左移操作符亦是如此。

3.1.2 负整数移动

#include <stdio.h>
int main()
{
	int n = -10;
	int m = n << 1;    //把n向左移动一位(右边数字是多少，就移动多少位)
	printf("%d", m);
	return 0;
}

正整数的原反补码相同，因此我们直接写出来的2进制序列就是正整数的补码，但是负整数不同，因此，我们需要先将原码改写成补码。

10000000000000000000000000001010 -10的原码

111111111111111111111111111111110101 -10的反码（符号位不变，其它按位取反）

111111111111111111111111111111110110 -10的补码（+1，满2进1）

得到补码后，我们开始进行左移操作

11111111111111111111111111110110 //移动前

111111111111111111111111111101100 //向左移动一位

舍去前面多出来的1，并在后面的空位补上0，因此最后得到的补码是

11111111111111111111111111101100 //左移1位后的补码

10000000000000000000000010011 //左移一位后的反码（取反）

10000000000000000000000010100 //左移一位后的原码（+1）

该结果等于 -20

3.2 右移操作符：>>

移动规则：右移运算分两种：

逻辑右移：左边用0填充，右边丢弃
算术右移：左边用原该值的符号位填充，右边丢弃负数用1填充，正数用0填充。

关于右移运算，是根据编译器来看的，编译器使用的是哪种那你计算就是哪种，在VS上，编译器支持的是算术右移。大部分编译器采用的就是算术右移。

闲言碎语：小编觉得逻辑右移一点也没有逻辑，逻辑右移不管是正整数还是负整数都用0填充，负数都给搞成了正数。

注：后面所展示的右移操作符运算都按照算术右移的移动规则。

#include <stdio.h>
int main()
{
	int n = -10;
	int m = n >> 1;    //把n向右移动一位(右边数字是多少，就移动多少位)
	printf("%d", m);
	return 0;
}

10000000000000000000000000001010 -10的原码

111111111111111111111111111111110101 -10的反码（符号位不变，其它按位取反）

111111111111111111111111111111110110 -10的补码（+1，满2进1）

得到补码后，我们开始进行右移操作

111111111111111111111111111111110110 右移前的补码

111111111111111111111111111111110110 向右移动一位

由于是负整数，因此左边空缺补上1，右边0舍去，得到

111111111111111111111111111111111011 右移后的补码

10000000000000000000000000000100 右移后的反码

10000000000000000000000000000101 右移后的原码

移动后的结果是 m = -5

正整数右移和左移基本相同。就跳过了！

3.3 一些总结

左移一位有 ×2 的效果，右移一位有 ÷2 的效果
移动可以一下移动多位，但是要注意不要移动的位置超过总数，要选择适当的位数移动。
移动的位数只能是正整数，不能出现 a>>-3 这种情况
移动几位补几位，如果是负整数，左边都用1填充。

4、位操作符：&、|、^、~

位操作符有：
1 & //按位与

2 | //按位或

3 ^ //按位异或

4 ~ //按位取反

这里位是指二进制位，因此使用这些操作符一定要先写成二进制位的表示i形式才能参与计算

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

4.1 按位与：&

#include <stdio.h>
int main()
{
	int a = -10;
	int b = 13;
	int c = a & b;   //按位与，指的是对应的二进制位与运算
	printf("%d", c);
	return 0;
}

我们需要先得到 a 和 b 的补码

a

10000000000000000000000000001010 原码

111111111111111111111111111111110101 反码（符号位不变，其它按位取反）

111111111111111111111111111111110110 补码（+1，满2进1）

b

00000000000000000000000000001101 补码（正整数的三种相同）

得到 a 和 b 的补码后，我们可以开始计算了

111111111111111111111111111111110110 // a的补码

00000000000000000000000000001101 // b的补码

c = a & b

00000000000000000000000000000100 // 与后的结果： c的补码

大家能看出是怎么计算的吗？

对应的位置有0则为0，两个同时为1结果才为1

图释：

最终结果为：c = 4

4.2 按位或： |

#include <stdio.h>
int main()
{
	int a = -10;
	int b = 10;
	int c = a | b;  //按位或，指的是对应的二进制位或运算
	printf("%d", c);
	return 0;
}

先求a和b的补码（这里a的补码就不在重新求一遍了，我直接从上面拿下来了）

111111111111111111111111111111110110 // a的补码

00000000000000000000000000001010 // b的补码

c = a | b

111111111111111111111111111111111110 // 或后的结果：c的补码

按位与 | 的运算规律：有1则为1，全0才为0

得到的C是负数，因此取反+1后得到原码得到结果

10000000000000000000000000000010

最终结果为：c = -2

4.3 按位异或：^

#include <stdio.h>
int main()
{
	int a = -10;
	int b = 13;
	int c = a ^ b;  //按位异或，指的是对应的二进制位异或运算
	printf("%d", c);
	return 0;
}

a的补码求解在4.1里，这里我直接用了

111111111111111111111111111111110110 // a的补码

00000000000000000000000000001101 // b的补码

c = a ^ b

111111111111111111111111111111111011 // 异或后的结果：c的补码

按位异或^ 的运算规律：相同为0，相异为1

对应位置如果相同的话，就是0，不同的话就是1。

c的原码取反+1

10000000000000000000000000000100 //取反

10000000000000000000000000000101 //+1 c的原码

最终结果为： c = -5

4.4 按位取反： ~

#include <stdio.h>
int main()
{
    int a = 0;
	printf("%d", ~a);// ~a就是对a按位取反
	return 0;
}

按位取反就是原来是0改为1，原来是1改为0

a的补码：00000000000000000000000000000000

~a的补码：11111111111111111111111111111111

~a的反码：1000000000000000000000000000

~a的原码：1000000000000000000000000001

因此，打印的结果为 -1

5、逗号表达式：,

ex1,ex2,ex3,ex…

逗号表达式，就是使用逗号隔开的表达式。

特点：

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

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
    printf("%d",c);
	return 0;
}

表达式结果：

我们最终打印出来的结果就是最后一个表达式的结果，但是，我们不能够只算最后一个表达式，因为前面的表达式是可以影响后面的表达式的。向这道题第二个表达式a = b + 10就改变了a的值，从而影响了b = a + 1 的最终结果。

逗号表达式可以减少一些重复的代码

 a = get_val();
 count_val(a);
 while (a > 0)
 {
 //业务处理 
 //...
 a = get_val();
 count_val(a);
 }

比如上面的代码中就有一些重复的，我们可以使用逗号将表达式改写

while (a = get_val(), count_val(a), a>0)
 {
 //业务处理 
 }

这样是不是看着就好多了？

6、下标访问[ ]、函数调用()

6.1 下标引用操作符: [ ]

操作数：一个数组名 + 一个索引值（下标）

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6 };
	printf("%d\n", arr[5]);  
	return 0;
}

[ ]是一个操作符
操作数 arr 和 5，缺一不可

注意：使用下标引用操作符时，一定要确保索引值在有效范围内，否则可能导致访问越界错误。

6.2 函数调用操作符：()

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

#include <stdio.h>
int main()
{
	printf("hehe\n");
	return 0;
}

printf是一个函数 , ()这个括号就是函数调用操作符。

int add(int a, int b)
{
}
#include <stdio.h>
int main()
{
	printf("hehe\n");//操作数有 printf,"hehe"
	add(1,2);
	return 0;
}

这里的add()表示函数调用，()就是函数调用操作符

函数调用操作符的操作数是不固定的，但都有函数名，传参值根据情况而定

()操作数是 add , 1 , 2

但是函数调用操作符至少有一个操作数，就是函数名。

7、算数操作符：+、-、*、/、%

7.1 + 和 -

+ 和 - 用来完成加法和减法。
+ 和 - 都是有2个操作数的，位于操作符两端的就是它们的操作数，这种操作符也叫双目操作符。

 #include <stdio.h>
 int main()
{
  int a = 1;
  int b = 2;
  int c = a + b ;
  int b = a - b ;
  printf("%d",c);
  return θ;
}

7.2 *

运算符 * 用来完成乘法。

1 #include <stdio.h>
2 int main()
3 {
4    int num = 5;
5    printf("%\n",num * num); //输出25
6    return 0;
7 }

7.3 /

运算符/用来表示除法。

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

1 #include <stdio.h>
2 int main()
3 {
4 float x=6/ 4；
5 int y=6/4；
6 printf("%f\n"，x)；// 输出 1.00000
7 printf("%d\n”,y)；// 输出1
8 return 0;
9 }

上面示例中，尽管变量 × 的类型是float (浮点数)，但是6 / 4 得到的结果是 1.θ，而不是 1.5。原因就在于C语言里面的整数除法是整除，只会返回整数部分，丢弃小数部分。

如果希望得到浮点数的结果，两个运算数必须至少有一个浮点数，这时C语言就会进行浮点数除法。

7.4 %

运算符%表示求模(余)运算，即返回两个整数相除的余值。这个运算符只能用于整数，不能用于浮点数。

1 #include <stdio.h>
2 int main()
3 {
4   int x =6 % 4; //2
5   return 0;
6 }

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


1 #include (stdio.h)
2 int main()
3 {
4  printf("%d\n"，11 % -5);  //1
5  printf(“%d\n", -11 % -5); //-1 
6  printf("%d\n", -11 % 5);  //-1
7  return 0;
8 }

上面示例中，第一个运算数的正负号(11或-11)决定了结果的正负号。

8、赋值操作符:=和复合赋值

在变量创建的时候给一个初始值叫初始化，在变量创建好后，再给一个值，这叫赋值。

1 int a = 100; //初始化
2 a = 100; //赋值，这里使用的就是赋值操作符

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

8.1 连续赋值

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

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

虽然C语言支持这种连续赋值，但是写出的代码不容易理解，建议还是才开来写，这样方便观察代码的执行细节。

1 int a = 3;
2 int b = 5;
3 int c = 0;
4 b= a+3;
5 c = b;

这样写，在调试的时候，每一次赋值的细节都是可以很方便的观察的。

8.2 复合赋值法

在写代码的时候，我们经常可能会对一个数进行自增，自减的操作

代码演示：

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

这样写代码C语言给提供了更加方便的写法：

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

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

1 +=      -+
2 *=      /=     %=
3 >>=     <<=
4 &=      |=     ^=

8.2.1 += 、 -=

1 int a = 10;
2 a+=20; => a = a+20 //此时得出的结果是a等于30
3
4 a-=10; => a = a-10 //此时得出的结果是a等于0

**8.2.2 *= 、 /= 、 %=**

1 int a =10;
2 a*=3 => a = a * 3  //a的结果是30
3 a/=2 => a = a / 2  //a的结果是5
4 a%=3 => a = a % 3  //a的结果是1（求余数）

8.2.3 >>= <<=

右移赋值 :a >>= b 表示将变量a的二进制表示向右移动b位，并用0填充空缺的位置，如果a是一个正数，这相当于除以2的b次方。对于负数，结果会有所不同，取决于具体的实现。举个例子，假设我们有一个八位二进制数a = 0b10101010（十进制为140），如果我们执行a = a >> 2，这相当于清除最右边的两位并左移0进去，结果就是 0b10100000（十进制为64）。这个操作可以用于处理位标志、压缩数据等场景。

左移赋值： a<<=b它的作用是将一个数的二进制形式向左移动指定的位数，并将左边多出来的位数用0补齐，然后将结果赋值给这个数。举个例子，如果x的二进制为0000 1000，执行x <<= 3后，x的二进制变为0100 0000，也就是十进制数值变为64。

8.2.4 &= |= ^=

1、按位与（&=）&符号名为按位与

二元运算符&通过逐位比较两个运算对象，生成一个新值。对于每个位，只有两个运算对象中相应的位都为1时，结果才为1（从真/假方面看，只有当两个位都为真时，结果才为真）。

1 (010010) & (100010) //表达式
2 (000010)            //结果值

&= 用法

1 val &= 0234;
2 val = val & 0234;
3  //以上两种等同

2、按位或 ( |=)

二元运算符|，通过逐位比较两个运算对象，生成一个新值。对于每个位，如果两个运算对象中相应的位为1，结果就为1（从真/假方面看，如果两个运算对象中相应的一个位为真或两个位都为真，那么结果为真）。

1 (1001001) | (0100101)  //表达式
2 (1101101)              //结果式
3  
4  val &= 05234;
5  val = val & 05234;
6  //效果等同

3、按位异或：^=

二元运算符^逐位比较两个运算对象。如果两个运算对象中相应的位一个为1（只有一个1），结果为1（从真/假方面看，如果两个运算对象中相应的一个位为真且不是两个同为1，那么结果为真）。任何数与0异或都为本身。

1 (10010011) ^(00111101)    //表达式
2 (10101110)                //结果值
3 //效果相同
4 val ^= 05234;
5 val = val ^ 05234;

9、单目操作符：++、--、+、- 、sizeof(类型）

前面介绍的操作符都是双目操作符，有2个操作数的。C语言中还有一些操作符只有一个操作数，被称为单目操作符。++、--、+(正)、-(负)就是单目操作符的。

9.1 ++和--

++是一种自增的操作符，又分为前置++和后置++，--是一种自减的操作符，也分为前置--和后置--.

9.1.1 前置++

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

计算口诀：先+1，后使用；

9.1.2 后置++

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

计算口诀：先使用，后+1；

9.1.3 前置--

计算口诀：先-1，后使用；

9.1.4 后置--

计算口诀：先使用，后-1；

和++相同，就不再举例说明了。

关于++、-- 我们只需要掌握以上使用方法就可以了。

9.2 +、 -

比较简单，就直接代码演示了

9.3 sizeof 操作符

sizeof 是一个关键字，也是操作符，专门是用来计算sizeof的操作符数的类型长度的，单位是字节。（后面会介绍什么是字节）
sizeof 操作符的操作数可以是类型，也可是变量或者表达式。

1 sizeof (类型)
2 sizeof 表达式

sizeof的操作数如果不是类型，是表达式的时候，可以省略掉后边的括号的。
sizeof 后边的表达式是不真实参与运算的，根据表达式的类型来得出大小。
sizeof 的计算结果是size_t类型的。

sizeof 运算符的返回值，C语言只规定是无符号整数，并没有规定具体的类型，而是留给系统自己去决定，sizeof到底返回什么类型。不同的系统中，返回值的类型有可能是unsigned int，也有可能是unsigned long，甚至是 unsigned long long，对应的 printf() 占位符分别是 u%、%1u和%11u。这样不利于程序的可移植性。
C 语言提供了一个解决方法，创造了一个类型别名 size_t，用来统一表示 sizeof 的返回值类型。对应当前系统的 sizeof 的返回值类型，可能是 unsigned int，也可能是 unsigned long long。

补充 size_t

size_t --- 是一种类型，是专门为sizeof 设计的就是sizeof返回值的类型
size_t 其实是一种无符号的整型
unsigned ...

sizeof 的返回值的类型可能是：
unsigned int %u
unsigned long %lu
unsigned long long %llu

由于种类太多，导致在写代码的时候不太方便，便统一使用size_t代替，占位符为%zd

比如：

1 #include <stdio.h>
2
3 int main ()
4 {
5   int a=10;
6   printf("%zd\n,sizeof(a));
7   printf("%zd\n,sizeof(a));//a是变量的名字，可以省略掉sizeof后边的()
8   printf("%zd\n,sizeof(int));
9   printf("%zd\n,sizeof(3=3.5));
10  return 0;
11 }

10、逻辑操作符：!、&&、||

逻辑运算符提供逻辑判断功能，用于构建更复杂的表达式，主要有下面三个运算符。

•!：逻辑取反运算符(改变单个表达式的真假)。

• &&：逻辑与运算符，就是并且的意思(两侧的表达式都为真，则为真，否则为假)。

•||：逻辑或运算符，就是或者的意思(两侧至少有一个表达式为真，则为真，否则为假)。

| 注：C语言中，非0表示真，0表示假

10.1 逻辑取反运算符！

a	!a
非0（真）	0（假）
0（假）	1（真）

比如说，我们有一个变量 flag ，如果flag为假，要做一个什么事情，就可以这样写代码：

 #include <stdio.h>
 int main()
 {
    int flag = 0;
    if ( !flag )                   
    {
        printf("do something\n");
    }
      return 0;
 }

如果 flag 为真，！flag就是假，如果 flag 为假，！flag就是真

因此上面代码的意思就是：flag为假，！flag为真，执行if语句中的代码。

10.2 逻辑与运算符 &&

逻辑与运算符
a	b	a&&b
非零	非零	1
非零	0	0
0	非零	0
0	0	0

&& 就是 与运算符，也是并且的意思，&& 是一个双目操作符，使用的方式是 a&&b ，&& 两边的表达式都是真的时候，整个表达式才为真，只要有一个是假，则整个表达式为假。

四字口诀：一假全假（只要有一个是假的，这个表达式就是假的。）

例如：如果我们说月份3月到五月，是春天，那使用代码该怎么表示呢？

 int month = 0;
 scanf("%d",&month);
 if(month >= 3 && month <= 5);//表达式
 {
    printf("春季\n");
 }

这里表达式的意思就是month既要大于等于3 ，又要小于等于5，且必须同时满足。

只要其中有一个不成立，都不能得到想要结果，假如month大于等于2，则结果不成立；或者month小于等于6，结果也不成立。一假全假。

10.3 逻辑或运算符 ||

**逻辑或运算符**
a	b	a\|\|b
非0（真）	非0	1
非0	0（假）	1
0	非0	1
0	0	0

|| 就是或运算符，也就是或者的意思，|| 也是一个双目操作符，使用的方式是 allb ，两边的表达式
只要有一个是真，整个表达式就是真，两边的表达式都为假的时候，才为假。

四字口诀：一真全真（只要有一个是真的，表达式就是真的）

例如：我们说一年中月份是12月或者1月或者2月是冬天，那么我们还怎么使用代码体现呢？

 int month = 0;
 scanf("%d",&month);
 if(month == 12 || month == 1 || month == 2));//表达式
 {
    printf("冬季\n");
 }

这里表达式的意思是在12月、 1月、2 月中，只要有一个是真（即是冬季）表达式都成立。

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

C语言的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。

11.1 优先级

优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不⼀样的。

3 + 4 * 5

上面例子中，表达式3 + 4 * 5里既有加法运算符，又有乘法运算符，由于乘法的优先级高于加法，所以会先计算4 * 5，而不是先计算3 + 4。

相邻的两个运算符，优先级高的先计算。

11.2 结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（ = ）。

5 * 6 / 2

上面例子中，表达式 * 和 / 的优先级是相同的，它们都是左结合运算符，所以从左到右执行，先计算5 * 6，再计算 / 2。

运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从高到低排列）

圆括号（ () ）
自增运算符（++），自减运算符（--）
单目操作符（+ 和 -）
乘法（*），除法（/）
加法（+），减法（-）
关系操作符（<、>等）
赋值操作符（=）

上面这些记住就可以了，其它的使用时查表就行。

C 运算符优先级 - cppreference.com

结语：

本篇文章到这里就结束了，基本上C语言相关的操作符都梳理了一遍，关于结构成员访问操作符会在后面小编学习后补上。希望大家能够在这里面找到你所要的知识！！！