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)

所以:

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]