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     右移前的补码

  11111111111111111111111111111111011   向右移动一位

由于是负整数,因此左边空缺补上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 后置++

<code>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 操作符的操作数可以是类型,也可是变量或者表达式。

<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月到五月,是春天,那使用代码该怎么表示呢?

<code> 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月是冬天,那么我们还怎么使用代码体现呢?

<code> 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语言相关的操作符都梳理了一遍,关于结构成员访问操作符会在后面小编学习后补上。希望大家能够在这里面找到你所要的知识!!!



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。