C：操作符介绍-学习笔记
JonlyMay 2024-08-18 15:35:01 阅读 79
目录
引言：
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 正整数移动
<code>#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 负整数移动
<code>#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填充，负数都给搞成了正数。
注：后面所展示的右移操作符运算都按照算术右移的移动规则。
<code>#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 按位与：&
<code>#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 按位或： |
<code>#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 按位异或：^
<code>#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 按位取反： ~
<code>#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…
逗号表达式，就是使用逗号隔开的表达式。
特点：
逗号表达式，从左向右依次执行。整个表达式的结果是最后⼀个表达式的结果
<code>#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 的最终结果。
逗号表达式可以减少一些重复的代码
<code> 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 %
运算符%表示求模(余)运算，即返回两个整数相除的余值。这个运算符只能用于整数，不能用于浮点数。
<code>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 后置++
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 操作符的操作数可以是类型，也可是变量或者表达式。
<code>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为假，要做一个什么事情，就可以这样写代码：
<code> #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月到五月，是春天，那使用代码该怎么表示呢？
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月是冬天，那么我们还怎么使用代码体现呢？
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语言相关的操作符都梳理了一遍，关于结构成员访问操作符会在后面小编学习后补上。希望大家能够在这里面找到你所要的知识！！！
声明
本文内容仅代表作者观点，或转载于其他网站，本站不以此文作为商业用途
如有涉及侵权，请联系本站进行删除
转载本站原创文章，请注明来源及作者。