操作符详解，超详细的介绍操作符的作用与功能和注意事项

1.操作符分类

算术操作符
位移操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号操作符
下标引用、函数调用和结构体成员操作符

2.算术操作符

+ - * / %

• 除%操作符外，其他的4个操作符都是可以作用于整数和浮点数。即取模的操作符的两端必须都是整数。
• 对于/操作符如果两个操作数都为整数，执行整数除法。而有浮点数执行的就是浮点数除法
• %操作符的两个操作符必须为整数。返回的是整数之后的余数

程序当中的二进制位

程序的最底层都是二进制位，在C语言中也不例外。数与数的运算都是以二进制位运算的，以正整数15为例，它的二进制表达为：00000000 00000000 00000000 00001111。同时二进制有三种表达形式。
整数的二进制表达形式：

原码 反码 补码。

正整数的原 反 补码是相同的
负整数的原 反 补码是要计算的
计算负整数的反码与补码
负数的反码等于原码的符合位不变，其他位按位取反得到的就是反码
补码等于反码加1

以-15为例
-15的原码为 10000000 00000000 00000000 00001111
-15的补码为 11111111 11111111 11111111 11110000
-15的补码为 11111111 11111111 11111111 11110001

什么是符号位
符号位就是在整数的进制位最左侧的一位为符号位，1表示负数 0表示正数。
补码的作用
在计算机中的运算都是围绕着补码来计算的。
在内存中存储的是补码，计算也是用的补码

3.移位操作符

<< 左移操作符
>> 右移操作符

//移位操作符的操作数只能是整数

3.1 左移操作符

左边抛弃、右边补0

在num没有被赋值的情况下，自身的值不会改变。

3.2 右移操作符

规则

右移运算有两种规则：
> 1.逻辑移位
> 左边用0填充，右边抛弃
> 2.算术移位
> 左边用原该值的符号位填充，右边抛弃

C语言没有明确规定是算术右移还是符号右移，一般编译器上采用的是算术右移

#include <stdio.h>

int main()
{
	int num = -1;
	int b = num >> 1;
	printf("%d\n", b);
	return 0;
}
//打印结果 -1

注意：对于移位操作符，不能移动负数位，这是标准为定义行为

//错误写法
int num = 10;
num>>-1;//error

4.位操作符

位操作符：

& //按位与
| //按位或
^ //按位异或
//以上操作符的操作数必须是整数

位操作符也是对二进制进行操作的，且为双目操作符
&的作用就是将，两个二进制位的补码，对应位置有0为0，两个同时为1才是1.

1&2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000000

|的作用就是将，两个二进制位的补码，对应位置有1为1，两个同时为0才是0.

1|2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000011

^的作用就是将，两个二进制位的补码，对应位置相同为0，不同为1.

1^2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000011

练习：

#include <stdio.h>
int main()
{
	int num1 = 1;
	int num2 = 2;
	printf("%d\n",num1&num2);
	printf("%d\n",num1|num2);
	printf("%d\n",num1^num2);
	return 0;
}
//打印结果
/*
0
3
3
*/

练习

在不能创建临时变量（第3个变量）的情况下，实现两个数的交换

//代码1
#include <stdio.h>
int main()
{
	int a = 5;
	int b = 3;
	a = a^b;
	b = a^b;
	a = a^b;
	printf("a = %d,b = %d",a,b);
	return 0;
}

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

练习

编写代码实现：求一个整数存储在内存中的二进制中的1的个数

#include <stdio.h>
int main()
{
	int a = 0;
	scanf("%d",&a);
	int num = 1;
	int count = 0;
	for(int i = 0;i<32;++i)
	{
		num = 1<<i;
		if(a&num)
		{
			count++;
		}
	}
	printf("%d\n",count);
	return 0;
}

5.赋值操作符

int weight = 120;
weight = 89;
double salary = 10000.0;
salary = 20000.0;

//赋值操作符可以连续使用，比如
int a = 10;
int b = 20;
int c = 30;
a = b = c = 50;//连续赋值
//推荐使用分开赋值，代码更简单，调试也很方便

复合赋值符

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

这些运算符都可以写成复合的效果

6.单目操作符

6.1 介绍单目操作符

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

* 通过指针变量中存放的地址，找到指向的空间（内容）

#include <stdio.h>
int main()
{
	int a = 1;
	int* pa = &a;
	a = -a;
	printf("%d\n",sizeof(a));
	printf("%d\n",sizeof a);
	printf("%d\n",sizeof(int));
	printf("%d\n",sizeof int);//错误写法，对应类型计算要加()
	return 0;
}

6.2 sizeof和数组

#include <stdio.h>
void test1(int arr[10])
{
	printf("%d\n",sizeof(arr));
}
void test2(char ch[10])
{
	printf("%d\n",sizeof(ch));
}
int main()
{
	int arr[10] = {0};
	char ch[10] = {0};
	printf("%d\n",sizeof(arr));
	printf("%d\n",sizeof(ch));
	test1(arr);
	test2(ch);
	return 0;
}
//打印结果
/*
40
10
4/8
4/8
*/

//关于前置++ 后置++与前置-- 后置--
#include <stdio.h>
int main()
{
	int a = 10;
	int x = ++a;
	//a先自增1，然后再用a对x赋值
	int y = a++;
	//先用a赋值y，然后a再自增1
	return 0;
}

7.关系操作符

>
>=
<
<=
!=    不等于
==    等于

注意== 和 = 的区分

8.逻辑操作符

&&     逻辑与
||     逻辑或

区分逻辑与和按位与
区分逻辑或和按位或
练习

//代码1
#include <stdio.h>
int main()
{
	int i = 0,a = 0,b = 2,c = 3,d = 4;
	i = a++&&++b&&d++;
	printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
	return 0;
}
//打印结果
/*
 a = 1
 b = 2
 c = 3
 d = 4
*/
//代码1
#include <stdio.h>
int main()
{
	int i = 0,a = 0,b = 2,c = 3,d = 4;
	i = a++||++b||d++;
	printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
	return 0;
}
//打印结果
/*
 a = 1
 b = 3
 c = 3
 d = 4
*/

对于多个&&连接的一个式子，从左到右当出现一个表达式为假时，此时该条式子已经为假，计算机便不要再往右计算。
对于多个||连接的一个式子，从左到右当出现一个表达式为真时，此时该条式子已经为真，计算机便不要再往右计算。

9.条件操作符

exp1?exp2:exp3
//当exp1为真时执行exp2反之执行exp3

if(a>5)
	b = 3;
else
	b = -3;
//利用条件操作符简化
b = a>5?3:-3

10.逗号表达式

exp1,exp2,exp3,...expn

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

a = get_val();
count_val(a);
while(a>0)
{
	//.....
	a = get_val();
	count_val(a);
}
//利用逗号表达式
while(a = get_val(),count_val(a),a>0)
{
	//.....
}

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

1.[] 下标引用操作符
操作数：一个数组名+一个索引值

int arr[10] = {0};
arr[9] = 10;
//[]的两个操作数是arr和9。
//数组也是有类型的，去掉名字就是数组类型，如int arr[10] = {0};类型为：int [10]

2.（）函数调用操作符
接受一个或者多个操作符：第一个操作数是函数名，剩余的操作数就是传递给函数的参数

#include <stdio.h>
void test1()
{
	printf("hahaha\n");
}
void test2(const char* str)
{
	printf("%s\n",str);
}
int main()
{
	test1();
	test2("hello!");
}

3.访问一个结构的成员

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

#include <stdio.h>
struct stu
{
	char name[10];
	int age;
	char sex[5];
};
int main()
{
	struct stu s;
	struct stu* ps;
	ps = &s;
	s.age = 17;
	s.name = Yui;
	s.sex = female;
	ps->age = 18;
	ps->name = Yui;
	s->sex = female;
}

12.表达式求值

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

12.1隐式类型转换

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

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

//实例1
char a,b,c;
...
a = b+c;

b和c的值被提升为普通整型，然后再执行加法运算。
加法完成后，结果将被截断，然后再存储于a当中。
然后进行整型提升

整型提升是按照变量的数据类型的符合位来提升的。

#include <stdio.h>
int main()
{
	//负数的整型提升
	char c1 = -1;
	//变量c1的二进制位（补码）中只有8个比特位
	//11111111
	//因为char为符合的char
	//所以在整型提升的时候，高位补充符合位，即为1
	//提升后的结果：
	//11111111 11111111 11111111 11111111
	char c2 = 1;
	//变量c2的二进制位（补码）中只有8个比特位
	//00000001
	//因为char为符合的char
	//所以在整型提升的时候，高位补充符合位，即为1
	//提升后的结果：
	//00000000 00000000 00000000 00000001

	//无符号整型提升，高位补0
}

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

//打印结果
/*
1
4
4
*/

该实例中，c只要参加表达式运算，就会发生整型提升，所以在执行+c/-c的过程中就有整型提升。变为整型4个字节

12.2 算术转换

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

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

如果，某个操作数的类型在上面这个列表的排名较低，那么首先要转换位另一个操作数的类型后执行运算。
注意：
算术转换要合理，不然可能会有精度丢失等一些问题。

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

12.3操作符的属性

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

• 操作符的优先级
• 操作符的结合性
• 是否控制求值顺序
  两个相邻的操作符先执行哪个，取决于它们的优先级。如果两者优先级相同，取决于它们的结合性。

操作符优先级

操作符	描述	用法示例	结果类 型	结合性	是否控制求值 顺序
（）	聚组	（表达式）	与表达式同	N/A	否
（）	函数调用	rexp（rexp，…,rexp）	rexp	L-R	否
[ ]	下标引用	rexp[rexp]	lexp	L-R	否
.	访问结构成员	lexp.member_name	lexp	L-R	否
->	访问结构指针成员	rexp->member_name	lexp	L-R	否
++	后缀自增	lexp ++	rexp	L-R	否
–	后缀自减	lexp –	rexp	L-R	否
!	逻辑反	! rexp	rexp	R-L	否
~	按位取反	~ rexp	rexp	R-L	否
+	单目，表示正值	+ rexp	rexp	R-L	否
-	单目，表示负值	- rexp	rexp	R-L	否
++	前缀自增	++ lexp	rexp	R-L	否
–	前缀自减	– lexp	rexp	R-L	否
*	间接访问	* rexp	lexp	R-L	否
&	取地址	& lexp	rexp	R-L	否
sizeof	取其长度，以字节 表示	sizeof rexp sizeof(类型)	rexp	R-L	否
(类型）	类型转换	(类型) rexp	rexp	R-L	否
*	乘法	rexp * rexp	rexp	L-R	否
/	除法	rexp / rexp	rexp	L-R	否
%	整数取余	rexp % rexp	rexp	L-R	否
+	加法	rexp + rexp	rexp	L-R	否
-	减法	rexp - rexp	rexp	L-R	否
<<	左移位	rexp << rexp	rexp	L-R	否
>>	右移位	rexp >> rexp	rexp	L-R	否
>	大于	rexp > rexp	rexp	L-R	否
>=	大于等于	rexp >= rexp	rexp	L-R	否
<	小于	rexp < rexp	rexp	L-R	否
<=	小于等于	rexp <= rexp	rexp	L-R	否
操作 符	描述	用法示例	结果类 型	结合 性	是否控制求值 顺序
==	等于	rexp == rexp	rexp	L-R	否
!=	不等于	rexp != rexp	rexp	L-R	否
&	位与	rexp & rexp	rexp	L-R	否
^	位异或	rexp ^ rexp	rexp	L-R	否
|	位或	rexp | rexp	rexp	L-R	否
&&	逻辑与	rexp && rexp	rexp	L-R	是
|	逻辑或	rexp | rexp	rexp	L-R	是
? :	条件操作符	rexp ? rexp : rexp	rexp	N/A	是
=	赋值	lexp = rexp	rexp	R-L	否
+=	以…加	lexp += rexp	rexp	R-L	否
-=	以…减	lexp -= rexp	rexp	R-L	否
*=	以…乘	lexp *= rexp	rexp	R-L	否
/=	以…除	lexp /= rexp	rexp	R-L	否
%=	以…取模	lexp %= rexp	rexp	R-L	否
<<=	以…左移	lexp <<= rexp	rexp	R-L	否
>>=	以…右移	lexp >>= rexp	rexp	R-L	否
&=	以…与	lexp &= rexp	rexp	R-L	否
^=	以…异或	lexp ^= rexp	rexp	R-L	否
|=	以…或	lexp |= rexp	rexp	R-L	否
，	逗号	rexp，rexp	rexp	L-R	是

a*b+c*d+e*f

在上面的代码当中，由于*比+的优先级高，只能保证，*的计算比+早，但是优先级并不能决定第三个*比第一个+早执行。

//计算机的计算顺序可能是
a*b
c*d
a*b+c*d
e*f
a*b+c*d+e*f
//或者
a*b
c*d
e*f

a*b+c*d
a*b+c*d+e*f

再看一段代码

c + --c

操作符的优先级只能决定自减–的运算在+的运算前面，但是我们并没有办法得知，+的操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧意的。

//非法表达式
int main()
{
	int i = 10;
	i = i-- - --i * (i=-3) * i++ + ++i;
	printf("i = %d\n",i);
	return 0;
}

本段代码出在《C与指针》。该书的作者尝试了市面上所有的主流编译器，得到的答案却都不相同。所以这段代码没有实际的意义。
总结：
我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那么这个表达式就是存在问题的。

完