C语言操作符详解

算数操作符

+ - % /
这四个操作符中%只能操作整数，不能对浮点数进行操作，%是对两个整数整除之后的余数。
例如：7%2=1；5%5=5；6%3=0；
/操作符它可以对浮点数和整数操作，其中只要有浮点数就进行浮点数运算，都是整形就进行整形运算

表达式	结果
3/2	1
3.0/2	1.5
3.0/2.0	1.5
3/2.0	1.5

移位操作符

• << 左移操作符
• >> 右移操作符
• 注：移位操作符的操作数只能是整数。

我们要想理解移位操作符就必须先了解移动的是什么位，什么是源码，反码，补码
移位操作符移动的是二进制位且为反码的二进制位
十进制就是逢十进一
二进制就是逢二进一
计算机中的数据都是二进制存储的，所以源码反码补码都为二进制，补码就是数据存储在计算机中的样子

在整形数据中：
正数的整数的原码、反码、补码相同
负数的整数的原码、反码、补码是要计算的
原码就是你想要存储的数字
数据存储中第一位代表符号位

• 1 - 负数
• 0 - 正数

负数的反码就是原码的符号位不变，其他位按位取反
负数的补码就是反码减一
例子：7和-7的原码反码补码。

左移操作符

移位规则：
左边抛弃、右边补0
例子1：若int a = 7; int b = a<<1;求b的值

代码验证

#include<stdio.h>
int main()
{
	int a = 7;
	int b = a << 1;
	printf("%d\n", b);
	return 0;
}

例子2：若int a = -7; int b = a<<1;求b的值

代码验证

#include<stdio.h>
int main()
{
	int a = -7;
	int b = a << 1;
	printf("%d\n", b);
	return 0;
}

从上可知左移一位原数据增加二倍

右移操作符

右移操作符分为算术右移和逻辑右移

• 算数右移:左边丢弃，右边补原符号位。
• 逻辑右移:左边丢弃，右边补0

在大多数编译器中应用的是算数右移

例子1：若int a = 7; int b = a>>1;求b的值

代码验证

#include<stdio.h>
int main()
{
	int a = 7;
	int b = a >> 1;
	printf("%d\n", b);
	return 0;
}

例子2：若int a = -7; int b = a>>1;求b的值
代码验证

#include<stdio.h>
int main()
{
	int a = -7;
	int b = a >> 1;
	printf("%d\n", b);
	return 0;
}

位操作符

位操作符有三个:

• & - 按(二进制)位与(全为1则位1，否则为0)
• | - 按(二进制)位或（全为0则为0，否则为1）
• ^ - 按(二进制)位异或（相同为0，相异为1）

例题1:int a = 3;int b = -5;int c = a | b;求c

代码验证:

#include<stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a | b;
	printf("%d\n", c);
	return 0;
}

例题2:int a = 3;int b = -5;int c = a & b;求c

代码验证:

#include<stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a & b;
	printf("%d\n", c);
	return 0;
}

例题3:int a = 3;int b = -5;int c = a ^ b;求c

代码验证:

#include<stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a ^ b;
	printf("%d\n", c);
	return 0;
}

位操作符的练习题

不能创建临时变量（第三个变量），实现两个数的交换。

通常我们交换两个变量a,b都是创建一个变量tmp = a;a =b;b = tmp;
但是不用创建第三个变量我们应该如何如解决呢?
我们提供两种方法，一种是求和加减，一种是用^操作符

求和加减法:

#include<stdio.h>
int main()
{
	int a = 4;
	int b = 5;
	a = a + b;//4+5
	b = a - b;//4+5-5=4
	a = a - b;//4+5-4=5
	printf("%d %d", a, b);
	return 0;
}

但是上面的这种方法当数据过大时就不行了，当a,b都很大但不对于int溢出
a+b就溢出，a=a+b; a - b就不再是以前的a了
用^操作符可以解决这种问题

^操作符交换两数
我们应先补充几个小知识：

• 存在一个整形变量a , 则a^a = 0;a^0 = a ；
• 异或操作符支持交换律：
  5^5^8=8;
  5^8^5=8;

#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	a = a ^ b;
	b = a ^ b;//a^b^b=a
	a = a ^ b;//a^b^a=b;
	printf("%d %d", a, b);
	return 0;
}

但是此方法也是有缺陷的，只能操作整数，其他类型数据就不行

赋值操作符

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。
比如int weight = 120;weight = 80;
注意: int weight = 120;是初始化。weight = 80;是赋值。
赋值操作符可以连续赋值a = x = y+1;
但是不如x = y+1;a = x;更加清晰爽朗而且易于调试。

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

a = a+5;等价于a+=5;
a = a>>1;等价于a>>=1;
其他类似

单目操作符

单目操作符是只有一个操作数的，双目操作符是有两个操作数的例如：a+b;

操作符	名称
!	逻辑反操作
-	负值
+	正值
&	取地址
sizeof	操作数的类型长度（以字节为单位）
~	对一个数的二进制按位取反
–	前置、后置–
++	前置、后置++
*	间接访问操作符(解引用操作符)
(类型)	强制类型转换

! 逻辑反操作
逻辑反操作符顾名思义就是逻辑相反，假变真，真变假。
C语言0表示假，非0表示真

#include<stdio.h>
int main()
{
	int flag = 0;
	if (flag)
	{
		printf("flag this is ture\n");
	}
	if (!flag)
	{
		printf("!flag this is ture\n");
	}

	return 0;
}

上面的程序if语句中的语句可以换成其他的程序语句来实现想要的功能。

- 负值 + 正值
- 操作符会使操作数变为相反数，但是+操作数不会使所有操作数为正，正操作出还为正，负操作数还为负

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

& 取地址操作符
&是取出变量的地址

#include<stdio.h>
int main()
{
	int a = 10;
	printf("%p", &a);
	return 0;
}

显示的是a变量首地址

sizeof 操作数的类型长度（以字节为单位）
sizeof是一个操作符，不是一个函数。

• 计算变量的大小
• 计算数组的大小
• 计算类型所创建的变量占据空间的大小

#include<stdio.h>
int main()
{
	int a = 10;
	int arr[10] = { 0 };
	printf("%zu\n", sizeof(a));
	printf("%zu\n", sizeof a);
	printf("%zu\n", sizeof (int));
	printf("%zu\n", sizeof arr);
	printf("%zu\n", sizeof (arr));
	return 0;
}

从计算arr和a 的大小可以不用()可以证明他是操作符，因为()是函数才能用的。
但是int必须加()

~ 对一个数的二进制按位取反
int a = 0;~a是多少，

#include<stdio.h>
int main()
{
	int a = 0;
	int b = ~a;
	printf("%d", b);
	return 0;
}

int a = 3;~a是多少

#include<stdio.h>
int main()
{
	int a = 3;
	int b = ~a;
	printf("%d\n", ~b);
	return 0;
}

将int a = 13;a的二进制位中第五位先改为1，然后再改为0；

改为1

再改为0

#include<stdio.h>
int main()
{
	int a = 13;
	int b = a | (1 << 4);
	printf("%d\n", b);
	int c = b & (~(1 << 4));
	printf("%d\n", c);
	return 0;
}

– 前置、后置–
++ 前置、后置++

前置++ --是先++ --再进行其他操作
后置++ --是先进行其他操作在进行++ –

#include<stdio.h>
int main()
{
	int a = 10;
	int b = ++a;//先++再使用
	//等价于 a = a + 1 b = a
	
	int c = a++;//先使用再++
	//等价于 c = a ; a = a +1
	//--同理
	return 0;
}

* 间接访问操作符(解引用操作符)

*操作符可以通过变量的地址来找到变量，进而来改变变量

#include<stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	*pa = 20;
	printf("%d\n", a);
	return 0;
}

(类型) 强制类型转换

强制类型转换操作符当int a = 3.14;编译器会报警告，因为数据类型不匹配
改为int a = (int)3.14;

关系操作符

>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”

关系操作符需要注意的一点==不要写成=这样会出BUG
只能比较简单变量，例如比较字符串就不能使用’==’，需要用strcmp函数

逻辑操作符

&& 逻辑与
|| 逻辑或
逻辑与相当于并且两个为真则为真否则为假，
逻辑或相当于或者全部为假则为假否则为真。

&& 左边为假，右边就不计算了
|| 左边为真，右边就不计算了

笔试题

#include <stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);

	return 0;
}

输出结果是什么?

#include <stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ || ++b || d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);

	return 0;
}

输出结果是什么?

条件操作符

exp1 ? exp2 : exp3
条件操作符有三个操作数属于三目操作符
exp1为真计算exp2，表达式结果也为exp2
exp1为假计算exp3，表达式结果也为exp3
用条件操作符可以相当于if else语句

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int max1 = a > b ? a : b;
	int max2 = 0;
	if (a > b)
		max2 = a;
	else
		max2 = b;
	printf("%d\n%d\n", max1, max2);

	return 0;
}

虽然能代替if else语句，但是建议语句复杂的情况下还是用if else语句不要用条件表达式，因为这样会使条件表达式变得不比if else语句简洁

逗号表达式

exp1, exp2, exp3, …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

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

	return 0;
}

输出结果:a = 20 b = 21 c = 50 d = 50

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

[]为下标引用操作符，数组每个元素都有编号，标号从0开始，这个编号就是下标拥有数组名和下标就可以访问数组元素了
操作数：一个数组名 + 一个索引值

int arr[10]={10};
arr[4] <–> *(arr+4)<–> *(4+arr)<–>4[arr];
所以arr[4]和4[arr]等价，可以用4[arr],访问元素

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

	return 0;
}

()函数调用操作符，

#include<stdio.h>
//函数定义
int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int a = 10;
	int b = 20;
	//函数调用
	int c = Add(a, b);//() 就是函数调用操作符,操作数：Add,a,b
	printf("%d\n", c);
	return 0;
}

由上可知，（）操作符接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include<stdio.h>
//函数定义
int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int a = 10;
	int b = 20;
	//函数调用
	int c = Add(a, b);//() 就是函数调用操作符,操作数：Add,a,b
	printf("%d\n", c);
	return 0;
}

由此可以验证sizeof可以没有()它不是函数

结构成员操作符
作用：访问一个结构的成员

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

#include<stdio.h>
struct stu
{
	char name[20];
	int age;
	double score;
};
int main()
{
	struct stu S = { "zhangsan",18,80 };
	printf("%s   %d   %lf\n", S.name, S.age, S.score);
	struct stu* ps = &S;
	printf("%s   %d   %lf\n", (*ps).name, (*ps).age, (*ps).score);
	printf("%s   %d   %lf\n", ps->name, ps->age, ps->score);
	return 0;
}

表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

实例1：

#include<stdio.h>
int main()
{
	char a = 5;
	char b = 126;
	char c = a + b;
	printf("%d\n", c);
	return 0;
}

验证整形提升的存在

#include<stdio.h>
int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));//1
	printf("%u\n", sizeof(+c));//4
	printf("%u\n", sizeof(-c));//4

	return 0;
}

输出结果为：1 4 4

#include<stdio.h>
int main()
{
	char a = 0xb6;
	short b = 0xb600;
	int c = 0xb6000000;

	if (a == 0xb6)
		printf("a");

	if (b == 0xb600)
		printf("b");

	if (c == 0xb6000000)
		printf("c");

	return 0;
}

最终结果为C

整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长
度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令
中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转
换为int或unsigned int，然后才能送入CPU去执行运算。

算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类
型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double
double
float
unsigned long int
long int
unsigned int
int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
警告：
但是算术转换要合理，要不然会有一些潜在的问题。

float f = 3.14; int num = f;(隐式转换，会有精度丢失)

操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级

优先级	运算符	结合律
1	后缀运算符：[] () · -> ++ --(类型名称){列表}	从左到右
2	一元运算符：++ – ! ~ + - * & sizeof	从右到左
3	类型转换运算符：(类型名称)	从右到左
4	乘除法运算符：* / %	从左到右
5	加减法运算符：+ -	从左到右
6	移位运算符：<< >>	从左到右
7	关系运算符：<<= >>=	从左到右
8	相等运算符：== !=	从左到右
9	位运算符 AND：&	从左到右
10	位运算符 XOR：^	从左到右
11	位运算符 OR：|	从左到右
12	逻辑运算符 AND：&&	从左到右
13	逻辑运算符 OR：||	从左到右
14	条件运算符：?:	从右到左
15	赋值运算符： = += -= *= /= %= &= ^= |= <<= >>=	从右到左
16	逗号运算符：，	从左到右

是否控制求值顺序只有四个操作符：逻辑与，逻辑或，条件表达式，逗号表达式。

一些问题表达式
表达式求值中符号优先级是由两个相邻的符号决定的，如果有3个以上的操作符就可能出现问题
例一：

这两种表达式求值的顺序都满足从左到右结和性，*大于+的优先级，但是表达式顺序却不相同，如果a,b,c,d,e,f为表达式的话会影响整体表达式的结果。
例2：
操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。
代码3-非法表达式

int main()
{
 int i = 10;
 i = i-- - --i * ( i = -3 ) * i++ + ++i;
 printf("i = %d\n", i);
 return 0;
}

上面是在不同编译器，输出的不同结果

例子4：

int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少？
     return 0;
}

上面代码中三个fun()不知是谁先算是123，还是231都不可知，都是满足语法要求的，结果可能是-2或-10

例5：

#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}

上面的代码是经典的错误代码，在大学期间大部分人也做过这种题，在Linux运算中为10，在vs2019中是10，

上面的问题代码都是由于操作符使用不当造成的，我们写代码的时候避免使用这种不能通过操作符的属性确定唯一的计算路径的问题代码。