操作符详解-C语言

_Amor_

已于 2023-11-12 16:43:34 修改

阅读量47

点赞数

分类专栏： C语言文章标签： c语言开发语言 1024程序员节

于 2023-10-15 12:59:20 首次发布

本文链接：https://blog.csdn.net/ma123456542/article/details/133841364

版权

C语言专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1.操作符的分类

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2. 算术操作符

作用：用于处理四则运算。

+    -    *    /    %

除法操作符（/）
· 整型的除法： 1/2
· 浮点数的除法：1.0/2
               1/2.0
               1.0/2.0

注意：在除法和取模运算中，除数不能为 0。

取模操作符（%）的本质是求余数，两端必须是整数。其他的几个操作符可以作用于整数和浮点数。
对于 / 操作符如果两个操作数都是整数，执行整数除法。而只要有浮点数就执行浮点数的除法。

3. 移位操作符

移位操作符移动的是二进制位。

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

注意：移位操作符的操作数只能是整数，移动的位数不能用负数。

整数的二进制表示有 3 种：

原码
反码
补码

正的整数的原码反码补码相同。

负的整数的原码反码补码是需要计算的。
7
原码：0000 0000 0000 0000 0000 0000 0000 0111
反码：0000 0000 0000 0000 0000 0000 0000 0111
补码：0000 0000 0000 0000 0000 0000 0000 0111

-7
原码：1000 0000 0000 0000 0000 0000 0000 0111
反码：1111 1111 1111 1111 1111 1111 1111 1000(原码的符号位不变，其他位按位取反就是反码)
补码：1111 1111 1111 1111 1111 1111 1111 1001(反码 +1 就是补码)
整数在内存中存储的是补码，因此移位操作符移动的是存储在内存中的补码。

3.1 左移操作符（<<）

原则：左边丢弃，右边补 0。

int a = 7;
int b = a << 1;
int c = -7;
int d = d << 1;

printf("a=%d\n", a);
printf("b=%d\n", b);
printf("c=%d\n", c);
printf("d=%d\n", d);

左移操作符有 ×2 的处理效果（正负数均有）。而操作数本身并不发生变化。

3.2 右移操作符（>>）

右移操作符分为两类（取决于编译器）：

算术移位：右边丢弃，左边补原符号位；（常用）
逻辑移位：右边丢弃，左边补 0。

int a = -7;
int b = a >> 1;

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

警告⚠：

对于移位操作符，不要移动负数，这是标准未定义的。
int num = 10;
num >> -1;//error

4. 位操作符

位操作符操作的是二进制位。

&    按(二进制)位与
|    按(二进制)位或
^    按(二进制)位异或：相同为 0，相异为 1
~    按位取反

注意：它们的操作数必须是整数。

int a = 3;
int b = -5;
int c = a & b;
int d = a | b;
int e = a ^ b;

printf("%d\n", c);
printf("%d\n", d);
printf("%d\n", e);

异或操作符（^）特点：

a ^ a = 0; 0 ^ a = a;
异或操作符支持交换律。

一道变态的面试题：不能创建临时变量（第三个变量），实现两个数的变换。

方法 1：

#include <stdio.h>

int main() {
	int a = 3;
	int b = 5;

	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 = 3;
	int b = 5;

	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("交换后：a=%d b=%d", a, b);

	return 0;
}

该方法特点：

只适用于整型。
可读性差。
效率较低。

练习：编写代码实现：求一个整数存储在内存中（补码）的二进制中 1 的个数。

5. 赋值操作符

赋值操作符是一个很棒的操作符，它可以让你在一个变量得到一个不满意的值后，重新给该变量赋值。

作用：用于将表达式的值赋给变量

int a = 10;

赋值运算符可以连续使用：

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

//连续赋值
a = x = y + 1;


//逐一赋值
x = y + 1;
a = x;

采用逐一赋值这样的写法更加清晰爽朗并且易于调试。

复合赋值符

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

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

int x = 10;
x = x + 10;
x += 10;

其他运算符一样的道理，这样写更加整洁。

6. 单目操作符

6.1 单目操作符介绍

单目操作符只有一个操作数

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

int a = +10;
int b = -a;

if (!a) {
}
int* p = &a;

sizeof(a);

printf("%d", a--);//先传参，后--
return a++;//先return，后++

*p = 20;

int a = 3.14;
int a = (int)3.14;
srand((unsigned int)(time(NULL));

6.2 位运算介绍

int a = 13;
//0000 0000 0000 0000 0000 0000 0000 1101

a |= (1 << 4);
//0000 0000 0000 0000 0000 0000 0001 0000
//0000 0000 0000 0000 0000 0000 0001 1101

a &= (~(1 << 4));
//0000 0000 0000 0000 0000 0000 0001 0000
//1111 1111 1111 1111 1111 1111 1110 1111 
//0000 0000 0000 0000 0000 0000 0000 1101

C语言中 0 表示假，非 0 表示真。
sizeof 可以计算变量/类型所创建的变量所占内存空间的大小，单位是字节。
前置++：先++，后使用。（内置类型无区别，自定义类型效率高一些）后置++：先使用，后++。

练习：

#include <stdio.h>

void test1(int arr[]) {
	printf("%d\n", sizeof(arr));
}

void test2(char ch[]) {
	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;
}

7. 关系操作符

作用：用于表达式的比较，并返回一个真值或者假值。

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

注意：

在编程过程中 == 和 = 不小心写错，导致的错误。
浮点数用 == 比较存在不精确的问题。
字符串不能用关系操作符比较，实际在比较字符串首元素的地址。(应使用 strcmp)
if (3.0 == 3.0) {}
if ("abc" == "abcd") {}

8. 逻辑操作符

作用：用于根据表达式的值返回真值或假值

&&         逻辑与
||         逻辑或
!          逻辑非

区别 逻辑与 和 按位与

区别 逻辑或 和 按位或

1&2  ---> 0
1&&2 ---> 1

1|2  ---> 3
1||2 ---> 1

逻辑与和或的特点：

逻辑与（&&）：
有 0 则 0，全 1 为 1。
左边为假，右边就不计算了。
逻辑或（||）：
有 1 则 1，全 0 为 0。
左边为真，右边就不计算了。
逻辑非（!）：
真（非 0 均为真）变假，假变真（变为1）。

笔试题：

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

	return 0;
}

逻辑操作符（&&，||，！）的结果如果是真就是 1，如果是假就是 0。

9. 条件操作符（三目操作符）

作用：通过三目操作符实现简单的判断

语法：

exp1 ? exp2 : exp3

解释：

如果表达式 1 的值为真，执行表达式 2，并返回表达式 2 的结果；
如果表达式 1 的值为假，执行表达式 3，并返回表达式 3 的结果.

练习：

if (a > 5)
    b = 3;
else 
    b = -3;

b = a > 5 ? 3 : -3;

使用三目操作符求较大值：

int max = (a > b ? a : b);

三目操作符返回的如果是变量，可以继续赋值。
(a > b ? a : b) = 100;

10. 逗号表达式

exp1, exp2, exp3, ...expN

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

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

//代码1
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);

//代码2
if (a = b + 1, c = a / 2, d > 0)

//代码3
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. 下标引用、函数调用和结构成员

11.1 下标引用操作符 [ ]

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

int arr[10];
arr[9] = 10;
9[arr] = 8;

[ ] 的两个操作数是 arr 和 9，满足交换律。
arr[9] ---> *(arr + 9)
9[arr] ---> *(9 + arr)

11.2 函数调用操作符 ( )

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

#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);

	return 0;
}

11.3 结构成员访问操作符

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

#include <stdio.h>

struct Stu {
	char name[20];
	int age;
	double score;
};

void set_stu(struct Stu* ss) {
	//(*ss).age = 20;
	//(*ss).score = 100.0;
	//strcpy((*ss).name, "zhangsan");
	ss->age = 20;
	ss->score = 100.0;
	strcpy(ss->name, "zhangsan");
}

void print_stu(struct Stu ss) {
	printf("%s %d %lf\n", ss.name, ss.age, ss.score);
}

int main() {
	struct Stu s = { 0 };
	set_stu(&s);
	print_stu(s);

	return 0;
}

注意：

ss->age === (*ss).age

12. 表达式求值

任何一个变量或者表达式都有两个属性：值属性和类型属性。

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值过程中可能需要转换为其他类型。

12.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为 整型提升。

整型提升的意义：

表达式的整型运算要在 CPU 的相应运算器件内执行，CPU 内整型运算器（ALU）的操作数的字节长度一般就是 int 的字节长度，同时也是 CPU 的通用寄存器的长度。

因此，即使两个 char 类型相加，在 CPU 执行时实际上也要先转换为 CPU 内整型操作数的标准长度。

通用 CPU（general-purpose CPU）是难以直接实现两个 8 比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于 int 长度的整型值，都必须先转换为 int 或 unsigned int，然后才能送入 CPU 去执行运算。

char a = 5;
char b = 126;
char c = a + b;

a 和 b 的值被提升为普通整型，然后再执行加法运算。

如何进行整型提升呢？

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

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

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

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

整型提升的例子：

例子 1：

char a = 5;
//0000 0000 0000 0000 0000 0000 0000 0101
//0000 0101 - a

char b = 126;
//0000 0000 0000 0000 0000 0000 0111 1110
//0111 1110 - b

char c = a + b;
//0000 0101 - a
//0000 0000 0000 0000 0000 0000 0000 0101
//0111 1110 - b
//0000 0000 0000 0000 0000 0000 0111 1110

//0000 0000 0000 0000 0000 0000 1000 0011
//1000 0011 - c

printf("%d\n", c);
//1000 0011 - c
//1111 1111 1111 1111 1111 1111 1000 0011 - 补码
//1111 1111 1111 1111 1111 1111 1000 0010
//1000 0000 0000 0000 0000 0000 0111 1101

例子 2：

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

例子 2 中的 a，b 要进行整型提升，但是 c 不需要整型提升。

a，b 整型提升之后，变成了负数，所以表达式 a==0xb6，b==0xb600 的结果是假，但是 c 不发生整型提升，则表达式 c==0xb6000000 的结果是真。

例子 3：

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

例子 3 中的 c 只要参与表达式运算，就会发生整型提升，表达式 +c，就会发生提升，所以 sizeof(+c) 是 4 个字节；表达式 -c 也会发生整型提升，所以 sizeof(-c) 是 4 个字节；但是 sizeof(c)，就是一个字节。

12.2 算术转换

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

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

如果某个操作数的类型在上面这个列表中那个排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

警告⚠：

算术转换要合理，否则会有一些潜在的问题。
float f = 3.14;
int num = f;
隐式转换，会有精度丢失。

12.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	是

一些问题表达式

表达式 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;
}

这段代码在不同的编译器下测试得到的结果均不相同，是一个非法的表达式。

代码 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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。

函数的调用先后顺序无法通过操作符的优先级确定。

代码 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 4

在 vs2013 环境的结果： 12 4

看到相同的代码产生不同的结果，这是为什么？

通过汇编代码分析得到：这段代码中的第一个 + 在执行的时候，第三个 ++ 是否执行，这是不确定的，因为依靠操作符的优先级和结合性是无法确定第一个 + 和第三个前置 ++ 的先后顺序。

总结：

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

13. 练习

练习 1：

#include <stdio.h>

int main() {
	int a, b, c;
	a = 5;
	c = ++a;
	b = ++c, c++, ++a, a++;
	b += a++ + c;
	printf("a = %d b = %d c = %d\n", a, b, c);

	return 0;
}

逗号操作符的优先级最低，因此 b = ++c; 作为一个表达式进行运算。

练习 2：

#include <stdio.h>

int i;
int main() {
	i--;
	if (i > sizeof(i)) {
		printf(">\n");
	}
	else {
		printf("<\n");
	}

	return 0;
}

sizeof() 函数返回的是无符号的整型，在进行比较时需要进行算术转换。

_Amor_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
操作符详解-C语言

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

扫一扫

专栏目录