【C语言】操作符（详解）

1.算数操作符

---

+
-
*
/
%

1.对于除了%操作符之外，其他的几个操作符可以作用于整数和浮点数。
2.对于/操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3.%操作符的两个操作符必须为整数。返回的是整除后的余数。

 
 

2.移位操作符

---

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

2.1左移操作符

移位规则：

左边抛弃、右边补0

注：这里的例子可以说明，一个负数左移1位，后面的数直接充当符号位，不用考虑负数左移以后是否需要补充符号位

2.2右移操作符

移位规则：
首先右移运算分两种：

1.逻辑移位：左边用0填充，右边丢弃
2.算法移位：左边用原该值的符号位填充，右边丢弃

注：一般的编译器都是算数右移。

警告：对于移位运算符，不要移动负数位，这个是C语言标准未定义的。

int num = 10;
num >> -1;//error

 
 

3.位操作符

---

位操作符有：

&  //按位与
|  //按位或
^  //按位异或 -- 相同为0，相异为1
注：他们的操作数必须是整数。

练习一下

#include <stdio.h>
int main()
{
	int num1 = 1;
	//0001
	int num2 = 2;
	//0010
	num1& num2;
	//0000
	num1 | num2;
	//0011
	num1^ num2;
	//0011
	return 0;
}

注：这里补充两个常用的公式

a ^ 0 = a
a ^ a = 0

一道面试题：

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

#include <stdio.h>

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前: a = %d  b = %d\n", a, b);
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("交换后: a = %d  b = %d\n", a, b);
	return 0;
}

//原理
// 异或符号也满足交换律
//a ^ 0 == a;
//a ^ a == 0;
//a = a ^ b;
//b = a ^ b  ==>  b = a ^ b ^ b  ==>  b = a;
//a = a ^ b  ==>  a = a ^ b ^ a  ==>  a = b;

这里记两个重要的公式：

⭐️： num & (num - 1)
📖：这个公式可以消掉num的二进制中的最后一个1
⭐️ ： num & (-num)
📖：这个公式可以找到num的二进制中最后一个1的位置，我们把最后一个1减掉也能达到消掉最后一个1的目的

再练习一道题：

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

//方法一：
#include <stdio.h>
int main()
{
	int num = 0;
	int count = 0;//用来计数
	scanf("%d", &num);
	while (num)//num不等于0进入循环
	{
		count++;
		num = num & (num - 1);//每次消掉最后一个1
	}
	printf("%d\n", count);
	return 0;
}

//方法二：
#include <stdio.h>
int main()
{
	int num = 0;
	int count = 0;//用来计数
	scanf("%d", &num);
	while (num)
	{
		count++;
		num = num - (num & (-num));//找到最后一个一并减掉，以达到消掉最后一个1的目的
	}
	printf("%d\n", count);
	return 0;
}

 
 

4.赋值操作符

---

赋值操作符是可以连续使用的，比如：

int a = 10;
int x = 0;
int y = 20;
a = x = y + 1;

同样的语义：

x = y + 1;
a = x;

这样的写法显然更加清晰爽朗而且易于调试。

复合赋值符

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

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

 
 

5.单目操作符

---

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

⭐️：sizeof 是一个操作符，不是函数！

size_t  是专门为sizeof设计的一个类型
size_t  在不同的编译器下定义不同，但一般都是unsigned int 或者 unsigned long 这些正数

 
 

6.关系操作符

---

关系操作符：

>     大于
>=     大于等于
<     小于
<=     小于等于
!=      用于测试"不相等"
==     用于测试"相等"

⭐️：关系操作符只能引用到合适的类型上，比如：比较字符串的大小不能实用这些关系操作符，而应该使用strcmp

 
 

7.逻辑操作符

---

逻辑操作符：

&&    逻辑与：如果左边表达式为假，则右边表达式不计算
||    逻辑或：如果左边表达式为真，则右边表达式不计算

来看一道笔试题：

//程序的输出结果是什么
#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    //i = a++||++b||d++;
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}

答案如下：

a = 1
b = 2
c = 3
d = 4

 
 

8.条件操作符

---

exp1?exp2:exp3

判断表达式一是否为真：如果为真，则执行表达式二；如果为假，则执行表达式三。

 
 

9.逗号表达式

---

exp1,exp2,exp,3, … expN

逗号表达式，就是用逗号隔开的多个表达式。

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

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//c是多少?

c = 13
在这个表达式中，a>b、a=b+10、b=a+1都执行了一遍，但c的结果是等于b=a+1的结果

 
 

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

---

[ ]   下标引用操作符

操作数：一个数组名 + 一个索引值

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//创建数组
	arr[9] = 11;//使用下标引用操作符修改数组下标为9的元素
	//[ ]的两个操作数是 arr 和 9
	return 0;
}

那既然这是一个操作符，那它是否满足交换律呢？我们把代码写成这样来测试一下：

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//创建数组
	9[arr] = 20;//使用下标引用操作符
	//[ ]的两个操作数是 arr 和 9
	printf("%d\n", 9[arr]);
	printf("%d\n", arr[9]);
	return 0;
}

运行结果如图所示：

由此我们可以看出，写成这样语法也是支持的，当然，我们还是建议写成写成arr[9]的这种形式，方便他人读懂

( )   函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

访问一个结构体成员

.        使用方法：结构体.成员名
->      使用方法：结构体指针->成员名

 
 

11.表达式求值

---

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

11.1隐式类型转换

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

整形提升的意义：

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

char a,b,c;
...
a = b + c;

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

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

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001

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

整形提升的例子：

//实例1
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;
}

实例1中的a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600 的结果是假,但是c不发生整形提升,则表
达式 c==0xb6000000 的结果是真0.
所程序输出的结果是:

C

//实例2
int main()
{
	 char c = 1;
	 printf("%u\n", sizeof(c));
	 printf("%u\n", sizeof(+c));
	 printf("%u\n", sizeof(-c));
	 return 0;
}

实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节.（因为有一个加号表示准备参与运算，所以是提升成了整形类型）

表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节.

11.2算术转换

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

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

这里的转换顺序是由下到上

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

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

11.3操作符的属性

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

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

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

11.4操作符优先级

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

一些问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释：代码1在计算的时候，由于*比+的优先级高，只能保证，的计算是比+早，但是优先级并不能决定第三个比第一个+早执行。

所以表达式的计算顺序就可能是：

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

 

//表达式2
c + --c;

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

 

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

表达式3在不同编译器中测试结果：非法表达式程序的结果

 

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

这个代码也是有问题的

虽然在大多数的编译器上求得结果都是相同的。
但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。