单片机的位操作知识

void main(void)
{
	while (1)
	{
		gLed1 = 0;			// 点亮LED
		Delay();			// 延时一段时间
		gLed1 = 1;			// 熄灭LED
		Delay();			// 延时一段时间
	}		
}

void FlashLed1(void)
{
	LED_PORT = 0x7f;			// 0b01111111，左边数第1颗LED亮其他灭
	Delay();
	
	LED_PORT = 0xbf;			// 0b10111111，左边数第2颗LED亮其他灭
	Delay();
 
	LED_PORT = 0xdf;			// 0b11011111，左边数第3颗LED亮其他灭
	Delay();
 
	LED_PORT = 0xef;			// 0b11101111，左边数第4颗LED亮其他灭
	Delay();
 
	LED_PORT = 0xf7;			// 0b11110111，左边数第5颗LED亮其他灭
	Delay();
 
	LED_PORT = 0xfb;			// 0b11111011，左边数第6颗LED亮其他灭
	Delay();
 
	LED_PORT = 0xfd;			// 0b11111101，左边数第7颗LED亮其他灭
	Delay();
 
	LED_PORT = 0xfe;			// 0b11111110，左边数第8颗LED亮其他灭
	Delay();
}
void FlashLed2(void)
{
	unsigned char i = 0;/*为什么要是unsigned char呢？原因是51单片机是8位处理器，而unsigned char也是8位，所以要注意51单片机编程时数字不能超过255（因为加上0是256个数）*/
	for (i=0; i<8; i++)
	{
		LED_PORT  = (0xff & ~(1<<i));/*这段代码中用到了c语言位操作的知识下面有文章讲解
		Delay();//这里是使用了delay函数下面有delay函数
	}
}
void Delay(void)//delay函数
{
	unsigned char i = 0, j = 0, k = 0;
	
	for (i=0; i<50; i++)//注意变量的值不能超过255否则会数据溢出
		for (j=0; j<50; j++)
			for (k=0; k<50; k++);	
}

位操作符
1.位与&
1、注意：位与符号是一个&，两个&&是逻辑与。
2、真值表：1&0=01&1=10&0=00&1=0
3、从真值表可以看出：位与操作的特点是，只有1和1位与结果为1，其余全是0.
4、位与和逻辑与的区别：位与时两个操作数是按照二进制位彼次对应位相与的，逻辑与是两个操作数作为整体来相与的。（举例：0xAA&0xF0=0xA0,0xAA && 0xF0=1）

2.位或|
1、注意：位或符号是一个|，两个||是逻辑或。
2、真值表：1|0=11|1=10|0=00|1=1
3、从真值表可以看出：位或操作的特点是：只有2个0相位或才能得到0，只要有1个1结果就一定是1.
4、位或和逻辑或的区别：位或时两个操作数是按照二进制位彼次对应位相与的，逻辑或是两个操作数作为整体来相或的。

3.位取反~
1、注意：C语言中位取反是~，C语言中的逻辑取反是!
2、按位取反是将操作数的二进制位逐个按位取反（1变成0，0变成1）；而逻辑取反是真（在C语言中只要不是0的任何数都是真）变成假（在C语言中只有0表示假）、假变成真。
实验：

#include <stdio.h>
void main()
{
        int a = 5; // 结果 ：
        printf("~~a = %d.n",~~a);//~~a = 5.
        printf("!!a = %d.n",!!a);//!!a = 1.
}

结论：

@任何非0的数被按位取反再取反就会得到他自己；任何非0的数被按逻辑取反再取反就会得到1；

@任何非0的数被按逻辑取反再取反就会得到1；

4.位异或^
1、位异或真值表：

1^1=0

0^0=0

1^0=1

0^1=1

2、位异或的特点：2个数如果相等结果为0，不等结果为1。

记忆方法：异或就是相异就或操作起来。

位与、位或、位异或的特点总结：
位与：（任何数，其实就是1或者0）与1位与无变化，与0位与变成0
位或：（任何数，其实就是1或者0）与1位或变成1，与0位或无变化
位异或：（任何数，其实就是1或者0）与1位异或会取反，与0位异或无变化

5.左移位<< 与右移位>>
C语言的移位要取决于数据类型。
对于无符号数，左移时右侧补0（相当于逻辑移位）
对于无符号数，右移时左侧补0（相当于逻辑移位）

对于有符号数，左移时右侧补0（叫算术移位，相当于逻辑移位）

对于有符号数，右移时左侧补符号位（如果正数就补0，负数就补1，叫算术移位）
实验：

#include <stdio.h>

void main()
{
int a = 5; // 0101b
int b = -5;// 1...0101b
printf("a<<2 = %d.n",a<<2);
printf("a>>2 = %d.n",a>>2);
printf("b<<2 = %d.n",b<<2);
printf("b>>2 = %d.n",b>>2);
}

结果：

a<<2 = 20.
a>>2 = 1.
b<<2 = -20.
b>>2 = -2.

结论：

左移一位，结果*2；

右移一位，结果/2；

注释:有符号数右移结果往小的那边走，-5/4=-1.25->-2；

分析过程自己去分析数值在计算机内部的存储(以补码形式存储！)

~嵌入式中研究的移位，以及使用的移位都是无符号数

位与位或位异或在操作寄存器时的特殊作用
1.寄存器操作的要求（特定位改变而不影响其他位）
1、ARM是内存与IO统一编址的，ARM中有很多内部外设，SoC中CPU通过向这些内部外设的寄存器写入一些特定的值来操控这个内部外设，进而操控硬件动作。所以可以说：读写寄存器就是操控硬件。
2、寄存器的特点是按位进行规划和使用。但是寄存器的读写却是整体32位一起进行的（也就是说你只想修改bit5～bit7是不行的，必须整体32bit全部写入）
3、寄存器操作要求就是：在设定特定位时不能影响其他位。
4、如何做到？答案是：读-改-写三部曲。
读改写的操作理念，就是：当我想改变一个寄存器中某些特定位时，我不会直接去给他写，我会先读出寄存器整体原来的值，然后在这个基础上修改我想要修改的特定位，再将修改后的值整体写入寄存器。
这样达到的效果是：在不影响其他位原来值的情况下，我关心的位的值已经被修改了。

2.特定位清零用&
1、回顾上面讲的位与操作的特点：（任何数，其实就是1或者0）与1位与无变化，与0位与变成0
2、如果希望将一个寄存器的某些特定位变成0而不影响其他位，可以构造一个合适的1和0组成的数和这个寄存器原来的值进行位与操作，就可以将特定位清零。
3、举例：

假设原来32位寄存器中的值为：0xAAAAAAAA，我们希望将bit8～bit15清零而其他位不变，可以将这个数与0xFFFF00FF进行位与即可。

#include <stdio.h>
void main()
{
printf("0x%X.n",0xAAAAAAAA&0xFFFF00FF);// 0xAAAA00AA.
}

3.特定位置1用|
1、回顾上面讲的位或操作的特点：任何数，其实就是1或者0）与1位或变成1，与0位或无变化
2、操作手法和刚才讲的位与是类似的。我们要构造这样一个数：要置1的特定位为1，其他位为0，然后将这个数与原来的数进行位或即可。

3、举例：

假设原来32位寄存器中的值为：0xAAAAAAAA，我们希望将bit8～bit15置1而其他位不变，可以将这个数与0x0000FF00进行位或即可。

#include <stdio.h>
void main()
{
printf("0x%X.n",0xAAAAAAAA|0x0000FF00);// 0xAAAAFFAA.
}

4.特定位取反用^
1、回顾上面讲的位异或操作的特点：（任何数，其实就是1或者0）与1位异或会取反，与0位异或无变化
2、操作手法和刚才讲的位与是类似的。我们要构造这样一个数：要取反的特定位为1，其他位为0，然后将这个数与原来的数进行位异或即可。
进行位或即可。

3、举例：

假设原来32位寄存器中的值为：0xAAAAAAAA，我们希望将bit8～bit15取反而其他位不变，可以将这个数与0x0000FF00进行异或即可。

#include <stdio.h>
void main()
{
printf("0x%X.n",0xAAAAAAAA^0x0000FF00);// 0xAAAA55AA.
}

如何用位运算构建特定二进制数
1.寄存器位操作经常需要特定位给特定值
1、从上节可知，对寄存器特定位进行置1或者清0或者取反，关键性的难点在于要事先构建一个特别的数，这个数和原来的值进行位与、位或、位异或等操作，即可达到我们对寄存器操作的要求。
2、

解法1：用工具软件或者计算器或者自己大脑计算，直接给出完整的32位特定数。

优势：可以完成工作，难度也不大，操作起来也不是太麻烦。
劣势：依赖工具，而且不直观，读程序的人不容易理解。
评价：凑活能用，但是不好用，应该被更好用的方法替代。
3、解法2：自己写代码用位操作符号（主要是移位和位取反）来构建这个特定的二进制数

2.使用移位获取特定位为1的二进制数
1、最简单的就是用移位来获取一个特定位为1的二进制数。譬如我们需要一个bit3～bit7为1（隐含意思就是其他位全部为0）的二进制数，可以这样：(0x1f<<3)
2、更难一点的要求：获取bit3～bit7为1，同时bit23～bit25为1，其余位为0的数：((0x1f<<3) | (7<<23))

3.再结合位取反获取特定位为0的二进制数
1、这次我们要获取bit4～bit10为0，其余位全部为1的数。怎么做？
2、利用上面讲的方法就可以：(0xf<<0)|(0x1fffff<<11)

但是问题是：连续为1的位数太多了，这个数字本身就很难构造，所以这种方法的优势损失掉了。

3、这种特定位（比较少）为0而其余位（大部分）为1的数，不适合用很多个连续1左移的方式来构造，适合左移加位取反的方式来构造。
4、思路是：先试图构造出这个数的位相反数，再取反得到这个数。
（譬如本例中要构造的数bit4～bit10为0其余位为1，那我们就先构造一个bit4～bit10为1，其余位为0的数，然后对这个数按位取反即可）- ~(0x7f<<4)

4.总结：位与、位或结合特定二进制数即可完成寄存器位操作需求
1、如果你要的这个数比较少位为1，大部分位为0，则可以通过连续很多个1左移n位得到。
2、如果你想要的数是比较少位为0，大部分位为1，则可以通过先构建其位反数，然后再位取反来得到。
3、如果你想要的数中连续1（连续0）的部分不止1个，那么可以通过多段分别构造，然后再彼此位或即可。

这时候因为参与位或运算的各个数为1的位是不重复的，所以这时候的位或其实相当于几个数的叠加。

位运算实战演练1
回顾：要置1用|，用清零用&，要取反用^，~和<< >>用来构建特定二进制数。
1.给定一个整型数a，设置a的bit3，保证其他位不变。
a = a | (1<<3)或者 a |= (1<<3)

2.给定一个整形数a，设置a的bit3~bit7，保持其他位不变。
a = a | (0b11111<<3)或者 a |= (0x1f<<3);

3.给定一个整型数a，清除a的bit15，保证其他位不变。
a = a & (~(1<<15));或者 a &= (~(1<<15));

4.给定一个整形数a，清除a的bit15~bit23，保持其他位不变。
a = a & (~(0x1ff<<15));或者 a &= (~(0x1ff<<15));

5.给定一个整形数a，取出a的bit3~bit8。
思路：
第一步：先将这个数bit3～bit8不变，其余位全部清零。
第二步，再将其右移3位得到结果。
第三步，想明白了上面的2步算法，再将其转为C语言实现即可。
a &= (0x3f<<3);
a >>= 3;

6.用C语言给一个寄存器的bit7～bit17赋值937（其余位不受影响）。
关键点：第一，不能影响其他位；第二，你并不知道原来bit7～bit17中装的值。
思路：

第一步，先将bit7～bit17全部清零，当然不能影响其他位。

第二步，再将937写入bit7～bit17即可，当然不能影响其他位。

a &= ~(0x7ff<<7);

a |= (937<<7);

位运算实战演练2
1.用C语言将一个寄存器的bit7～bit17中的值加17（其余位不受影响）。
关键点：不知道原来的值是多少
思路：

第一步，先读出原来bit7～bit17的值

第二步，给这个值加17
第三步，将bit7～bit17清零
第四步，将第二步算出来的值写入bit7～bit17
tmp = a&(0x7ff<<7);

tmp>>=7;

tmp+=17;

a &=~(0x7ff<<7);

a|=(tmp<<7);

2.用C语言给一个寄存器的bit7～bit17赋值937，同时给bit21～bit25赋值17.
思路：6.的升级版，两倍的6.中的代码即可解决。
分析：这样做也可以，但是效果不够高，我们有更优的解法就是合两步为一步。
a &= ~((0x7ff<<7) | (0x1f<<21));

a |= ((937<<7) | (0x17<<21))

技术升级：用宏定义来完成位运算
1.直接用宏来置位、复位（最右边为第1位）
#define SET_NTH_BIT(x, n) (x | (1<<(n-1)))
#define CLEAR_NTH_BIT(x, n) (x & ~(1<<(n-1)))

2.截取变量的部分连续位。例如：变量0x88, 也就是0b10001000，若截取第2～4位，则值为：0b100 = 4

#define GETBITS(x, n, m) ((x & ₍(0U)<<(m-n+1))<<(n-1)) >> (n-1))
分析：这个题目相当于我们位运算实战演练1中5.做的事情，只不过要用宏来实现。
这个题目相当于是要把x的bit(n-1)到bit(m-1)取出来

注：优先级~ 高于 <<高于&

#define GETBITS(x, n, m) ((x & (₍(0U)<<(m-n+1))<<(n-1))) >> (n-1))

U表示unsigned int-32

复杂宏怎么分析：
((x & ₍(0U)<<(m-n+1))<<(n-1)) >> (n-1))

第一步，先分清楚这个复杂宏分为几部分：2部分

@(x & ₍(0U)<<(m-n+1))<<(n-1))

@>>(n-1)

分析为什么要>>(n-1)，相当于是我们5.中的第二步（第二步，再将其右移3位得到结果。）

第二步，继续解析剩下的：又分为2部分
@x&

@₍(0U)<<(m-n+1))<<(n-1)

分析为什么要&，相当于我们5中的第一步 (第一步：先将这个数bit3～bit8不变，其余位全部清零。)

第三步，继续分析剩下的：

(~(0U)<<(m-n+1))<<(n-1)
这个分析时要搞清楚第2坨到底应该先左边取反再右边<<；还是先右边<<再左边取反。
解法：第一，查C语言优先级表；第二，自己实际写个代码测试。
说明这个式子应该是 ₍(0U)<<(m-n+1))<<(n-1) ，这就又分为2部分了

0x88:10001000

例如：变量0x88, 也就是0b10001000，若截取第2～4位，则值为：0b100 = 4

₍(0U)<<(m-n+1))<<(n-1)):00001110
(x & ₍(0U)<<(m-n+1))<<(n-1)):00001000
(x & ₍(0U)<<(m-n+1))<<(n-1)) >> (n-1):00001000

作者：种瓜大爷
来源：CSDN
原文：https://blog.csdn.net/czg13548930186/article/details/72859866
版权声明：本文为博主原创文章，转载请附上博文链接！

一. 机器数和真值
在学习原码, 反码和补码之前, 需要先了解机器数和真值的概念.

1、机器数
一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.

比如，十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。

那么，这里的 00000011 和 10000011 就是机器数。

2、真值
因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。

例：0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1

二. 原码, 反码, 补码的基础概念和计算方法.
在探求为何机器要使用补码之前, 让我们先了解原码, 反码和补码的概念.对于一个数, 计算机要使用一定的编码方式进行存储. 原码, 反码, 补码是机器存储一个具体数字的编码方式.

1. 原码
   原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:

[+1]原 = 0000 0001

[-1]原 = 1000 0001

第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:

[1111 1111 , 0111 1111]

即

[-127 , 127]

原码是人脑最容易理解和计算的表示方式.

2. 反码
   反码的表示方法是:

正数的反码是其本身

负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原 = [11111110]反

可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算.

3. 补码
   补码的表示方法是:

正数的补码就是其本身

负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

[+1] = [00000001]原 = [00000001]反 = [00000001]补

[-1] = [10000001]原 = [11111110]反 = [11111111]补

对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.

三. 为何要使用原码, 反码和补码
在开始深入学习前, 我的学习建议是先"死记硬背"上面的原码, 反码和补码的表示方式以及计算方法.

现在我们知道了计算机可以有三种编码方式表示一个数. 对于正数因为三种编码方式的结果都相同:

[+1] = [00000001]原 = [00000001]反 = [00000001]补

所以不需要过多解释. 但是对于负数:

[-1] = [10000001]原 = [11111110]反 = [11111111]补

可见原码, 反码和补码是完全不同的. 既然原码才是被人脑直接识别并用于计算表示方式, 为何还会有反码和补码呢?

首先, 因为人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对真值区域的加减. (真值的概念在本文最开头). 但是对于计算机, 加减乘数已经是最基础的运算, 要设计的尽量简单. 计算机辨别"符号位"显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了.

于是人们开始探索 将符号位参与运算, 并且只保留加法的方法. 首先来看原码:

计算十进制的表达式: 1-1=0

1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2

如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.

为了解决原码做减法的问题, 出现了反码:

计算十进制的表达式: 1-1=0

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

发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在"0"这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有[0000 0000]原和[1000 0000]原两个编码表示0.

于是补码的出现, 解决了0的符号以及两个编码的问题:

1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原 = [0000 0001]补 + [1111 1111]补 = [0000 0000]补=[0000 0000]原

这样0用[0000 0000]表示, 而以前出现问题的-0则不存在了.而且可以用[1000 0000]表示-128:

(-1) + (-127) = [1000 0001]原 + [1111 1111]原 = [1111 1111]补 + [1000 0001]补 = [1000 0000]补

-1-127的结果应该是-128, 在用补码运算的结果中, [1000 0000]补 就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以-128并没有原码和反码表示.(对-128的补码表示[1000 0000]补算出来的原码是[0000 0000]原, 这是不正确的)

使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, 使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127].

因为机器使用补码, 所以对于编程中常用到的32位int类型, 可以表示范围是: [-231, 231-1] 因为第一位表示的是符号位.而使用补码表示时又可以多保存一个最小值.

四 原码, 反码, 补码 再深入
计算机巧妙地把符号位参与运算, 并且将减法变成了加法, 背后蕴含了怎样的数学原理呢?

将钟表想象成是一个1位的12进制数. 如果当前时间是6点, 我希望将时间设置成4点, 需要怎么做呢?我们可以:

1. 往回拨2个小时: 6 - 2 = 4

2. 往前拨10个小时: (6 + 10) mod 12 = 4

3. 往前拨10+12=22个小时: (6+22) mod 12 =4

2,3方法中的mod是指取模操作, 16 mod 12 =4 即用16除以12后的余数是4.

所以钟表往回拨(减法)的结果可以用往前拨(加法)替代!

现在的焦点就落在了如何用一个正数, 来替代一个负数. 上面的例子我们能感觉出来一些端倪, 发现一些规律. 但是数学是严谨的. 不能靠感觉.

首先介绍一个数学中相关的概念: 同余

同余的概念
两个整数a，b，若它们除以整数m所得的余数相等，则称a，b对于模m同余

记作 a ≡ b (mod m)

读作 a 与 b 关于模 m 同余。

举例说明:

4 mod 12 = 4

16 mod 12 = 4

28 mod 12 = 4

所以4, 16, 28关于模 12 同余.

负数取模
正数进行mod运算是很简单的. 但是负数呢?

下面是关于mod运算的数学定义:

上面是截图, "取下界"符号找不到如何输入(word中粘贴过来后乱码). 下面是使用"L"和"J"替换上图的"取下界"符号:

x mod y = x - y L x / y J

上面公式的意思是:

x mod y等于 x 减去 y 乘上 x与y的商的下界.

以 -3 mod 2 举例:

-3 mod 2

= -3 - 2xL -3/2 J

= -3 - 2xL-1.5J

= -3 - 2x(-2)

= -3 + 4 = 1

所以:

(-2) mod 12 = 12-2=10

(-4) mod 12 = 12-4 = 8

(-5) mod 12 = 12 - 5 = 7

开始证明
再回到时钟的问题上:

回拨2小时 = 前拨10小时

回拨4小时 = 前拨8小时

回拨5小时= 前拨7小时

注意, 这里发现的规律!

结合上面学到的同余的概念.实际上:

(-2) mod 12 = 10

10 mod 12 = 10

-2与10是同余的.

(-4) mod 12 = 8

8 mod 12 = 8

-4与8是同余的.

距离成功越来越近了. 要实现用正数替代负数, 只需要运用同余数的两个定理:

反身性:

a ≡ a (mod m)

这个定理是很显而易见的.

线性运算定理:

如果a ≡ b (mod m)，c ≡ d (mod m) 那么:

(1)a ± c ≡ b ± d (mod m)

(2)a * c ≡ b * d (mod m)

如果想看这个定理的证明, 请看:http://baike.baidu.com/view/79282.htm

所以:

7 ≡ 7 (mod 12)

(-2) ≡ 10 (mod 12)

7 -2 ≡ 7 + 10 (mod 12)

现在我们为一个负数, 找到了它的正数同余数. 但是并不是7-2 = 7+10, 而是 7 -2 ≡ 7 + 10 (mod 12) , 即计算结果的余数相等.

接下来回到二进制的问题上, 看一下: 2-1=1的问题.

2-1=2+(-1) = [0000 0010]原 + [1000 0001]原= [0000 0010]反 + [1111 1110]反

先到这一步, -1的反码表示是1111 1110. 如果这里将[1111 1110]认为是原码, 则[1111 1110]原 = -126, 这里将符号位除去, 即认为是126.

发现有如下规律:

(-1) mod 127 = 126

126 mod 127 = 126

即:

(-1) ≡ 126 (mod 127)

2-1 ≡ 2+126 (mod 127)

2-1 与 2+126的余数结果是相同的! 而这个余数, 正式我们的期望的计算结果: 2-1=1

所以说一个数的反码, 实际上是这个数对于一个膜的同余数. 而这个膜并不是我们的二进制, 而是所能表示的最大值! 这就和钟表一样, 转了一圈后总能找到在可表示范围内的一个正确的数值!

而2+126很显然相当于钟表转过了一轮, 而因为符号位是参与计算的, 正好和溢出的最高位形成正确的运算结果.

既然反码可以将减法变成加法, 那么现在计算机使用的补码呢? 为什么在反码的基础上加1, 还能得到正确的结果?

2-1=2+(-1) = [0000 0010]原 + [1000 0001]原 = [0000 0010]补 + [1111 1111]补

如果把[1111 1111]当成原码, 去除符号位, 则:

[0111 1111]原 = 127

其实, 在反码的基础上+1, 只是相当于增加了膜的值:

(-1) mod 128 = 127

127 mod 128 = 127

2-1 ≡ 2+127 (mod 128)

此时, 表盘相当于每128个刻度转一轮. 所以用补码表示的运算结果最小值和最大值应该是[-128, 128].

但是由于0的特殊情况, 没有办法表示128, 所以补码的取值范围是[-128, 127]

最后

以上就是激动宝贝为你收集整理的单片机的位操作知识的全部内容，希望文章能够帮你解决单片机的位操作知识所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。