41.位运算

所谓位运算，就是对一个比特（Bit）位进行操作。比特（Bit）是一个电子元器件，8个比特构成一个字节（Byte），它已经是粒度最小的可操作单元了。

C语言提供了六种位运算符：

运算符	&	\|	^	~	<<	>>
说明	按位与	按位或	按位异或	取反	左移	右移

一、按位与运算（&）

一个比特（Bit）位只有 0 和 1 两个取值，只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似。

C语言中不能直接使用二进制，&两边的操作数可以是十进制、八进制、十六进制，它们在内存中最终都是以二进制形式存储，&就是对这些内存中的二进制位进行运算。其他的位运算符也是相同的道理。

例如，9 & 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在内存中的存储）

也就是说，按位与运算会对参与运算的两个数的所有二进制位进行&运算，9 & 5的结果为 1。

又如，-9 & 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）

-9 & 5的结果是 5。

再强调一遍，&是根据内存中的二进制位进行运算的，而不是数据的二进制形式；其他位运算符也一样。以-9&5为例，-9 的在内存中的存储和 -9 的二进制形式截然不同：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （-9 的二进制形式，前面多余的 0 可以抹掉）

按位与运算通常用来对某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以进行n & 0XFFFF运算（0XFFFF 在内存中的存储形式为 0000 0000 -- 0000 0000 -- 1111 1111 -- 1111 1111）。

【实例】对上面的分析进行检验。

#include <stdio.h>


int main(){
int n = 0X8FA6002D;
printf("%d, %d, %X\n", 9 & 5, -9 & 5, n & 0XFFFF);
return 0;
}

运行结果：
1, 5, 2D

二、按位或运算（|）

参与|运算的两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为1，0|0为0，1|0为1，这和逻辑运算中的||非常类似。

例如，9 | 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 （13 在内存中的存储）

9 | 5的结果为 13。

又如，-9 | 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）

-9 | 5的结果是 -9。

按位或运算可以用来将某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以进行n | 0XFFFF0000运算（0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000）。

【实例】对上面的分析进行校验。

#include <stdio.h>


int main(){
int n = 0X2D;
printf("%d, %d, %X\n", 9 | 5, -9 | 5, n | 0XFFFF0000);
return 0;
}

运行结果：
13, -9, FFFF002D

三、按位异或运算（^）

参与^运算两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为1，0^0为0，1^1为0。

例如，9 ^ 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 （12 在内存中的存储）

9 ^ 5的结果为 12。

又如，-9 ^ 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 （-14 在内存中的存储）

-9 ^ 5的结果是 -14。

按位异或运算可以用来将某些二进制位反转。例如要把 n 的高 16 位反转，保留低 16 位，可以进行n ^ 0XFFFF0000运算（0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000）。

【实例】对上面的分析进行校验。

#include <stdio.h>


int main(){
unsigned n = 0X0A07002D;
printf("%d, %d, %X\n", 9 ^ 5, -9 ^ 5, n ^ 0XFFFF0000);
return 0;
}

运行结果：
12, -14, F5F8002D

四、取反运算（~）

取反运算符~为单目运算符，右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似。。

例如，~9可以转换为如下的运算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 （-10 在内存中的存储）

所以~9的结果为 -10。

例如，~-9可以转换为如下的运算：

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 （8 在内存中的存储）

所以~-9的结果为 8。

【实例】对上面的分析进行校验。

#include <stdio.h>


int main(){
printf("%d, %d\n", ~9, ~-9 );
return 0;
}

运行结果：
-10, 8

五、左移运算（<<）

左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补0。

例如，9<<3可以转换为如下的运算：

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 （72 在内存中的存储）

所以9<<3的结果为 72。

又如，(-9)<<3可以转换为如下的运算：

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 （-72 在内存中的存储）

所以(-9)<<3的结果为 -72

如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。

【实例】对上面的结果进行校验。

#include <stdio.h>


int main(){
printf("%d, %d\n", 9<<3, (-9)<<3 );
return 0;
}

运行结果：
72, -72

六、右移运算（>>）

右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1。

例如，9>>3可以转换为如下的运算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在内存中的存储）

所以9>>3的结果为 1。

又如，(-9)>>3可以转换为如下的运算：

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 （-2 在内存中的存储）

所以(-9)>>3的结果为 -2

如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方（但被移除的位中经常会包含 1）。

【实例】对上面的结果进行校验。

#include <stdio.h>


int main(){
printf("%d, %d\n", 9>>3, (-9)>>3 );
return 0;
}

运行结果：
1, -2

1. 预备知识

认识二进制，十六进制。会二进制与十进制的相互转化运算由计算机的硬件决定，任何存储于计算机中的数据，其本质都是以二进制码存储。

根据冯~诺依曼提出的经典计算机体系结构框架。一台计算机由运算器，控制器，存储器，输入和输出设备组成。其中运算器，只有加法运算器，没有减法运算器（据说一开始是有的，后来由于减法器硬件开销太大，被废了）所以，计算机中的没法直接做减法的，它的减法是通过加法来实现的。你也许会说，现实世界中所有的减法也可以当成加法的，减去一个数，可以看作加上这个数的相反数。当然没错，但是前提是要先有负数的概念。这就为什么不得不引入一个该死的符号位。

1. 而且从硬件的角度上看，只有正数加负数才算减法。2. 正数与正数相加，负数与负数相加，其实都可以通过加法器直接相加。原码，反码，补码的产生过程，就是为了解决，计算机做减法和引入符号位（正号和负号）的问题。

2. 正数位移运算

有三个位移运算：

<<：左移>>：右移>>>：无符号右移

我们来举一个栗子:

public class test {public static void main(String[] args){ System.out.println(3 <<1);// 6 System.out.println(3 >>1);// 1 System.out.println(3 >>>1);// 1 System.out.println(-3 <<1);// -6 System.out.println(-3 >>1);// -2 System.out.println(-2 >>>1);// 2147483647 }}

是不是一眼看到上面栗子的打印结果，是不是很懵逼，下来我来解释一下这个结果到底是如何运算出来的。

上面的栗子中有“3”和“-3”，这是两个十进制数，并且是int类型的(java中占四个字节)，位运算是基于二进制bit来的，所以我们需要将十进制转换为二进制之后再进行运算：

3 >> 1：十进制“3”转换成二进制为“00000000 00000000 00000000 00000011”，再将二进制右移一位，低位丢弃，高位补0，所以结果为“00000000 00000000 00000000 00000001”，换算成十进制则为“1”3 << 1：十进制“3”转换成二进制为“00000000 00000000 00000000 00000011”，再将二进制左移一位，高位丢弃，低位补0，所以结果为“00000000 00000000 00000000 00000110”，换算成十进制则为“6”对于这两种情况非常好理解，那什么是无符号右移，以及负数是怎么运算的呢？我们先来看-3 << 1与-3 >> 1，这两个负数的左移与右移操作其实和正数类似，都是先将十进制数转换成二进制数，再将二进制数进行移动，所以现在的关键是负数如何用二进制数进行表示。3. 原码、反码、补码

接下来我们主要介绍十进制数用二进制表示的不同方法，所以为了简洁，我们用一个字节，也就是8个bit来表示二进制数。

1. 原码

最高位为符号位，0代表正数，1代表负数，非符号位为该数字绝对值的二进制表示。

原码其实是最容易理解的，只不过需要利用二进制中的第一位来表示符号位，0表示正数，1表示负数，所以可以看到，一个数字用二进制原码表示的话，取值范围是-111 1111 ~ +111 1111，换成十进制就是-127 ~ 127

2. 反码

正数的反码与原码一致；负数的反码是对原码按位取反，只是最高位(符号位)不变。

如果计算机内部采用原码来表示数，那么在进行加法和减法运算的时候，需要转化为两个绝对值的加法和减法运算；计算机既要实现加法器，又要实现减法器，代价有点大，那么可不可以只用一种类型的运算器来实现加和减的远算呢？

很容易想到的就是化减为加，对于计算机来说最好只有加法这样计算机会更加简单高效，我们知道在数学中5-3=2，其实可以转换成5+(-3)=2，这就表示减法可以用加法表示，而乘法是加法的累积，除法是减法的累积，所以在计算机中只要有加法就够了。

一个数字用原码表示是容易理解的，但是需要单独的一个bit来表示符号位。并且在进行加法时，计算机需要先识别某个二进制原码是正数还是负数，识别出来之后再进行相应的运算。这样效率不高，能不能让计算机在进行运算时不用去管符号位，也就是说让符号位也参与运算，这就要用到反码。

正数的反码和原码一样，负数的反码就是在原码的基础上符号位保持不变，其他位取反。

那么我们来看一下，用反码直接运算会是什么情况，我们以5-3举例。

5 - 3等于5 + (-3)

5-3= 5+(-3)= 0000 0101(反码) + 1111 1100(反码)= 0000 0001(反码)= 0000 0001(原码)= 1

这不对呀?!! 5-3=1?，为什么差了1？

我们来看一个特殊的运算：

1-1= 1+(-1)= 0000 0001(反码) + 1111 1110(反码)= 1111 1111(反码)= 1000 0000(原码)= -0

我们在来看一个特殊的运算：

0+0= 0000 0000(反码) + 0000 0000(反码)= 0000 0000(反码)= 0000 0000(原码)= 0

我们可以看到1000 0000表示-0，0000 0000表示0，虽然-0和0是一样的，但是在用原码和反码表示时是不同的，我们可以理解为在用一个字节表示数字取值范围时，这些数字中多了一个-0，所以导致我们在用反码直接运算时符号位可以直接参加运算，但是结果会不对。

3. 补码

为了解决反码的问题就出现了补码。

正数的补码与原码一致；

负数的补码是该数的反码加1。

正数的补码和原码、反码一样，负数的补码就是反码+1。

5-3= 5+(-3)= 0000 0101(补码) + 1111 1101(补码)= 0000 0010(补码)= 0000 0010(原码)= 2

5-3=2！！正确。

再来看特殊的：

1-1= 1+(-1)= 0000 0001(补码) + 1111 1111(补码)= 0000 0000(补码)= 0000 0000(原码)= 0

1-1=0！！正确

再来看一个特殊的运算：

0+0= 0000 0000(补码) + 0000 0000(补码)= 0000 0000(补码)= 0000 0000(原码)= 0

0+0=0！！也正确。

所以，我们可以看到补码解决了反码的问题。

所以对于数字，我们可以使用补码的形式来进行二进制表示。

总结一下就是：

正数的原码、反码、补码是一致的；负数的补码是反码加1，反码是对原码按位取反，只是最高位(符号位)不变；计算机数字运算均是基于补码的。补码有啥好？

如果计算机内部采用原码来表示数，那么在进行加法和减法运算的时候，需要转化为两个绝对值的加法和减法运算；

计算机既要实现加法器，又要实现减法器，代价有点大，那么可不可以只用一种类型的运算器来实现加和减的远算呢？

很容易想到的就是化减为加，举一个生活中的例子来说明这个问题：

时钟一圈是360度，当然也存在365度，但其实它和5度是一样的；

相同的道理，-30度表示逆时针旋转30度，其与顺时针旋转330度是一样的；

这里数字360表示时钟的一圈，在计算机里类似的概念叫模，它可以实现化减为加，本质上是将溢出的部分舍去而不改变结果。

易得，单字节(8位)运算的模为256=2^8。

在没有符号位的情况下，127+2=129，即：

这时，我们将最高位作为符号位，计算机数字均以补码来表示，则1000 0001的原码为减1后按位取反得1111 1111，也就是-127。

也就是说，计算机里的129即表示-127，相当于模256为一圈，顺时针的129则和逆时针127即-127是一样的。

故可以得到以下结论：

负数的补码为模减去该数的绝对值。

如-5的补码为：

-5=256-5=251=1111 1011(二进制)

同样的，临界值-128也可以表示出来：

-128=256-128=128=1000 0000(二进制)

但是正128就会溢出了，故单字节(8位)表示的数字范围为-128--127。

最后，我们来看一下，补码是如何通过模的溢出舍弃操作来完成化减为加的！

16-5=16+(-5)=11

1 0000 1011将溢出位舍去，得0000 1011(二进制)=11。

4. 负数位移运算

我们再来看

-3 << 1

与

-3 >> 1

。

-3用原码表示为

10000000 00000000 00000000 00000011

-3用反码表示为

11111111 11111111 11111111 11111100

-3用补码表示为

11111111 11111111 11111111 11111101

-3 << 1

，表示-3的补码左移一位后为

11111111 11111111 11111111 11111010

，该补码对应的反码为

11111111 11111111 11111111 11111010-1= 11111111 11111111 11111111 11111001

该反码对应的原码为：符号位不变，其他位取反，为

10000000 00000000 00000000 00000110

，表示-6。

所以

-3 << 1 = -6

。

同理

-3 >> 1

是一样的计算方法，这里就不演示了。

5. 无符号右移

上面在进行左移和右移时，我有一点没讲到，就是在对补码进行移动时，符号位是固定不动的，而无符号右移是指在进行移动时，符号位也会跟着一起移动。

比如

-2 >>> 1

。

-2用原码表示为

10000000 00000000 00000000 00000010

-2用反码表示为

11111111 11111111 11111111 11111101

-2用补码表示为

11111111 11111111 11111111 11111110

-2的补码右移1位为：

01111111 11111111 11111111 11111111

右移后的补码对应的反码、原码为：

01111111 11111111 11111111 11111111

（因为现在的符号位为0，表示正数，正数的原、反、补码都相同）

所以，对应的十进制为2147483647。

也就是

-2 >>> 1 = 2147483647

6. 总结

3 << 1 = 6 = 3*2

3 << 2 = 12 = 3*2*2

3 << n = 3*2n

m << n = m * 2n

右移则相反，所以以后在源码中再看到位运算时，可以参考上面的公式。

posted @ 2022-03-22 20:24 随遇而安== 阅读(74) 评论(0) 编辑收藏举报

刷新页面返回顶部

root@su