5.C语言常见运算符及其优先级

运算符

用算术运算符将运算对象（也称操作数）连接起来的、符合C语言规则的式子，称为C算术表达式。运算对象包括常量、变量、函数等。
例如：a * b / c - 1.5 + ‘a’

运算符的分类

1.双目运算符：即参加运算的操作数有两个
例：a + b

2.单目运算符：参加运算的操作数只有一个
例：++自增运算符
- -自减运算符
int a =10;
a++;

3.三目运算符：即参加运算的操作数有三个
例：条件运算符 () ? () : ()

1.算术运算符

+ , - , * , / ,% , += , -= , *= , /= , %=

10%3 表达式结果为1
复合运算符：
a += 3 相当于a=a+3
a *= 6+8 相当于 a=a*(6+8)

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 0;
	c = a + b;
	printf("c=%d\n", c);

	c = 10 % 3;
	printf("c=%d\n", c);

	a += 3;
	printf("a=%d\n", a);

	b += 2 * 8;
	printf("b=%d\n", b);
	return 0;
}

2.关系运算符

> , < , == , >= , <= , !=

一般用于判断条件是否满足或者循环语句

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int i;
	if (a > b)
	{
		printf("a>b\n");
	}
	if (a < b)
	{
		printf("a<b\n");
	}
	for (i = 0; i <= 100; i++)
	{
		printf("i=%d\n", i);
	}
	return 0;
}

3.逻辑运算符

1. && 逻辑与
   两个条件都为真，则结果为真
   if ( (a>b) && (a<c) )
   注意：if (b < a < c) 这种表达方式是错误的

2. || 逻辑或
   两个条件至少有一个为真，则结果为真
   if ( (a>b) || (a<c) )

3. ! 逻辑非
   if ( !(a>b))
   {
   }

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	if ((a < b) && (b > c))
	{
		printf("条件为真！\n");
	}
	else {
		printf("条件为假！\n");
	}
	if ((a < b) || (b > c))
	{
		printf("逻辑或的结果为真！\n");
	}
	if (!(a > b))
	{
		printf("逻辑非条件成立！\n");
	}
	return 0;
}

4.位运算符

十进制数转二进制数

123 / 2 = 61 余1
61 / 2 = 30 余1
30 / 2 = 15 余0
15 / 2 = 7 余1
7 / 2 = 3 余1
3 / 2 = 1 余1
1 / 2 = 0 余1
123 的二进制为 111 1011

原码反码补码
正数在内存中以原码形式存放，负数在内存中以补码的形式存放

正数：原码=反码=补码

原码：将一个整数，转换成二进制，就是其原码。
如单字节的5的原码为：0000 0101；-5的原码为 1000 0101。

反码：正数的反码就是其原码；负数的反码就是将原码中，除符号位以外，每一位取反。

如单字节5的反码为：0000 0101；-5的反码为 1111 1010。
补码：正数的补码就是其原码；负数的反码+1就是补码。
如单字节5的补码为：0000 0101； -5的补码为 1111 1011。
在计算机中，正数是直接用原码表示的，负数用补码表示。

#include<stdio.h>
int main()
{
	printf("%x\n",-5);
	return 0;
}
//1000 0000 0000 0000 0000 0000 0000 0101 -5的原码
//1111 1111 1111 1111 1111 1111 1111 1010 -5的反码
//1111 1111 1111 1111 1111 1111 1111 1011 -5的补码
// ff ff ff fb

位运算
无论正数还是负数，编译系统都是按照内存中存储的内容进行位运算。

1. & 按位与
   任何值与0得0，与1保持不变
   使某位清零
   -5 & 10
   1111 1111 1111 1111 1111 1111 1111 1011
   0000 0000 0000 0000 0000 0000 0000 1010
   0000 0000 0000 0000 0000 0000 0000 1010

2. | 按位或
   任何值或1得1，或0保持不变
   -5 | 10
   1111 1111 1111 1111 1111 1111 1111 1011
   0000 0000 0000 0000 0000 0000 0000 1010
   1111 1111 1111 1111 1111 1111 1111 1011

3. ~ 按位取反
   0变1,1变0
   ~（-5）
   1111 1111 1111 1111 1111 1111 1111 1011
   0000 0000 0000 0000 0000 0000 0000 0100

#include<stdio.h>
int main()
{
	printf("%x\n",-5 & 10);//0000 0000 0000 0000 0000 0000 0000 1010
	printf("%x\n", -5 | 10);//1111 1111 1111 1111 1111 1111 1111 1011
	printf("%X\n", ~(-5));// 0000 0000 0000 0000 0000 0000 0000 0100
	return 0;
}
//1000 0000 0000 0000 0000 0000 0000 0101 -5的原码
//1111 1111 1111 1111 1111 1111 1111 1010 -5的反码
//1111 1111 1111 1111 1111 1111 1111 1011 -5的补码
// ff ff ff fb

4. ^ 按位异或
   相异得1，相同得0
   1001 1100
   0101 1010
   - - - - - - - - -
   1100 0110

5. 位移
   >> 右移
   << 左移
   注意右移分：逻辑右移、算术右移
   (1) 右移
   逻辑右移：高位补0，低位溢出
   0101 1010 >>3
   0001 1011
   算术右移：高位补符号位，低位溢出（有符号位）
   1010 1101 >>3
   11110 1011

在一个编译系统中到底是逻辑右移还是算术右移，取决于编译器。

//判断右移是逻辑右移还是算术右移
#include<stdio.h>
int main()
{
	printf("%d\n", (-1) >> 3);
	return 0;
}// 1000 0000 0000 0000 0000 0000 0000 0001
// 1111 1111 1111 1111 1111 1111 1111 1111

(2) 左移 << 高位溢出，低位补0
5 << 1
0000 0101
0000 1010

5.条件运算符

() ? () : ()

A ? B : C
如果？前面的表达式成立，整个表达式的值是？和 : 之间的表达式的结果
否则是之后表达式的结果

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

6.逗号运算符

() , ()
逗号运算符的结果是后边表达式的结果。

int main()
{
	int num;
	num = ( 5 , 6 );
	printf("num=%d\n", num);
	return 0;
}

7.自增自减运算符

i++ , i–
运算符在变量的后面，在当前表达式中先用 i 的值，下条语句的时候 i 的值改变

#include<stdio.h>
int main()
{
	int num;
	int i = 3;
	int j = 7;
	num = i++;
	printf("num=%d\ti=%d\n", num, i);
	num = --j;
	printf("num=%d\tj=%d\n", num, j);
	return 0;
}

运算符的优先级及结合性

运算符优先级

在表达式中按照优先级先后进行运算，优先级高的先于优先级低的先运算。
优先级一样的按结合性来运算。

int a;
a = 2 + 5 + 3 * 4 - 6

运算符的结合性

左结合性：从左往右运算

int a;
a = 2 + 3 + 9 + 10;

右结合性：从右往左算

int a,b,c,d;
a = b = c = d = 100;

注：建议当表达式比较复杂的时候，用 （）括起来，括号的优先级最高，优先算括号里的。