【C语言学习】详解操作符

最新推荐文章于 2024-07-25 22:24:14 发布

embrace99

最新推荐文章于 2024-07-25 22:24:14 发布

阅读量77

点赞数

分类专栏： C语言学习文章标签： c语言学习开发语言 c# 算法 c++ 改行学it

本文链接：https://blog.csdn.net/embrace99/article/details/132157022

版权

C语言学习专栏收录该内容

25 篇文章 0 订阅

订阅专栏

C语言之所以非常灵活，很大一部分原因在于其具有丰富的操作符，甚至可以直接操作到二进制的位。

1. 二进制介绍

我们经常能听到2进制、8进制、10进制、16进制这样的讲法，那是什么意思呢？
其实2进制、8进制、10进制、16进制只是同一个数据的不同表达形式而已。而我们重点讲解2进制！
首先我们还是从10进制讲起，它也是我们生活中经常使用的：
1、10进制中满10进1。
2、10进制的数字每⼀位都是0~9的数字组成。
其实二进制也是一样的：
1、2进制中满2进1。
2、2进制的数字每⼀位都是0~1的数字组成。
例如：1101就是⼆进制的数字！

1.1 2进制转10进制的规则

10进制的123表示的值是一百二十三，为什么是这个值呢？
其实10进制的每一位是权重的，10进制的数字从右向左是个位、十位、百位…，分别每⼀位的权重是 $10^{0}、$ $10^{1}$ 、 $10^{2}$ …如下图所示：

2进制和10进制是类似的，只不过2进制的每⼀位的权重从10变为了2，从右向左是： $2^{0}$ ， $2^{1}$ ， $2^{2}$ …如下图所示：

总结：2进制转10进制采用的是乘法： $2^{0}$ + $2^{1}$ + $2^{3}$ + $2^{4}$ +…

1.2 10进制转2进制的规则

总结：10进制转2进制采用的是除法：
123/2=61…1;
62/2=31…0;
31/2=15…1;
…
把余数倒着写上去！

1.3 2进制转8进制的规则

8进制的数字每⼀位是0~7的数字，各自写成2进制，最多有3个2进制位就足够了，比如7的二进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算一个8进制位，剩余不够3个2进制位的直接换算。
例如：2进制的01101011，换成8进制：0153，0开头的数字，会被当做8进制。

1.4 2进制转16进制的规则

16进制数字的每⼀位是0~9，a~f（10～15）的数字，各⾃写成2进制，最多有4个2进制位就足够了，比如 f 的⼆进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进制位会换算⼀个16进制位，剩余不够4个⼆进制位的直接换算。如：2进制的01101011，换成16进制：0x6b，16进制表示的时候前面要加上0x。

2. 原码、反码、补码

整数的2进制表示方法有三种，即原码、反码和补码。
三种表示方法均有符号位和数值位两部分，符号位用0表示“正”，用1表示“负”。数值位最高位被当做符号位，其余的都是数值位。
正整数的原码、反码、补码都相同。
负整数的三种表示方法各不相同。
负整数原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
负整数反码：原码的符号位不变，其他位依次按位取反就可以得到反码。
负整数补码：反码+1就能得到补码。
例如：5 -5

Int a=5;（正整数三者相同）
//00000000000000000000000000000101—原码
//00000000000000000000000000000101—反码
//00000000000000000000000000000101—补码

Int b = -5;
//10000000000000000000000000000101—原码
//1111111111111111111111111111111010—反码（原码取反）
//1111111111111111111111111111111011—补码（反码+1）

对于整形来说：数据存放内存中其实存放的是补码！这是为什么呢？
其原因在于：
1.使用补码，可以将符号位和数值域统⼀处理；
2.加法和减法也可以统⼀处理（CPU只有加法器），此外，补码与原码相互转换，其运算过程是相同的，不需要额外的硬件电路。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	//1-1
	//1+(-1)
	//00000000000000000000000000000001 1的原码
	//10000000000000000000000000000001 -1的原码
	//10000000000000000000000000000010 原码相加（-2）×

	//00000000000000000000000000000001 1的补码
	//11111111111111111111111111111110 -1的反码
	//11111111111111111111111111111111 -1的补码
	//00000000000000000000000000000000 补码相加，由于2进制逢2进1，所以第一位2会缺失最终全为0！！！
	//而我们知道，1-1的结果就是0！补码运算结果正确
	return 0;
}

负整数原码和补码之间的关系：

至于原码和补码是上面这种关系，其实俺也不知道😅。因为这是计算机的科学家得出探索出的规律，在以后的实践中我们只需要用就可以了。

3. 移位操作符

移位操作符有两种：<<、>>。
<<：左移操作符；
>>:右移操作符。
注意：操作符的操作数只能是整形，而且移动的是补码，打印的是原码！！!

3.1 左移操作符

移位规则：左边抛弃，右边补0；

结果：左移前num=0，左移后num=20。
但是负数就不一样了！

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = -10;
	//原码：10000000000000000000000000001010
	//反码：11111111111111111111111111110101
	//补码：11111111111111111111111111110110
	int b = a << 1;
	//b的补码：11111111111111111111111111101100
	//取反：10000000000000000000000000010011
	//b的原码：10000000000000000000000000010100
	printf("%d\n", b);
	return 0;
}

由于负数的补码与原码不一致，需要先求得负数的补码，再进行移位操作，最后根据得到的补码找到对应的原码，然后进行打印。
结果：a= -10; b = -20

3.2 右移操作符

右移分两种：
1.逻辑右移：左边用0填充，右边丢弃。（简单粗暴，不合适）
2.算术右移：左边⽤原该值的符号位填充，右边丢弃。

可以看到，通过逻辑右移，num由负数变为了正数，太过于简单粗暴。

右移采用逻辑右移，还是算术右移，是不确定的，取决于编译器，但是大部分的编译器是采用算术右移的。
警告：不要移动负数位，因为这是没有定义的！
例如：

int num = 10;
num >> -1;

4. 位操作符：&、|、^、~

&——按位与
|——按位或
^——按位异或
注意：以上操作符的对象都是2进制，而且都是补码！

4.1 &——按位与操作符：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
		int a = 5;
		int b = -6;
		
		int c = a & b;//按位与—对应的二进制位，有0则为0，两个同时为1才是1
		//00000000000000000000000000000101— 5的补码
		//10000000000000000000000000000110
		//11111111111111111111111111111001
		//11111111111111111111111111111010— -6的补码

		//00000000000000000000000000000101
		//11111111111111111111111111111010
		//00000000000000000000000000000000
		printf("%d\n", c);
	return 0;
}

运行结果：

4.2 |——按位或操作符：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
		int a = 5;
		int b = -6;
		
		int c = a | b;//按位或—对应的二进制位上有1则为1，两个同时为0才是0
		//00000000000000000000000000000101— 5的补码
		//10000000000000000000000000000110
		//11111111111111111111111111111001
		//11111111111111111111111111111010— -6的补码

		//00000000000000000000000000000101
		//11111111111111111111111111111010
		//11111111111111111111111111111111

		printf("%d\n", c);
	return 0;
}

运行结果：

4.3 ^——按位异或操作符

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
		int a = 5;
		int b = -6;
		
		int c = a ^ b;//按位异或—对应的二进制位上相同为0，相异则为0
		//00000000000000000000000000000101— 5的补码
		//10000000000000000000000000000110
		//11111111111111111111111111111001
		//11111111111111111111111111111010— -6的补码

		//00000000000000000000000000000101
		//11111111111111111111111111111010
		//11111111111111111111111111111111

		printf("%d\n", c);
	return 0;
}

4.4 位操作符应用

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

很多小伙伴看到这道题可能傻眼了，认为这是不可能的。事实上，用我们刚才学过的 ^ 操作符就能解决，具体操作且听我娓娓道来。
我们就拿a = 3，b = 5两个数来举例。

a和b的二进制补码分别为011、101，通过a = a ^ b使得a的二进制补码变为110，b依然为101。
接着，通过b = a ^ b使得b的二进制补码变为011，此时我们可以看到b已经变为了3（正整数的原码、补码一致），在进行一次a^b，就能把a变为5。
代码实现如下：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 3;
	int b = 5;
	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;
}

运行结果：

在这里我用的是整数来举例说明，如果感兴趣的话，小伙伴们也可以用负整数来试试，结果肯定是正确的。
但是以上这种异或操作也存在一定局限性：
1.只能作用于整数的交换
2.代码的可读性差
3.代码执行的效率也低于使用第3个变量的方法

4.4.2 ⼀个整数存储在内存中的2进制中1的个数

在解决这个问题前，我们可以回想一下我们得到10进制每一位的操作方法：
在这里插入图片描述
通过不断的%10，/10操作，就能得到10进制整数的每一位，同样的我们可以将这个规律进行推广。如果我们对10进制数进行%2、/2操作，是不是就能得到它2进制中1的个数了呢？
在这里我们用15来举例：

显然，我们能够得到15的2进制中1的个数。
代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 0;
	int count = 0;
	scanf("%d", &a);
	while (a)
	{
		if (a % 2 == 1)
		{
			count++;
		}
		a = a / 2;
	}
	printf("%d\n", count);
	return 0;
}

运行结果：

这段代码有没有问题呢？实际上，这段代码是有问题的，如果我们输入负数，那么结果就是错误的！
就比如说，我们拿-1来举例说明：

我们都知道-1的二进制中有32个1，但是结果却显示0，这是为什么呢？
原因其实很简单，a = -1的时候，进入while循环里面，a % 2 != 1，count依然为0。a / 2 ==0，跳出while循环，打印结果就是count = 0。
既然找到了原因，那我们该如何解决呢？其实我们可以采用 >> 操作符解决问题。
修改后的代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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

运行结果：

除了上面两种方法以外，还有一种方法，我也称它为终极方法，也是科技巨头Google的面试解题方法👍👍👍
在给出代码之前，还是按照惯例给大家介绍它的核心思想：
在这里插入图片描述
代码实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 0;
	int i = 0;
	int count = 0;
	scanf("%d", &a);
	while (a)
	{
		a = a & (a - 1);
		count++;
	}
	printf("%d\n", count);
	return 0;
}

运行结果：

4.4.3 n&(n-1)拓展

除了上述例子实例外，n&(n-1)也可以被用来判断一个数是否为 $2^n$ ：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 0;
	int i = 0;
	scanf("%d", &a);
	if ((a&(a - 1)) == 0)
	{
		printf("yes\n");
	}
	else
	{
		printf("no\n");
	}
	return 0;
}

运行结果：

4.5 ~—按位取反操作符（二进制是0的变成1，是1的变为0，连最前面的符号位也得取反）

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 13;
	//00000000000000000000000000001101
	//00000000000000000000000000010000
	//1<<4
	a = a | (1 << 4);
	printf("%d\n", a);
	return 0;
}

运行结果：

把a改回来：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 13;
	//00000000000000000000000000001101
	//00000000000000000000000000010000
	//1<<4
	a = a | (1 << 4);
	printf("a=%d\n", a);
	//00000000000000000000000000011101
	//11111111111111111111111111101111
	//00000000000000000000000000001101
	a = a & ~(1 << 4);
	printf("a=%d\n", a);
	return 0;
}

运行结果：

5. 逗号表达式

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	int a = 1;
	int b = 2;
	int c = (a>b, a = b + 10, a, b = a + 1);
	printf("%d\n", c);
	return 0;
}

运行结果：

6. 下标访问[]，函数调用()

6.1 下标引用操作符[]

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

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};//创建数组
printf("%d\n", arr[9]};//[]—下标引⽤操作符。
[]的两个操作数是arr和9

6.2 函数调用操作符()

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

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int add(int x, int y)
{
	return x + y;
}

void test()
{
	printf("haha\n");
}

int main()
{
	int ret = add(2, 3);//()—函数调用操作符
	//()的操作数：add，2，3
	printf("%d\n", ret);
	test();//()—函数调用操作符
	return 0;
}

函数调用操作符最少有几个操作数呢？
很显然，最少保证1个操作数，这个操作数就是函数名！

7. 操作符的属性

C语言的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。

7.1 优先级

什么是优先级呢？
优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先被执行。各种运算符的优先级是不⼀样的。
例如：

13 + 4 * 5;

在上面的示例中，表达式13 + 4 * 5 里面既有加法运算符（ + ），又有乘法运算符（ * ）。由于乘法的优先级要高于加法，所以会先计算 4 * 5，而不是先计算 3 + 4。

7.2 结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个，这时候就看结合性了，即根据运算符是左结合，还是右结合，决定执行顺序。目前来说，大部分运算符是左结合（从左到右执行），少数运算符是右
结合（从右到左执行），比如赋值运算符（ = ）。
例如：

15 * 6 / 2;

上述示例中，* 和 / 的优先级相同，它们都是左结合运算符，所以要从左到右执行，先计算 5 * 6 ，再计算 6 / 2 。运算符的优先级顺序很多，下⾯是部分运算符的优先级顺序（按照优先级从高到低排列），大概记住这些操作符的优先级就行，其他的操作符在使用的时候查看后面的表格就行了。
1.圆括号（ () ）
2.自增运算符（ ++ ），自减运算符（ – ）
3.⼀元运算符（ + 和 - ）
4.乘法（ * ），除法（ / ）
5.加法（ + ），减法（ - ）
6.关系运算符（ < 、 > 等）
7.赋值运算符（ = ）
由于圆括号的优先级最高，因此可以用它来改变其他运算符的优先级。
其他运算符优先顺序表：
在这里插入图片描述

8. 表达式求值

表达式求值之前要进行类型转换，只有表达式中的值转换到适当的类型，才开始计算！
C语言中数值的类型转换有两种，分别是整形提升和算术转换。

8.1 整形提升

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

8.1.1 为什么要进行整形提升？

表达式的整型运算要在CPU的相应运算器件内执⾏，CPU内整型运算器(ALU)的操作数的字节⻓度⼀般就是int的字节⻓度，同时也是CPU的通用寄存器的长度。因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为 int或unsigned int，然后才能送⼊CPU去执行运算。
读完这段话，相信各位小伙伴都比较懵圈😂。没关系，下面我就以两个char类型的变量相加为例（char a，char b），来对上面这段话进行解释。

上面这幅图就非常清晰地向我们解释了为什么要进行整形提升，说白了其目的就是为了保留数据的精度。两个char类型的数字相加，可能发生进位，导致数据丢失。而如果都转化成为int 类型的变量，假设放入char类型的变量，也只占8个bit位，即使相加发生进位，也只是溢出到前一位上，数据也不会丢。它的精度就可能保留了！
例如：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char a = 5;
	char b = 127;
	char c = a + b;
	printf("%d\n", c);
	return 0;
}

运行结果：

至于为什么是-124，后面会进行解释，在这儿先卖个关子😋。

8.1.2 如何进行整形提升？

如何进行整数提升分为两种情况：有符号整数提升、无符号整数提升。
（一）有符号整数提升
有符号整数提升是按照变量的数据类型的符号位来提升的。
例如我们刚才所举的例子：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char a = 5;
	//5 — int — 32bit
	//00000000000000000000000000000101
	//00000101 — a（截断后存储到a中）
	
	char b = 127;
	//00000000000000000000000001111111
	//01111111 — b（截断后存储到b中）
	
	char c = a + b;//发生整形提升
	//00000000000000000000000000000101 — a
	//00000000000000000000000001111111 — b
	//00000000000000000000000010000100 — a+b
	//10000100 — c
	
	printf("%d\n", c);//这里c还要提升
	//11111111111111111111111110000100 — 补码
	//10000000000000000000000001111011 — 反码
	//10000000000000000000000001111100 — 原码
	//-124
	return 0;
}

（二）无符号整数提升
无符号整数提升用的比较少，而且方法也比较简单，直接在高位补0即可。
这里我就不再用加法举例了，直接用%d打印char类型的数值：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	unsigned char b = -1;
	//10000001 — 原码
	//11111110 — 反码
	//11111111 — 补码

	printf("%d\n", b);//整形提升，高位补0
	//00000000000000000000000011111111 — 补码
	//00000000000000000000000011111111 — 反码
	//00000000000000000000000011111111 — 原码
	//正数原码、反码和补码一样
	//255
	return 0;
}

运行结果：

8.2 算术转换

讲完整形提升，接下来我们再来讲一下算术转换。
按照惯例，我们先介绍算术转换的概念：如果某个操作的各个操作数属于不同的类型，除非其中⼀个操作数转换为另⼀个操作数的类型，否则操作就无法进行。而一种操作数转换为另一种操作数的过程就叫做算术转换。
既然我们操作数需要转换为另一种操作数，我们就不可避免地要面对转换的次序问题。下面的层次体系称为寻常算术转换。
在这里插入图片描述
如果某个操作数的类型在上面这个列表中排名靠后，那么首先要转换为另外⼀个操作数的类型后执行运算。
写到这儿，这期博客差不多就完成了，但是我还是想给大家介绍一下几个问题表达式，感兴趣的小伙伴可以接着往下看😊。

9. 问题表达式

9.1 表达式1

a*b + c*d + e*f

表达式1在计算的时候，由于 * 比 + 的优先级高，只能保证 * 的计算是比 + 早，但是优先级并不能决定第三个 * 比第⼀个 + 早执行。所以表达式1的计算机顺序就可能存在以下两种情况：
顺序1：

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

顺序2：

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

9.2 表达式2

c + --c;

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

9.3 表达式3

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
	int i = 10;
	i = i-- - --i * (i = -3) * i++ + ++i;
	printf("i = %d\n", i);
	return 0;
}

这段代码是《C和指针》这本书的作者测试的，这段代码同样存在歧义。具体有哪些歧义，感兴趣的小伙伴可以试着解答一下😁。
在各种编译器下运行，得到不同的结果如下：

总结：即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯⼀的。计算路径，那这个表达式就是存在潜在风险的，建议不要写出特别负责的表达式。

embrace99

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【C语言学习】详解操作符

我们经常能听到2进制、8进制、10进制、16进制这样的讲法，那是什么意思呢？其实2进制、8进制、10进制、16进制只是同一个数据的不同表达形式而已。而我们重点讲解2进制！首先我们还是从10进制讲起，它也是我们生活中经常使用的：1、10进制中满10进1。2、10进制的数字每⼀位都是0~9的数字组成。其实二进制也是一样的：1、2进制中满2进1。2、2进制的数字每⼀位都是0~1的数字组成。例如：1101就是⼆进制的数字！
复制链接

扫一扫