【C语言】操作符详解：从基础到高阶，一篇搞定！

建筑转码の逆袭日志

已于 2025-08-01 17:06:15 修改

阅读量858

点赞数 30

CC 4.0 BY-SA版权

分类专栏： C语言文章标签： c语言 c++ 开发语言

于 2025-06-27 18:50:35 首次发布

本文链接：https://blog.youkuaiyun.com/suxi_na/article/details/148959109

C语言专栏收录该内容

30 篇文章

订阅专栏

C语言学习

操作符详解
友情链接：C语言专栏

一、操作符分类

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

二、算术操作符

+ - * / %

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

三、移位操作符

>> 右移操作符
<<左移操作符
注：他们的操作数必须是整数。

这里咱们先了解一下什么是原码、反码、补码？

3.1、原码、反码、补码

整数的2进制表⽰⽅法有三种，即原码、反码和补码
有符号整数的三种表⽰⽅法均有符号位和数值位两部分，2进制序列中，最⾼位的1位是被当做符号
位，剩余的都是数值位。
符号位都是⽤0表⽰“正”，⽤1表⽰“负”。
正整数的原、反、补码都相同。
负整数的三种表⽰⽅法各不相同。
原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码：反码+1就得到补码
反码得到原码也是可以使⽤：取反，+1的操作。
综上，对于整形来说：数据存放内存中其实存放的是补码。
解释：

在计算机系统中，数值⼀律⽤补码来表⽰和存储。原因在于，使⽤补码，可以将符号位和数值域统⼀
处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算
过程是相同的，不需要额外的硬件电路。

3.2、左移操作符

规则：

左边抛弃，右边补零

看代码：

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

输出是这样的：
请添加图片描述
为什么呢？详解：

3.3、右移操作符

右移操作符分为两种：

逻辑右移：左边⽤0填充，右边丢弃
算术右移：左边⽤原该值的符号位填充，右边丢弃

到底是哪个右移方式，取决于编译器实现（但主流编译器通常选择算术右移以保持数学合理性）。

还要注意一点：对于移位运算符，不要移动负数位，这个是标准未定义的。这样做也没有意义。

四、位操作符

位操作符有：

&  //按位与
|  //按位或
^  //按位异或
~  //按位取反
注：他们的操作数必须是整数。

看代码：

#include <stdio.h>
int main()
{
	int num1 = -3;
	int num2 = 5;
	printf("%d\n", num1 & num2);
	printf("%d\n", num1 | num2);
	printf("%d\n", num1 ^ num2);
	printf("%d\n", ~0);
	return 0;
}

在这里插入图片描述

先看按位与&:两个都为1，结果位才为1，否则为0（有0则为0），那结果就为：5
再看按位或|:两个都为0，结果才为0，否则为1（有1则为1），那结果就为：-3（下图皆为补码）
再看按位异或^:相同为0，不同为1，那结果就为：-8
按位取反：-1

看测试结果：

那咱们来看看位操作符的妙用：

不能创建临时变量（第三个变量），实现两个数的交换。
以前，咱们可能这样做：

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

但这种方法会有溢出的风险，那么我们现在可以这样写：

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

解释：

首先，我们要知道：20^0=20; 10^10=0;
那么，10^20^10应该等于多少？
其实它就等于，10^10^20;这就说明异或操作符符合交换律；

五、赋值操作符

赋值操作符咱们已经不陌生了，就是=;咱们这里主要说一说复合赋值符：

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

举个例子：

	int x = 5;
	x = x + 10；//可写为
	x += 10;//效果是一样的，只是这样写更为简洁

六、单目操作符

6.1、单目操作符介绍

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

其实这些操作符都很简单，咱们主要来看一些注意的点。

6.2、sizeof

sizeof求变量（类型）大小：

int main()
{
	int a = 10;
	printf("%d\n",sizeof(a));
	printf("%d\n",sizeof(int));
	//类型名作为 sizeof 的操作数时必须加括号
	//这是C 标准规定
	return 0;
}

sizeof与数组
这里咱们主要看一下数组名在不同情况下sizeof的输出值，

#include <stdio.h>
void test1(int arr[])
{
	printf("%d\n", sizeof(arr));//3
}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));//4
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//1
	printf("%d\n", sizeof(ch));//2
	test1(arr);
	test2(ch);
	return 0;
}

分析：

首先，1和2都是算数组的大小，即1为40，2为10；
3和4虽然都是数组名，但是函数拆传参的时候传过去的是数组首元素地址，所以在32位的环境下是4；
看输出结果：

还有一个需要注意，前置++/–与后置++/–；

前置++；
int a = 10;
printf("%d",a++);//输出为10；先对a先使用，再增加
//但如果这样写的话：
printf("%d",++a);//输出则为11；先对a加加，再使用

但是，在下面这种情况下需注意：

int a = 10;
sizeof(a++); // a 不会自增，因为 sizeof 不计算表达式
//因为sizeof 在编译阶段确定结果，不会生成运行时代码。

七、关系操作符

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

很简单，就不说了，但是要注意一点：
在编程的过程中== 和=不小心写错，导致的错误，很常见。

八、逻辑操作符

&& 逻辑与
|| 逻辑或

逻辑与或结果只有1/0，即真假；
看个代码：

#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\nd = %d\n", a, b, c, d);
	return 0;
}

输出：
在这里插入图片描述

其实是这样的：（ a && b && c）,当a为假时，就不会执行b\c语句，这样的话也减少了时间。
同样，可以看一下：

#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\nd = %d\n", a, b, c, d);
	return 0;
}

九、条件操作符（三目表达式）

exp1 ? exp2 : exp3

解释：1为真，则执行表达式2，否则执行3；
咱们可以试着用这个写一个求两个数的较大值：

int main()
{
	int a, b, c;
	scanf("%d %d", &a, &b);
	c = a > b ? a : b;
	printf("%d", c);
	return 0;
}

十、逗号操作符

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

exp1,exp2,exp3……

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

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

那咱们从左往右开始看不就行了，c为13。

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

下标引用操作符[]

	int arr[10];//创建数组
	arr[5] = 10;//实用下标引用操作符。
[ ]的两个操作数是arr和5。

函数调用操作符()

#include <stdio.h>
void test1()
{
	printf("hello\n");
}
void test2(char *str)
{
	printf("%s\n", str);
}
int main()
{
	test1(); //实用（）作为函数调用操作符。
	test2("hello");//实用（）作为函数调用操作符。
	//接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数
	return 0;
}

结构成员访问操操作符

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

示例：

//结构体创建
struct Stu
{
	char name[10];
	int age;
	char sex[5];
	double score;
};
void set_age1(struct Stu stu)
{
	stu.age = 18;//结构成员访问
}
void set_age2(struct Stu* pStu)
{
	pStu->age = 18;//结构成员访问
}
int main()
{
	struct Stu stu;
	struct Stu* pStu = &stu;

	stu.age = 20;//结构成员访问
	set_age1(stu);

	pStu->age = 20;//结构成员访问
	set_age2(pStu);
	return 0;
}

十二、表达式求值

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

12.1、隐式类型转换

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

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

比如：

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

那咱们来看一下如何进行整体提升呢？

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

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

咱们来看两个例子：

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;
}

在这里插入图片描述
解释：

a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表
达式 c==0xb6000000 的结果是真.

来看第二个：

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

在这里插入图片描述
解释：

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

12.2、算术转换

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

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

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

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

12.3 、操作符的属性

这里就要说一下复杂表达式的求值影响因素了。

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

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级参考表
在很多时候，即便有操作符的优先级，还会有一些问题表达式：
举个做简单的例子：

c + --c

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

即：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题
的。

总结

C语言操作符涵盖运算、比较、位操作等，需注意优先级、结合性及副作用，sizeof 是编译时求值的特殊操作符。

附录