程序員不得不了解的硬核知識大全

我們每個程序員或許都有一個夢，那就是成為大牛，我們或許都沉浸在各種框架中，以為框架就是一切，以為應用層才是最重要的，你錯了。在當今計算機行業中，會應用是基本素質，如果你懂其原理才能讓你在行業中走的更遠，而計算機基礎知識又是重中之重。下面，跟隨我的腳步，為你介紹一下計算機底層知識。

CPU

還不了解 CPU 嗎？現在就帶你了解一下 CPU 是什么

CPU 的全稱是 Central Processing Unit，它是你的電腦中最硬核的組件，這種說法一點不為過。CPU 是能夠讓你的計算機叫計算機的核心組件，但是它卻不能代表你的電腦，CPU 與計算機的關系就相當於大腦和人的關系。CPU 的核心是從程序或應用程序獲取指令並執行計算。此過程可以分為三個關鍵階段：提取，解碼和執行。CPU從系統的主存中提取指令，然后解碼該指令的實際內容，然后再由 CPU 的相關部分執行該指令。

CPU 內部處理過程

下圖展示了一般程序的運行流程（以 C 語言為例），可以說了解程序的運行流程是掌握程序運行機制的基礎和前提。

在這個流程中，CPU 負責的就是解釋和運行最終轉換成機器語言的內容。

CPU 主要由兩部分構成：控制單元 和 算術邏輯單元（ALU）

• 控制單元：從內存中提取指令並解碼執行
• 算數邏輯單元（ALU）：處理算數和邏輯運算

CPU 是計算機的心臟和大腦，它和內存都是由許多晶體管組成的電子部件。它接收數據輸入，執行指令並處理信息。它與輸入/輸出（I / O）設備進行通信，這些設備向 CPU 發送數據和從 CPU 接收數據。

從功能來看，CPU 的內部由寄存器、控制器、運算器和時鍾四部分組成，各部分之間通過電信號連通。

• 寄存器是中央處理器內的組成部分。它們可以用來暫存指令、數據和地址。可以將其看作是內存的一種。根據種類的不同，一個 CPU 內部會有 20 - 100個寄存器。
• 控制器負責把內存上的指令、數據讀入寄存器，並根據指令的結果控制計算機
• 運算器負責運算從內存中讀入寄存器的數據
• 時鍾 負責發出 CPU 開始計時的時鍾信號

CPU 是一系列寄存器的集合體

在 CPU 的四個結構中，我們程序員只需要了解寄存器就可以了，其余三個不用過多關注，為什么這么說？因為程序是把寄存器作為對象來描述的。

不同類型的 CPU ，其內部寄存器的種類，數量以及寄存器存儲的數值范圍都是不同的。不過，根據功能的不同，可以將寄存器划分為下面這幾類

種類	功能
累加寄存器	存儲運行的數據和運算后的數據。
標志寄存器	用於反應處理器的狀態和運算結果的某些特征以及控制指令的執行。
程序計數器	程序計數器是用於存放下一條指令所在單元的地址的地方。
基址寄存器	存儲數據內存的起始位置
變址寄存器	存儲基址寄存器的相對地址
通用寄存器	存儲任意數據
指令寄存器	儲存正在被運行的指令，CPU內部使用，程序員無法對該寄存器進行讀寫
棧寄存器	存儲棧區域的起始位置

其中程序計數器、累加寄存器、標志寄存器、指令寄存器和棧寄存器都只有一個，其他寄存器一般有多個。

下面就對各個寄存器進行說明

程序計數器

程序計數器(Program Counter)是用來存儲下一條指令所在單元的地址。

程序執行時，PC的初值為程序第一條指令的地址，在順序執行程序時，控制器首先按程序計數器所指出的指令地址從內存中取出一條指令，然后分析和執行該指令，同時將PC的值加1指向下一條要執行的指令。

我們還是以一個事例為准來詳細的看一下程序計數器的執行過程

這是一段進行相加的操作，程序啟動，在經過編譯解析后會由操作系統把硬盤中的程序復制到內存中，示例中的程序是將 123 和 456 執行相加操作，並將結果輸出到顯示器上。

地址 0100 是程序運行的起始位置。Windows 等操作系統把程序從硬盤復制到內存后，會將程序計數器作為設定為起始位置 0100，然后執行程序，每執行一條指令后，程序計數器的數值會增加1（或者直接指向下一條指令的地址），然后，CPU 就會根據程序計數器的數值，從內存中讀取命令並執行，也就是說，程序計數器控制着程序的流程。

條件分支和循環機制

高級語言中的條件控制流程主要分為三種：順序執行、條件分支、循環判斷三種，順序執行是按照地址的內容順序的執行指令。條件分支是根據條件執行任意地址的指令。循環是重復執行同一地址的指令。

• 順序執行的情況比較簡單，每執行一條指令程序計數器的值就是 + 1。
• 條件和循環分支會使程序計數器的值指向任意的地址，這樣一來，程序便可以返回到上一個地址來重復執行同一個指令，或者跳轉到任意指令。

下面以條件分支為例來說明程序的執行過程（循環也很相似）

程序的開始過程和順序流程是一樣的，CPU 從0100處開始執行命令，在0100和0101都是順序執行，PC 的值順序+1，執行到0102地址的指令時，判斷0106寄存器的數值大於0，跳轉（jump）到0104地址的指令，將數值輸出到顯示器中，然后結束程序，0103 的指令被跳過了，這就和我們程序中的 if() 判斷是一樣的，在不滿足條件的情況下，指令會直接跳過。所以 PC 的執行過程也就沒有直接+1，而是下一條指令的地址。

標志寄存器

條件和循環分支會使用到 jump（跳轉指令），會根據當前的指令來判斷是否跳轉，上面我們提到了標志寄存器，無論當前累加寄存器的運算結果是正數、負數還是零，標志寄存器都會將其保存

CPU 在進行運算時，標志寄存器的數值會根據當前運算的結果自動設定，運算結果的正、負和零三種狀態由標志寄存器的三個位表示。標志寄存器的第一個字節位、第二個字節位、第三個字節位各自的結果都為1時，分別代表着正數、零和負數。

CPU 的執行機制比較有意思，假設累加寄存器中存儲的 XXX 和通用寄存器中存儲的 YYY 做比較，執行比較的背后，CPU 的運算機制就會做減法運算。而無論減法運算的結果是正數、零還是負數，都會保存到標志寄存器中。結果為正表示 XXX 比 YYY 大，結果為零表示 XXX 和 YYY 相等，結果為負表示 XXX 比 YYY 小。程序比較的指令，實際上是在 CPU 內部做減法運算。

函數調用機制

接下來，我們繼續介紹函數調用機制，哪怕是高級語言編寫的程序，函數調用處理也是通過把程序計數器的值設定成函數的存儲地址來實現的。函數執行跳轉指令后，必須進行返回處理，單純的指令跳轉沒有意義，下面是一個實現函數跳轉的例子

圖中將變量 a 和 b 分別賦值為 123 和 456 ，調用 MyFun(a,b) 方法，進行指令跳轉。圖中的地址是將 C 語言編譯成機器語言后運行時的地址，由於1行 C 程序在編譯后通常會變為多行機器語言，所以圖中的地址是分散的。在執行完 MyFun(a,b)指令后，程序會返回到 MyFun(a,b) 的下一條指令，CPU 繼續執行下面的指令。

函數的調用和返回很重要的兩個指令是 call 和 return 指令，再將函數的入口地址設定到程序計數器之前，call 指令會把調用函數后要執行的指令地址存儲在名為棧的主存內。函數處理完畢后，再通過函數的出口來執行 return 指令。return 指令的功能是把保存在棧中的地址設定到程序計數器。MyFun 函數在被調用之前，0154 地址保存在棧中，MyFun 函數處理完成后，會把 0154 的地址保存在程序計數器中。這個調用過程如下

在一些高級語言的條件或者循環語句中，函數調用的處理會轉換成 call 指令，函數結束后的處理則會轉換成 return 指令。

通過地址和索引實現數組

接下來我們看一下基址寄存器和變址寄存器，通過這兩個寄存器，我們可以對主存上的特定區域進行划分，來實現類似數組的操作，首先，我們用十六進制數將計算機內存上的 00000000 - FFFFFFFF 的地址划分出來。那么，凡是該范圍的內存地址，只要有一個 32 位的寄存器，便可查看全部地址。但如果想要想數組那樣分割特定的內存區域以達到連續查看的目的的話，使用兩個寄存器會更加方便。

例如，我們用兩個寄存器（基址寄存器和變址寄存器）來表示內存的值

這種表示方式很類似數組的構造，數組是指同樣長度的數據在內存中進行連續排列的數據構造。用數組名表示數組全部的值，通過索引來區分數組的各個數據元素，例如: a[0] - a[4]，[]內的 0 - 4 就是數組的下標。

CPU 指令執行過程

幾乎所有的馮·諾伊曼型計算機的CPU，其工作都可以分為5個階段：取指令、指令譯碼、執行指令、訪存取數、結果寫回。

• 取指令階段是將內存中的指令讀取到 CPU 中寄存器的過程，程序寄存器用於存儲下一條指令所在的地址
• 指令譯碼階段，在取指令完成后，立馬進入指令譯碼階段，在指令譯碼階段，指令譯碼器按照預定的指令格式，對取回的指令進行拆分和解釋，識別區分出不同的指令類別以及各種獲取操作數的方法。
• 執行指令階段，譯碼完成后，就需要執行這一條指令了，此階段的任務是完成指令所規定的各種操作，具體實現指令的功能。
• 訪問取數階段，根據指令的需要，有可能需要從內存中提取數據，此階段的任務是：根據指令地址碼，得到操作數在主存中的地址，並從主存中讀取該操作數用於運算。
• 結果寫回階段，作為最后一個階段，結果寫回（Write Back，WB）階段把執行指令階段的運行結果數據“寫回”到某種存儲形式：結果數據經常被寫到CPU的內部寄存器中，以便被后續的指令快速地存取；

內存

CPU 和 內存就像是一堆不可分割的戀人一樣，是無法拆散的一對兒，沒有內存，CPU 無法執行程序指令，那么計算機也就失去了意義；只有內存，無法執行指令，那么計算機照樣無法運行。

那么什么是內存呢？內存和 CPU 如何進行交互？下面就來介紹一下

什么是內存

內存（Memory）是計算機中最重要的部件之一，它是程序與CPU進行溝通的橋梁。計算機中所有程序的運行都是在內存中進行的，因此內存對計算機的影響非常大，內存又被稱為主存，其作用是存放 CPU 中的運算數據，以及與硬盤等外部存儲設備交換的數據。只要計算機在運行中，CPU 就會把需要運算的數據調到主存中進行運算，當運算完成后CPU再將結果傳送出來，主存的運行也決定了計算機的穩定運行。

內存的物理結構

內存的內部是由各種 IC 電路組成的，它的種類很龐大，但是其主要分為三種存儲器

• 隨機存儲器（RAM）： 內存中最重要的一種，表示既可以從中讀取數據，也可以寫入數據。當機器關閉時，內存中的信息會 丟失。
• 只讀存儲器（ROM）：ROM 一般只能用於數據的讀取，不能寫入數據，但是當機器停電時，這些數據不會丟失。
• 高速緩存（Cache）：Cache 也是我們經常見到的，它分為一級緩存（L1 Cache）、二級緩存（L2 Cache）、三級緩存（L3 Cache）這些數據，它位於內存和 CPU 之間，是一個讀寫速度比內存更快的存儲器。當 CPU 向內存寫入數據時，這些數據也會被寫入高速緩存中。當 CPU 需要讀取數據時，會直接從高速緩存中直接讀取，當然，如需要的數據在Cache中沒有，CPU會再去讀取內存中的數據。

內存 IC 是一個完整的結構，它內部也有電源、地址信號、數據信號、控制信號和用於尋址的 IC 引腳來進行數據的讀寫。下面是一個虛擬的 IC 引腳示意圖

圖中 VCC 和 GND 表示電源，A0 - A9 是地址信號的引腳，D0 - D7 表示的是控制信號、RD 和 WR 都是好控制信號，我用不同的顏色進行了區分，將電源連接到 VCC 和 GND 后，就可以對其他引腳傳遞 0 和 1 的信號，大多數情況下，+5V 表示1，0V 表示 0。

我們都知道內存是用來存儲數據，那么這個內存 IC 中能存儲多少數據呢？D0 - D7 表示的是數據信號，也就是說，一次可以輸入輸出 8 bit = 1 byte 的數據。A0 - A9 是地址信號共十個，表示可以指定 00000 00000 - 11111 11111 共 2 的 10次方 = 1024個地址。每個地址都會存放 1 byte 的數據，因此我們可以得出內存 IC 的容量就是 1 KB。

內存的讀寫過程

讓我們把關注點放在內存 IC 對數據的讀寫過程上來吧！我們來看一個對內存IC 進行數據寫入和讀取的模型

來詳細描述一下這個過程，假設我們要向內存 IC 中寫入 1byte 的數據的話，它的過程是這樣的：

• 首先給 VCC 接通 +5V 的電源，給 GND 接通 0V 的電源，使用 A0 - A9 來指定數據的存儲場所，然后再把數據的值輸入給 D0 - D7 的數據信號，並把 WR（write）的值置為 1，執行完這些操作后，即可以向內存 IC 寫入數據
• 讀出數據時，只需要通過 A0 - A9 的地址信號指定數據的存儲場所，然后再將 RD 的值置為 1 即可。
• 圖中的 RD 和 WR 又被稱為控制信號。其中當WR 和 RD 都為 0 時，無法進行寫入和讀取操作。

內存的現實模型

為了便於記憶，我們把內存模型映射成為我們現實世界的模型，在現實世界中，內存的模型很想我們生活的樓房。在這個樓房中，1層可以存儲一個字節的數據，樓層號就是地址，下面是內存和樓層整合的模型圖

我們知道，程序中的數據不僅只有數值，還有數據類型的概念，從內存上來看，就是占用內存大小（占用樓層數）的意思。即使物理上強制以 1 個字節為單位來逐一讀寫數據的內存，在程序中，通過指定其數據類型，也能實現以特定字節數為單位來進行讀寫。

二進制

我們都知道，計算機的底層都是使用二進制數據進行數據流傳輸的，那么為什么會使用二進制表示計算機呢？或者說，什么是二進制數呢？在拓展一步，如何使用二進制進行加減乘除？下面就來看一下

什么是二進制數

那么什么是二進制數呢？為了說明這個問題，我們先把 00100111 這個數轉換為十進制數看一下，二進制數轉換為十進制數，直接將各位置上的值 * 位權即可，那么我們將上面的數值進行轉換

也就是說，二進制數代表的 00100111 轉換成十進制就是 39，這個 39 並不是 3 和 9 兩個數字連着寫，而是 3 * 10 + 9 * 1，這里面的 10 , 1 就是位權，以此類推，上述例子中的位權從高位到低位依次就是 7 6 5 4 3 2 1 0 。這個位權也叫做次冪，那么最高位就是2的7次冪，2的6次冪 等等。二進制數的運算每次都會以2為底，這個2 指得就是基數，那么十進制數的基數也就是 10 。在任何情況下位權的值都是 數的位數 - 1，那么第一位的位權就是 1 - 1 = 0， 第二位的位權就睡 2 - 1 = 1，以此類推。

那么我們所說的二進制數其實就是 用0和1兩個數字來表示的數，它的基數為2，它的數值就是每個數的位數 * 位權再求和得到的結果，我們一般來說數值指的就是十進制數，那么它的數值就是 3 * 10 + 9 * 1 = 39。

移位運算和乘除的關系

在了解過二進制之后，下面我們來看一下二進制的運算，和十進制數一樣，加減乘除也適用於二進制數，只要注意逢 2 進位即可。二進制數的運算，也是計算機程序所特有的運算，因此了解二進制的運算是必須要掌握的。

首先我們來介紹移位 運算，移位運算是指將二進制的數值的各個位置上的元素坐左移和右移操作，見下圖

補數

剛才我們沒有介紹右移的情況，是因為右移之后空出來的高位數值，有 0 和 1 兩種形式。要想區分什么時候補0什么時候補1，首先就需要掌握二進制數表示負數的方法。

二進制數中表示負數值時，一般會把最高位作為符號來使用，因此我們把這個最高位當作符號位。 符號位是 0 時表示正數，是 1 時表示 負數。那么 -1 用二進制數該如何表示呢？可能很多人會這么認為： 因為 1 的二進制數是 0000 0001，最高位是符號位，所以正確的表示 -1 應該是 1000 0001，但是這個答案真的對嗎？

計算機世界中是沒有減法的，計算機在做減法的時候其實就是在做加法，也就是用加法來實現的減法運算。比如 100 - 50 ，其實計算機來看的時候應該是 100 + (-50)，為此，在表示負數的時候就要用到二進制補數，補數就是用正數來表示的負數。

為了獲得補數，我們需要將二進制的各數位的數值全部取反，然后再將結果 + 1 即可，先記住這個結論，下面我們來演示一下。

具體來說，就是需要先獲取某個數值的二進制數，然后對二進制數的每一位做取反操作(0 ---> 1 , 1 ---> 0)，最后再對取反后的數 +1 ，這樣就完成了補數的獲取。

補數的獲取，雖然直觀上不易理解，但是邏輯上卻非常嚴謹，比如我們來看一下 1 - 1 的這個過程，我們先用上面的這個 1000 0001(它是1的補數，不知道的請看上文，正確性先不管，只是用來做一下計算)來表示一下

奇怪，1 - 1 會變成 130 ，而不是0，所以可以得出結論 1000 0001 表示 -1 是完全錯誤的。

那么正確的該如何表示呢？其實我們上面已經給出結果了，那就是 1111 1111，來論證一下它的正確性

我們可以看到 1 - 1 其實實際上就是 1 + (-1)，對 -1 進行上面的取反 + 1 后變為 1111 1111, 然后與 1 進行加法運算，得到的結果是九位的 1 0000 0000，結果發生了溢出，計算機會直接忽略掉溢出位，也就是直接拋掉 最高位 1 ，變為 0000 0000。也就是 0，結果正確，所以 1111 1111 表示的就是 -1 。

所以負數的二進制表示就是先求其補數，補數的求解過程就是對原始數值的二進制數各位取反，然后將結果 + 1。

算數右移和邏輯右移的區別

在了解完補數后，我們重新考慮一下右移這個議題，右移在移位后空出來的最高位有兩種情況 0 和 1。

將二進制數作為帶符號的數值進行右移運算時，移位后需要在最高位填充移位前符號位的值( 0 或 1)。這就被稱為算數右移。如果數值使用補數表示的負數值，那么右移后在空出來的最高位補 1，就可以正確的表示 1/2,1/4,1/8等的數值運算。如果是正數，那么直接在空出來的位置補 0 即可。

下面來看一個右移的例子。將 -4 右移兩位，來各自看一下移位示意圖

如上圖所示，在邏輯右移的情況下， -4 右移兩位會變成 63， 顯然不是它的 1/4，所以不能使用邏輯右移，那么算數右移的情況下，右移兩位會變為 -1，顯然是它的 1/4，故而采用算數右移。

那么我們可以得出來一個結論：左移時，無論是圖形還是數值，移位后，只需要將低位補 0 即可；右移時，需要根據情況判斷是邏輯右移還是算數右移。

下面介紹一下符號擴展：將數據進行符號擴展是為了產生一個位數加倍、但數值大小不變的結果，以滿足有些指令對操作數位數的要求，例如倍長於除數的被除數，再如將數據位數加長以減少計算過程中的誤差。

以8位二進制為例，符號擴展就是指在保持值不變的前提下將其轉換成為16位和32位的二進制數。將0111 1111這個正的 8位二進制數轉換成為 16位二進制數時，很容易就能夠得出0000 0000 0111 1111這個正確的結果，但是像 1111 1111這樣的補數來表示的數值，該如何處理？直接將其表示成為1111 1111 1111 1111就可以了。也就是說，不管正數還是補數表示的負數，只需要將 0 和 1 填充高位即可。

內存和磁盤的關系

我們大家知道，計算機的五大基礎部件是 存儲器、控制器、運算器、輸入和輸出設備，其中從存儲功能的角度來看，可以把存儲器分為內存和 磁盤，我們上面介紹過內存，下面就來介紹一下磁盤以及磁盤和內存的關系

程序不讀入內存就無法運行

計算機最主要的存儲部件是內存和磁盤。磁盤中存儲的程序必須加載到內存中才能運行，在磁盤中保存的程序是無法直接運行的，這是因為負責解析和運行程序內容的 CPU 是需要通過程序計數器來指定內存地址從而讀出程序指令的。

磁盤構造

磁盤緩存

我們上面提到，磁盤往往和內存是互利共生的關系，相互協作，彼此持有良好的合作關系。每次內存都需要從磁盤中讀取數據，必然會讀到相同的內容，所以一定會有一個角色負責存儲我們經常需要讀到的內容。 我們大家做軟件的時候經常會用到緩存技術，那么硬件層面也不例外，磁盤也有緩存，磁盤的緩存叫做磁盤緩存。

磁盤緩存指的是把從磁盤中讀出的數據存儲到內存的方式，這樣一來，當接下來需要讀取相同的內容時，就不會再通過實際的磁盤，而是通過磁盤緩存來讀取。某一種技術或者框架的出現勢必要解決某種問題的，那么磁盤緩存就大大改善了磁盤訪問的速度。

虛擬內存

虛擬內存是內存和磁盤交互的第二個媒介。虛擬內存是指把磁盤的一部分作為假想內存來使用。這與磁盤緩存是假想的磁盤（實際上是內存）相對，虛擬內存是假想的內存（實際上是磁盤）。

虛擬內存是計算機系統內存管理的一種技術。它使得應用程序認為它擁有連續可用的內存（一個完整的地址空間），但是實際上，它通常被分割成多個物理碎片，還有部分存儲在外部磁盤管理器上，必要時進行數據交換。

通過借助虛擬內存，在內存不足時仍然可以運行程序。例如，在只剩 5MB 內存空間的情況下仍然可以運行 10MB 的程序。由於 CPU 只能執行加載到內存中的程序，因此，虛擬內存的空間就需要和內存中的空間進行置換（swap），然后運行程序。

虛擬內存與內存的交換方式

虛擬內存的方法有分頁式 和 分段式 兩種。Windows 采用的是分頁式。該方式是指在不考慮程序構造的情況下，把運行的程序按照一定大小的頁進行分割，並以頁為單位進行置換。在分頁式中，我們把磁盤的內容讀到內存中稱為 Page In，把內存的內容寫入磁盤稱為 Page Out。Windows 計算機的頁大小為 4KB ，也就是說，需要把應用程序按照 4KB 的頁來進行切分，以頁（page）為單位放到磁盤中，然后進行置換。

為了實現內存功能，Windows 在磁盤上提供了虛擬內存使用的文件（page file，頁文件）。該文件由 Windows 生成和管理，文件的大小和虛擬內存大小相同，通常大小是內存的 1 - 2 倍。

磁盤的物理結構

之前我們介紹了CPU、內存的物理結構，現在我們來介紹一下磁盤的物理結構。磁盤的物理結構指的是磁盤存儲數據的形式。

磁盤是通過其物理表面划分成多個空間來使用的。划分的方式有兩種：可變長方式 和 扇區方式。前者是將物理結構划分成長度可變的空間，后者是將磁盤結構划分為固定長度的空間。一般 Windows 所使用的硬盤和軟盤都是使用扇區這種方式。扇區中，把磁盤表面分成若干個同心圓的空間就是 磁道，把磁道按照固定大小的存儲空間划分而成的就是 扇區

扇區是對磁盤進行物理讀寫的最小單位。Windows 中使用的磁盤，一般是一個扇區 512 個字節。不過，Windows 在邏輯方面對磁盤進行讀寫的單位是扇區整數倍簇。根據磁盤容量不同功能，1簇可以是 512 字節（1 簇 = 1扇區）、1KB（1簇 = 2扇區）、2KB、4KB、8KB、16KB、32KB( 1 簇 = 64 扇區)。簇和扇區的大小是相等的。

壓縮算法

我們想必都有過壓縮和 解壓縮文件的經歷，當文件太大時，我們會使用文件壓縮來降低文件的占用空間。比如微信上傳文件的限制是100 MB，我這里有個文件夾無法上傳，但是我解壓完成后的文件一定會小於 100 MB，那么我的文件就可以上傳了。

此外，我們把相機拍完的照片保存到計算機上的時候，也會使用壓縮算法進行文件壓縮，文件壓縮的格式一般是JPEG。

那么什么是壓縮算法呢？壓縮算法又是怎么定義的呢？在認識算法之前我們需要先了解一下文件是如何存儲的

文件存儲

文件是將數據存儲在磁盤等存儲媒介的一種形式。程序文件中最基本的存儲數據單位是字節。文件的大小不管是 xxxKB、xxxMB等來表示，就是因為文件是以字節 B = Byte 為單位來存儲的。

文件就是字節數據的集合。用 1 字節（8 位）表示的字節數據有 256 種，用二進制表示的話就是 0000 0000 - 1111 1111 。如果文件中存儲的數據是文字，那么該文件就是文本文件。如果是圖形，那么該文件就是圖像文件。在任何情況下，文件中的字節數都是連續存儲的。

壓縮算法的定義

上面介紹了文件的集合體其實就是一堆字節數據的集合，那么我們就可以來給壓縮算法下一個定義。

壓縮算法（compaction algorithm）指的就是數據壓縮的算法，主要包括壓縮和還原（解壓縮）的兩個步驟。

其實就是在不改變原有文件屬性的前提下，降低文件字節空間和占用空間的一種算法。

根據壓縮算法的定義，我們可將其分成不同的類型：

有損和無損

無損壓縮：能夠無失真地從壓縮后的數據重構，准確地還原原始數據。可用於對數據的准確性要求嚴格的場合，如可執行文件和普通文件的壓縮、磁盤的壓縮，也可用於多媒體數據的壓縮。該方法的壓縮比較小。如差分編碼、RLE、Huffman編碼、LZW編碼、算術編碼。

有損壓縮：有失真，不能完全准確地恢復原始數據，重構的數據只是原始數據的一個近似。可用於對數據的准確性要求不高的場合，如多媒體數據的壓縮。該方法的壓縮比較大。例如預測編碼、音感編碼、分形壓縮、小波壓縮、JPEG/MPEG。

對稱性

如果編解碼算法的復雜性和所需時間差不多，則為對稱的編碼方法，多數壓縮算法都是對稱的。但也有不對稱的，一般是編碼難而解碼容易，如 Huffman 編碼和分形編碼。但用於密碼學的編碼方法則相反，是編碼容易，而解碼則非常難。

幀間與幀內

在視頻編碼中會同時用到幀內與幀間的編碼方法，幀內編碼是指在一幀圖像內獨立完成的編碼方法，同靜態圖像的編碼，如 JPEG；而幀間編碼則需要參照前后幀才能進行編解碼，並在編碼過程中考慮對幀之間的時間冗余的壓縮，如 MPEG。

實時性

在有些多媒體的應用場合，需要實時處理或傳輸數據（如現場的數字錄音和錄影、播放MP3/RM/VCD/DVD、視頻/音頻點播、網絡現場直播、可視電話、視頻會議），編解碼一般要求延時 ≤50 ms。這就需要簡單/快速/高效的算法和高速/復雜的CPU/DSP芯片。

分級處理

有些壓縮算法可以同時處理不同分辨率、不同傳輸速率、不同質量水平的多媒體數據，如JPEG2000、MPEG-2/4。

這些概念有些抽象，主要是為了讓大家了解一下壓縮算法的分類，下面我們就對具體的幾種常用的壓縮算法來分析一下它的特點和優劣

幾種常用壓縮算法的理解

RLE 算法的機制

接下來就讓我們正式看一下文件的壓縮機制。首先讓我們來嘗試對 AAAAAABBCDDEEEEEF 這 17 個半角字符的文件（文本文件）進行壓縮。雖然這些文字沒有什么實際意義，但是很適合用來描述 RLE 的壓縮機制。

由於半角字符（其實就是英文字符）是作為 1 個字節保存在文件中的，所以上述的文件的大小就是 17 字節。如圖

那么，如何才能壓縮該文件呢？大家不妨也考慮一下，只要是能夠使文件小於 17 字節，我們可以使用任何壓縮算法。

最顯而易見的一種壓縮方式我覺得你已經想到了，就是把相同的字符去重化，也就是 字符 * 重復次數 的方式進行壓縮。所以上面文件壓縮后就會變成下面這樣

從圖中我們可以看出，AAAAAABBCDDEEEEEF 的17個字符成功被壓縮成了 A6B2C1D2E5F1 的12個字符，也就是 12 / 17 = 70%，壓縮比為 70%，壓縮成功了。

像這樣，把文件內容用 數據 * 重復次數 的形式來表示的壓縮方法成為 RLE(Run Length Encoding, 行程長度編碼) 算法。RLE 算法是一種很好的壓縮方法，經常用於壓縮傳真的圖像等。因為圖像文件的本質也是字節數據的集合體，所以可以用 RLE 算法進行壓縮

哈夫曼算法和莫爾斯編碼

下面我們來介紹另外一種壓縮算法，即哈夫曼算法。在了解哈夫曼算法之前，你必須舍棄半角英文數字的1個字符是1個字節(8位)的數據。下面我們就來認識一下哈夫曼算法的基本思想。

文本文件是由不同類型的字符組合而成的，而且不同字符出現的次數也是不一樣的。例如，在某個文本文件中，A 出現了 100次左右，Q僅僅用到了 3 次，類似這樣的情況很常見。哈夫曼算法的關鍵就在於 多次出現的數據用小於 8 位的字節數表示，不常用的數據則可以使用超過 8 位的字節數表示。A 和 Q 都用 8 位來表示時，原文件的大小就是 100次 * 8 位 + 3次 * 8 位 = 824位，假設 A 用 2 位，Q 用 10 位來表示就是 2 * 100 + 3 * 10 = 230 位。

不過要注意一點，最終磁盤的存儲都是以8位為一個字節來保存文件的。

哈夫曼算法比較復雜，在深入了解之前我們先吃點甜品，了解一下 莫爾斯編碼，你一定看過美劇或者戰爭片的電影，在戰爭中的通信經常采用莫爾斯編碼來傳遞信息，例如下面

接下來我們來講解一下莫爾斯編碼，下面是莫爾斯編碼的示例，大家把 1 看作是短點(嘀)，把 11 看作是長點(嗒)即可。

莫爾斯編碼一般把文本中出現最高頻率的字符用短編碼 來表示。如表所示，假如表示短點的位是 1，表示長點的位是 11 的話，那么 E（嘀）這一數據的字符就可以用 1 來表示，C（滴答滴答）就可以用 9 位的 110101101來表示。在實際的莫爾斯編碼中，如果短點的長度是 1 ，長點的長度就是 3，短點和長點的間隔就是1。這里的長度指的就是聲音的長度。比如我們想用上面的 AAAAAABBCDDEEEEEF 例子來用莫爾斯編碼重寫，在莫爾斯曼編碼中，各個字符之間需要加入表示時間間隔的符號。這里我們用 00 加以區分。

所以，AAAAAABBCDDEEEEEF 這個文本就變為了 A * 6 次 + B * 2次 + C * 1次 + D * 2次 + E * 5次 + F * 1次 + 字符間隔 * 16 = 4 位 * 6次 + 8 位 * 2次 + 9 位 * 1 次 + 6位 * 2次 + 1位 * 5次 + 8 位 * 1次 + 2位 * 16次 = 106位 = 14字節。

所以使用莫爾斯電碼的壓縮比為 14 / 17 = 82%。效率並不太突出。

用二叉樹實現哈夫曼算法

剛才已經提到，莫爾斯編碼是根據日常文本中各字符的出現頻率來決定表示各字符的編碼數據長度的。不過，在該編碼體系中，對 AAAAAABBCDDEEEEEF 這種文本來說並不是效率最高的。

下面我們來看一下哈夫曼算法。哈夫曼算法是指，為各壓縮對象文件分別構造最佳的編碼體系，並以該編碼體系為基礎來進行壓縮。因此，用什么樣的編碼（哈夫曼編碼）對數據進行分割，就要由各個文件而定。用哈夫曼算法壓縮過的文件中，存儲着哈夫曼編碼信息和壓縮過的數據。

接下來，我們在對 AAAAAABBCDDEEEEEF 中的 A - F 這些字符，按照出現頻率高的字符用盡量少的位數編碼來表示這一原則進行整理。按照出現頻率從高到低的順序整理后，結果如下，同時也列出了編碼方案。

字符	出現頻率	編碼（方案）	位數
A	6	0	1
E	5	1	1
B	2	10	2
D	2	11	2
C	1	100	3
F	1	101	3

在上表的編碼方案中，隨着出現頻率的降低，字符編碼信息的數據位數也在逐漸增加，從最開始的 1位、2位依次增加到3位。不過這個編碼體系是存在問題的，你不知道100這個3位的編碼，它的意思是用 1、0、0這三個編碼來表示 E、A、A 呢？還是用10、0來表示 B、A 呢？還是用100來表示 C 呢。

而在哈夫曼算法中，通過借助哈夫曼樹的構造編碼體系，即使在不使用字符區分符號的情況下，也可以構建能夠明確進行區分的編碼體系。不過哈夫曼樹的算法要比較復雜，下面是一個哈夫曼樹的構造過程。

自然界樹的從根開始生葉的，而哈夫曼樹則是葉生枝

哈夫曼樹能夠提升壓縮比率

使用哈夫曼樹之后，出現頻率越高的數據所占用的位數越少，這也是哈夫曼樹的核心思想。通過上圖的步驟二可以看出，枝條連接數據時，我們是從出現頻率較低的數據開始的。這就意味着出現頻率低的數據到達根部的枝條也越多。而枝條越多則意味着編碼的位數隨之增加。

接下來我們來看一下哈夫曼樹的壓縮比率，用上圖得到的數據表示 AAAAAABBCDDEEEEEF 為 000000000000 100100 110 101101 0101010101 111，40位 = 5 字節。壓縮前的數據是 17 字節，壓縮后的數據竟然達到了驚人的5 字節，也就是壓縮比率 = 5 / 17 = 29% 如此高的壓縮率，簡直是太驚艷了。

大家可以參考一下，無論哪種類型的數據，都可以用哈夫曼樹作為壓縮算法

文件類型	壓縮前	壓縮后	壓縮比率
文本文件	14862字節	4119字節	28%
圖像文件	96062字節	9456字節	10%
EXE文件	24576字節	4652字節	19%

可逆壓縮和非可逆壓縮

最后，我們來看一下圖像文件的數據形式。圖像文件的使用目的通常是把圖像數據輸出到顯示器、打印機等設備上。常用的圖像格式有 : BMP、JPEG、TIFF、GIF 格式等。

• BMP ： 是使用 Windows 自帶的畫筆來做成的一種圖像形式
• JPEG：是數碼相機等常用的一種圖像數據形式
• TIFF: 是一種通過在文件中包含"標簽"就能夠快速顯示出數據性質的圖像形式
• GIF： 是由美國開發的一種數據形式，要求色數不超過 256個

圖像文件可以使用前面介紹的 RLE 算法和哈夫曼算法，因為圖像文件在多數情況下並不要求數據需要還原到和壓縮之前一摸一樣的狀態，允許丟失一部分數據。我們把能還原到壓縮前狀態的壓縮稱為 可逆壓縮，無法還原到壓縮前狀態的壓縮稱為非可逆壓縮 。

一般來說，JPEG格式的文件是非可逆壓縮，因此還原后有部分圖像信息比較模糊。GIF 是可逆壓縮

操作系統

操作系統環境

程序中包含着運行環境這一內容，可以說 運行環境 = 操作系統 + 硬件 ，操作系統又可以被稱為軟件，它是由一系列的指令組成的。我們不介紹操作系統，我們主要來介紹一下硬件的識別。

我們肯定都玩兒過游戲，你玩兒游戲前需要干什么？是不是需要先看一下自己的筆記本或者電腦是不是能肝的起游戲？下面是一個游戲的配置（懷念一下 wow）

圖中的主要配置如下

• 操作系統版本：說的就是應用程序運行在何種系統環境，現在市面上主要有三種操作系統環境，Windows 、Linux 和 Unix ，一般我們玩兒的大型游戲幾乎都是在 Windows 上運行，可以說 Windows 是游戲的天堂。Windows 操作系統也會有區分，分為32位操作系統和64位操作系統，互不兼容。

• 處理器：處理器指的就是 CPU，你的電腦的計算能力，通俗來講就是每秒鍾能處理的指令數，如果你的電腦覺得卡帶不起來的話，很可能就是 CPU 的計算能力不足導致的。想要加深理解，請閱讀博主的另一篇文章：程序員需要了解的硬核知識之CPU

• 顯卡：顯卡承擔圖形的輸出任務，因此又被稱為圖形處理器（Graphic Processing Unit，GPU），顯卡也非常重要，比如我之前玩兒的劍靈開五檔（其實就是圖像變得更清晰）會卡，其實就是顯卡顯示不出來的原因。

• 內存：內存即主存，就是你的應用程序在運行時能夠動態分析指令的這部分存儲空間，它的大小也能決定你電腦的運行速度，想要加深理解，請閱讀博主的另一篇文章 程序員需要了解的硬核知識之內存

• 存儲空間：存儲空間指的就是應用程序安裝所占用的磁盤空間，由圖中可知，此游戲的最低存儲空間必須要大於 5GB，其實我們都會遺留很大一部分用來安裝游戲。

從程序的運行環境這一角度來考量的話，CPU 的種類是特別重要的參數，為了使程序能夠正常運行，必須滿足 CPU 所需的最低配置。

CPU 只能解釋其自身固有的語言。不同的 CPU 能解釋的機器語言的種類也是不同的。機器語言的程序稱為 本地代碼(native code)，程序員用 C 等高級語言編寫的程序，僅僅是文本文件。文本文件(排除文字編碼的問題)在任何環境下都能顯示和編輯。我們稱之為源代碼。通過對源代碼進行編譯，就可以得到本地代碼。下圖反映了這個過程。

uploading-image-703074.png

Windows 操作系統克服了CPU以外的硬件差異

計算機的硬件並不僅僅是由 CPU 組成的，還包括用於存儲程序指令的數據和內存，以及通過 I/O 連接的鍵盤、顯示器、硬盤、打印機等外圍設備。

在 WIndows 軟件中，鍵盤輸入、顯示器輸出等並不是直接向硬件發送指令。而是通過向 Windows 發送指令實現的。因此，程序員就不用注意內存和 I/O 地址的不同構成了。Windows 操作的是硬件而不是軟件，軟件通過操作 Windows 系統可以達到控制硬件的目的。

不同操作系統的 API 差異性

接下來我們看一下操作系統的種類。同樣機型的計算機，可安裝的操作系統類型也會有多種選擇。例如：AT 兼容機除了可以安裝 Windows 之外，還可以采用 Unix 系列的 Linux 以及 FreeBSD （也是一種Unix操作系統）等多個操作系統。當然，應用軟件則必須根據不同的操作系統類型來專門開發。CPU 的類型不同，所對應機器的語言也不同,同樣的道理，操作系統的類型不同，應用程序向操作系統傳遞指令的途徑也不同。

應用程序向系統傳遞指令的途徑稱為 API(Application Programming Interface)。Windows 以及 Linux 操作系統的 API，提供了任何應用程序都可以利用的函數組合。因為不同操作系統的 API 是有差異的。所以，如何要將同樣的應用程序移植到另外的操作系統，就必須要覆蓋應用所用到的 API 部分。

鍵盤輸入、鼠標輸入、顯示器輸出、文件輸入和輸出等同外圍設備進行交互的功能，都是通過 API 提供的。

這也就是為什么 Windows 應用程序不能直接移植到 Linux 操作系統上的原因，API 差異太大了。

在同類型的操作系統下，不論硬件如何，API 幾乎相同。但是，由於不同種類 CPU 的機器語言不同，因此本地代碼也不盡相同。

操作系統功能的歷史

操作系統其實也是一種軟件，任何新事物的出現肯定都有它的歷史背景，那么操作系統也不是憑空出現的，肯定有它的歷史背景。

在計算機尚不存在操作系統的年代，完全沒有任何程序，人們通過各種按鈕來控制計算機，這一過程非常麻煩。於是，有人開發出了僅具有加載和運行功能的監控程序，這就是操作系統的原型。通過事先啟動監控程序，程序員可以根據需要將各種程序加載到內存中運行。雖然仍舊比較麻煩，但比起在沒有任何程序的狀態下進行開發，工作量得到了很大的緩解。

隨着時代的發展，人們在利用監控程序編寫程序的過程中發現很多程序都有公共的部分。例如，通過鍵盤進行文字輸入，顯示器進行數據展示等，如果每編寫一個新的應用程序都需要相同的處理的話，那真是太浪費時間了。因此，基本的輸入輸出部分的程序就被追加到了監控程序中。初期的操作系統就是這樣誕生了。

類似的想法可以共用，人們又發現有更多的應用程序可以追加到監控程序中，比如硬件控制程序，編程語言處理器(匯編、編譯、解析)以及各種應用程序等，結果就形成了和現在差異不大的操作系統，也就是說，其實操作系統是多個程序的集合體。

Windows 操作系統的特征

Windows 操作系統是世界上用戶數量最龐大的群體，作為 Windows 操作系統的資深用戶，你都知道 Windows 操作系統有哪些特征嗎？下面列舉了一些 Windows 操作系統的特性

• Windows 操作系統有兩個版本：32位和64位
• 通過 API 函數集成來提供系統調用
• 提供了采用圖形用戶界面的用戶界面
• 通過 WYSIWYG 實現打印輸出，WYSIWYG 其實就是 What You See Is What You Get ，值得是顯示器上顯示的圖形和文本都是可以原樣輸出到打印機打印的。
• 提供多任務功能，即能夠同時開啟多個任務
• 提供網絡功能和數據庫功能
• 通過即插即用實現設備驅動的自設定

這些是對程序員來講比較有意義的一些特征，下面針對這些特征來進行分別的介紹

32位操作系統

這里表示的32位操作系統表示的是處理效率最高的數據大小。Windows 處理數據的基本單位是 32 位。這與最一開始在 MS-DOS 等16位操作系統不同，因為在16位操作系統中處理32位數據需要兩次，而32位操作系統只需要一次就能夠處理32位的數據，所以一般在 windows 上的應用，它們的最高能夠處理的數據都是 32 位的。

比如，用 C 語言來處理整數數據時，有8位的 char 類型，16位的short類型，以及32位的long類型三個選項，使用位數較大的 long 類型進行處理的話，增加的只是內存以及磁盤的開銷，對性能影響不大。

現在市面上大部分都是64位操作系統了，64位操作系統也是如此。

通過 API 函數集來提供系統調用

Windows 是通過名為 API 的函數集來提供系統調用的。API是聯系應用程序和操作系統之間的接口，全稱叫做 Application Programming Interface,應用程序接口。

當前主流的32位版 Windows API 也稱為 Win32 API，之所以這樣命名，是需要和不同的操作系統進行區分，比如最一開始的 16 位版的 Win16 API，和后來流行的 Win64 API 。

API 通過多個 DLL 文件來提供，各個 API 的實體都是用 C 語言編寫的函數。所以，在 C 語言環境下，使用 API 更加容易，比如 API 所用到的 MessageBox() 函數，就被保存在了 Windows 提供的 user32.dll 這個 DLL 文件中。

提供采用了 GUI 的用戶界面

GUI(Graphical User Interface) 指得就是圖形用戶界面，通過點擊顯示器中的窗口以及圖標等可視化的用戶界面，舉個例子：Linux 操作系統就有兩個版本，一種是簡潔版，直接通過命令行控制硬件，還有一種是可視化版，通過光標點擊圖形界面來控制硬件。

通過 WYSIWYG 實現打印輸出

WYSIWYG 指的是顯示器上輸出的內容可以直接通過打印機打印輸出。在 Windows 中，顯示器和打印機被認作同等的圖形輸出設備處理的，該功能也為 WYSIWYG 提供了條件。

借助 WYSIWYG 功能，程序員可以輕松不少。最初，為了是現在顯示器中顯示和在打印機中打印，就必須分別編寫各自的程序，而在 Windows 中，可以借助 WYSIWYG 基本上在一個程序中就可以做到顯示和打印這兩個功能了。

提供多任務功能

多任務指的就是同時能夠運行多個應用程序的功能，Windows 是通過時鍾分割技術來實現多任務功能的。時鍾分割指的是短時間間隔內，多個程序切換運行的方式。在用戶看來，就好像是多個程序在同時運行，其底層是 CPU 時間切片，這也是多線程多任務的核心。

提供網絡功能和數據庫功能

Windows 中，網絡功能是作為標准功能提供的。數據庫(數據庫服務器)功能有時也會在后面追加。網絡功能和數據庫功能雖然並不是操作系統不可或缺的，但因為它們和操作系統很接近，所以被統稱為中間件而不是應用。意思是處於操作系統和應用的中間層，操作系統和中間件組合在一起，稱為系統軟件。應用不僅可以利用操作系統，也可以利用中間件的功能。

相對於操作系統一旦安裝就不能輕易更換，中間件可以根據需要進行更換，不過，對於大部分應用來說，更換中間件的話，會造成應用也隨之更換，從這個角度來說，更å換中間件也不是那么容易。

通過即插即用實現設備驅動的自動設定

即插即用(Plug-and-Play)指的是新的設備連接(plug) 后就可以直接使用的機制，新設備連接計算機后，計算機就會自動安裝和設定用來控制該設備的驅動程序

設備驅動是操作系統的一部分，提供了同硬件進行基本的輸入輸出的功能。鍵盤、鼠標、顯示器、磁盤裝置等，這些計算機中必備的硬件的設備驅動，一般都是隨操作系統一起安裝的。

有時 DLL 文件也會同設備驅動文件一起安裝。這些 DLL 文件中存儲着用來利用該新追加的硬件API，通過 API ，可以制作出運行該硬件的心應用。

匯編語言和本地代碼

我們在之前的文章中探討過，計算機 CPU 只能運行本地代碼(機器語言)程序，用 C 語言等高級語言編寫的代碼，需要經過編譯器編譯后，轉換為本地代碼才能夠被 CPU 解釋執行。

但是本地代碼的可讀性非常差，所以需要使用一種能夠直接讀懂的語言來替換本地代碼，那就是在各本地代碼中，附帶上表示其功能的英文縮寫，比如在加法運算的本地代碼加上add(addition) 的縮寫、在比較運算符的本地代碼中加上cmp(compare)的縮寫等，這些通過縮寫來表示具體本地代碼指令的標志稱為 助記符，使用助記符的語言稱為匯編語言。這樣，通過閱讀匯編語言，也能夠了解本地代碼的含義了。

不過，即使是使用匯編語言編寫的源代碼，最終也必須要轉換為本地代碼才能夠運行，負責做這項工作的程序稱為編譯器，轉換的這個過程稱為匯編。在將源代碼轉換為本地代碼這個功能方面，匯編器和編譯器是同樣的。

用匯編語言編寫的源代碼和本地代碼是一一對應的。因而，本地代碼也可以反過來轉換成匯編語言編寫的代碼。把本地代碼轉換為匯編代碼的這一過程稱為反匯編，執行反匯編的程序稱為反匯編程序。

哪怕是 C 語言編寫的源代碼，編譯后也會轉換成特定 CPU 用的本地代碼。而將其反匯編的話，就可以得到匯編語言的源代碼，並對其內容進行調查。不過，本地代碼變成 C 語言源代碼的反編譯，要比本地代碼轉換成匯編代碼的反匯編要困難，這是因為，C 語言代碼和本地代碼不是一一對應的關系。

通過編譯器輸出匯編語言的源代碼

我們上面提到本地代碼可以經過反匯編轉換成為匯編代碼，但是只有這一種轉換方式嗎？顯然不是，C 語言編寫的源代碼也能夠通過編譯器編譯稱為匯編代碼，下面就來嘗試一下。

首先需要先做一些准備，需要先下載 Borland C++ 5.5 編譯器，為了方便，我這邊直接下載好了讀者直接從我的百度網盤提取即可 （鏈接:https://pan.baidu.com/s/19LqVICpn5GcV88thD2AnlA 密碼:hz1u）

下載完畢，需要進行配置，下面是配置說明 （https://wenku.baidu.com/view/22e2f418650e52ea551898ad.html），教程很完整跟着配置就可以，下面開始我們的編譯過程

首先用 Windows 記事本等文本編輯器編寫如下代碼

// 返回兩個參數值之和的函數
int AddNum(int a,int b){
  return a + b;
}

// 調用 AddNum 函數的函數
void MyFunc(){
  int c;
  c = AddNum(123,456);
}

編寫完成后將其文件名保存為 Sample4.c ，C 語言源文件的擴展名，通常用.c 來表示，上面程序是提供兩個輸入參數並返回它們之和。

在 Windows 操作系統下打開 命令提示符，切換到保存 Sample4.c 的文件夾下，然后在命令提示符中輸入

bcc32 -c -S Sample4.c

bcc32 是啟動 Borland C++ 的命令，-c 的選項是指僅進行編譯而不進行鏈接，-S 選項被用來指定生成匯編語言的源代碼

作為編譯的結果，當前目錄下會生成一個名為Sample4.asm 的匯編語言源代碼。匯編語言源文件的擴展名，通常用.asm 來表示，下面就讓我們用編輯器打開看一下 Sample4.asm 中的內容

	.386p
	ifdef ??version
	if    ??version GT 500H
	.mmx
	endif
	endif
	model flat
	ifndef	??version
	?debug	macro
	endm
	endif
	?debug	S "Sample4.c"
	?debug	T "Sample4.c"
_TEXT	segment dword public use32 'CODE'
_TEXT	ends
_DATA	segment dword public use32 'DATA'
_DATA	ends
_BSS	segment dword public use32 'BSS'
_BSS	ends
DGROUP	group	_BSS,_DATA
_TEXT	segment dword public use32 'CODE'
_AddNum	proc	near
?live1@0:
   ;	
   ;	int AddNum(int a,int b){
   ;	
	push      ebp
	mov       ebp,esp
   ;	
   ;	
   ;	    return a + b;
   ;	
@1:
	mov       eax,dword ptr [ebp+8]
	add       eax,dword ptr [ebp+12]
   ;	
   ;	}
   ;	
@3:
@2:
	pop       ebp
	ret 
_AddNum	endp
_MyFunc	proc	near
?live1@48:
   ;	
   ;	void MyFunc(){
   ;	
	push      ebp
	mov       ebp,esp
   ;	
   ;	    int c;
   ;	    c = AddNum(123,456);
   ;	
@4:
	push      456
	push      123
	call      _AddNum
	add       esp,8
   ;	
   ;	}
   ;	
@5:
	pop       ebp
	ret 
_MyFunc	endp
_TEXT	ends
	public	_AddNum
	public	_MyFunc
	?debug	D "Sample4.c" 20343 45835
	end

這樣，編譯器就成功的把 C 語言轉換成為了匯編代碼了。

不會轉換成本地代碼的偽指令

第一次看到匯編代碼的讀者可能感覺起來比較難，不過實際上其實比較簡單，而且可能比 C 語言還要簡單，為了便於閱讀匯編代碼的源代碼，需要注意幾個要點

匯編語言的源代碼，是由轉換成本地代碼的指令（后面講述的操作碼）和針對匯編器的偽指令構成的。偽指令負責把程序的構造以及匯編的方法指示給匯編器（轉換程序）。不過偽指令是無法匯編轉換成為本地代碼的。下面是上面程序截取的偽指令

_TEXT	segment dword public use32 'CODE'
_TEXT	ends
_DATA	segment dword public use32 'DATA'
_DATA	ends
_BSS	segment dword public use32 'BSS'
_BSS	ends
DGROUP	group	_BSS,_DATA

_AddNum	proc	near
_AddNum	endp

_MyFunc	proc	near
_MyFunc	endp

_TEXT	ends
	end

由偽指令 segment 和 ends 圍起來的部分，是給構成程序的命令和數據的集合體上加一個名字而得到的，稱為段定義。段定義的英文表達具有區域的意思，在這個程序中，段定義指的是命令和數據等程序的集合體的意思，一個程序由多個段定義構成。

上面代碼的開始位置，定義了3個名稱分別為 _TEXT、_DATA、_BSS 的段定義，_TEXT 是指定的段定義，_DATA 是被初始化（有初始值）的數據的段定義，_BSS 是尚未初始化的數據的段定義。這種定義的名稱是由 Borland C++ 定義的，是由 Borland C++ 編譯器自動分配的，所以程序段定義的順序就成為了 _TEXT、_DATA、_BSS ，這樣也確保了內存的連續性

_TEXT	segment dword public use32 'CODE'
_TEXT	ends
_DATA	segment dword public use32 'DATA'
_DATA	ends
_BSS	segment dword public use32 'BSS'
_BSS	ends

段定義( segment ) 是用來區分或者划分范圍區域的意思。匯編語言的 segment 偽指令表示段定義的起始，ends 偽指令表示段定義的結束。段定義是一段連續的內存空間

而group 這個偽指令表示的是將 _BSS和_DATA 這兩個段定義匯總名為 DGROUP 的組

DGROUP	group	_BSS,_DATA

圍起 _AddNum 和 _MyFun 的 _TEXT segment 和 _TEXT ends ，表示_AddNum 和 _MyFun 是屬於 _TEXT 這一段定義的。

_TEXT	segment dword public use32 'CODE'
_TEXT	ends

因此，即使在源代碼中指令和數據是混雜編寫的，經過編譯和匯編后，也會轉換成為規整的本地代碼。

_AddNum proc 和 _AddNum endp 圍起來的部分，以及_MyFunc proc 和 _MyFunc endp 圍起來的部分，分別表示 AddNum 函數和 MyFunc 函數的范圍。

_AddNum	proc	near
_AddNum	endp

_MyFunc	proc	near
_MyFunc	endp

編譯后在函數名前附帶上下划線_ ，是 Borland C++ 的規定。在 C 語言中編寫的 AddNum 函數，在內部是以 _AddNum 這個名稱處理的。偽指令 proc 和 endp 圍起來的部分，表示的是 過程(procedure) 的范圍。在匯編語言中，這種相當於 C 語言的函數的形式稱為過程。

末尾的 end 偽指令，表示的是源代碼的結束。

匯編語言的語法是 操作碼 + 操作數

在匯編語言中，一行表示一對 CPU 的一個指令。匯編語言指令的語法結構是 操作碼 + 操作數，也存在只有操作碼沒有操作數的指令。

操作碼表示的是指令動作，操作數表示的是指令對象。操作碼和操作數一起使用就是一個英文指令。比如從英語語法來分析的話，操作碼是動詞，操作數是賓語。比如這個句子 Give me money這個英文指令的話，Give 就是操作碼，me 和 money 就是操作數。匯編語言中存在多個操作數的情況，要用逗號把它們分割，就像是 Give me,money 這樣。

能夠使用何種形式的操作碼，是由 CPU 的種類決定的，下面對操作碼的功能進行了整理。

本地代碼需要加載到內存后才能運行，內存中存儲着構成本地代碼的指令和數據。程序運行時，CPU會從內存中把數據和指令讀出來，然后放在 CPU 內部的寄存器中進行處理。

如果 CPU 和內存的關系你還不是很了解的話，請閱讀作者的另一篇文章 程序員需要了解的硬核知識之CPU 詳細了解。

寄存器是 CPU 中的存儲區域，寄存器除了具有臨時存儲和計算的功能之外，還具有運算功能，x86 系列的主要種類和角色如下圖所示

指令解析

下面就對 CPU 中的指令進行分析

最常用的 mov 指令

指令中最常使用的是對寄存器和內存進行數據存儲的 mov 指令，mov 指令的兩個操作數，分別用來指定數據的存儲地和讀出源。操作數中可以指定寄存器、常數、標簽(附加在地址前)，以及用方括號([]) 圍起來的這些內容。如果指定了沒有用([]) 方括號圍起來的內容，就表示對該值進行處理；如果指定了用方括號圍起來的內容，方括號的值則會被解釋為內存地址，然后就會對該內存地址對應的值進行讀寫操作。讓我們對上面的代碼片段進行說明

	mov       ebp,esp
	mov       eax,dword ptr [ebp+8]

mov ebp,esp 中，esp 寄存器中的值被直接存儲在了 ebp 中，也就是說，如果 esp 寄存器的值是100的話那么 ebp 寄存器的值也是 100。

而在 mov eax,dword ptr [ebp+8] 這條指令中，ebp 寄存器的值 + 8 后會被解析稱為內存地址。如果 ebp

寄存器的值是100的話，那么 eax 寄存器的值就是 100 + 8 的地址的值。dword ptr 也叫做 double word pointer 簡單解釋一下就是從指定的內存地址中讀出4字節的數據

對棧進行 push 和 pop

程序運行時，會在內存上申請分配一個稱為棧的數據空間。棧（stack）的特性是后入先出，數據在存儲時是從內存的下層（大的地址編號）逐漸往上層（小的地址編號）累積，讀出時則是按照從上往下進行讀取的。

棧是存儲臨時數據的區域，它的特點是通過 push 指令和 pop 指令進行數據的存儲和讀出。向棧中存儲數據稱為 入棧 ，從棧中讀出數據稱為 出棧，32位 x86 系列的 CPU 中，進行1次 push 或者 pop，即可處理 32 位（4字節）的數據。

函數的調用機制

下面我們一起來分析一下函數的調用機制，我們以上面的 C 語言編寫的代碼為例。首先，讓我們從MyFunc 函數調用AddNum 函數的匯編語言部分開始，來對函數的調用機制進行說明。棧在函數的調用中發揮了巨大的作用，下面是經過處理后的 MyFunc 函數的匯編處理內容

_MyFunc 	 proc 	 near
	push 			ebp		  ; 將 ebp 寄存器的值存入棧中              (1) 
	mov				ebp,esp ; 將 esp 寄存器的值存入 ebp 寄存器中	    (2)
	push			456			; 將 456 入棧												  (3)
	push 			123			; 將 123 入棧												  (4)
	call			_AddNum ; 調用 AddNum 函數										 (5)
	add				esp,8		; esp 寄存器的值 + 8										(6)
	pop				ebp			; 讀出棧中的數值存入 esp 寄存器中				 (7)
	ret 							; 結束 MyFunc 函數，返回到調用源					(8)
_MyFunc 		endp

代碼解釋中的(1)、(2)、(7)、(8)的處理適用於 C 語言中的所有函數，我們會在后面展示 AddNum 函數處理內容時進行說明。這里希望大家先關注(3) - (6) 這一部分，這對了解函數調用機制至關重要。

(3) 和 (4) 表示的是將傳遞給 AddNum 函數的參數通過 push 入棧。在 C 語言源代碼中，雖然記述為函數 AddNum(123,456)，但入棧時則會先按照 456，123 這樣的順序。也就是位於后面的數值先入棧。這是 C 語言的規定。(5) 表示的 call 指令，會把程序流程跳轉到 AddNum 函數指令的地址處。在匯編語言中，函數名表示的就是函數所在的內存地址。AddNum 函數處理完畢后，程序流程必須要返回到編號(6) 這一行。call 指令運行后，call 指令的下一行(也就指的是 (6) 這一行)的內存地址(調用函數完畢后要返回的內存地址)會自動的 push 入棧。該值會在 AddNum 函數處理的最后通過 ret 指令 pop 出棧，然后程序會返回到 (6) 這一行。

(6) 部分會把棧中存儲的兩個參數 (456 和 123) 進行銷毀處理。雖然通過兩次的 pop 指令也可以實現，不過采用 esp 寄存器 + 8 的方式會更有效率(處理 1 次即可)。對棧進行數值的輸入和輸出時，數值的單位是4字節。因此，通過在負責棧地址管理的 esp 寄存器中加上4的2倍8，就可以達到和運行兩次 pop 命令同樣的效果。雖然內存中的數據實際上還殘留着，但只要把 esp 寄存器的值更新為數據存儲地址前面的數據位置，該數據也就相當於銷毀了。

我在編譯 Sample4.c 文件時，出現了下圖的這條消息

圖中的意思是指 c 的值在 MyFunc 定義了但是一直未被使用，這其實是一項編譯器優化的功能，由於存儲着 AddNum 函數返回值的變量 c 在后面沒有被用到，因此編譯器就認為 該變量沒有意義，進而也就沒有生成與之對應的匯編語言代碼。

下圖是調用 AddNum 這一函數前后棧內存的變化

函數的內部處理

上面我們用匯編代碼分析了一下 Sample4.c 整個過程的代碼，現在我們着重分析一下 AddNum 函數的源代碼部分，分析一下參數的接收、返回值和返回等機制

_AddNum 		proc		near
	push			ebp			               -----------(1)
	mov				ebp,esp                -----------(2)
	mov				eax,dword ptr[ebp+8]   -----------(3)
	add				eax,dword ptr[ebp+12]  -----------(4)
	pop				ebp										 -----------(5)
	ret				----------------------------------(6)
_AddNum			endp

ebp 寄存器的值在(1)中入棧，在(5)中出棧，這主要是為了把函數中用到的 ebp 寄存器的內容，恢復到函數調用前的狀態。

(2) 中把負責管理棧地址的 esp 寄存器的值賦值到了 ebp 寄存器中。這是因為，在 mov 指令中方括號內的參數，是不允許指定 esp 寄存器的。因此，這里就采用了不直接通過 esp，而是用 ebp 寄存器來讀寫棧內容的方法。

(3) 使用[ebp + 8] 指定棧中存儲的第1個參數123，並將其讀出到 eax 寄存器中。像這樣，不使用 pop 指令，也可以參照棧的內容。而之所以從多個寄存器中選擇了 eax 寄存器，是因為 eax 是負責運算的累加寄存器。

通過(4) 的 add 指令，把當前 eax 寄存器的值同第2個參數相加后的結果存儲在 eax 寄存器中。[ebp + 12] 是用來指定第2個參數456的。在 C 語言中，函數的返回值必須通過 eax 寄存器返回，這也是規定。也就是 函數的參數是通過棧來傳遞，返回值是通過寄存器返回的。

(6) 中 ret 指令運行后，函數返回目的地內存地址會自動出棧，據此，程序流程就會跳轉返回到(6) (Call _AddNum) 的下一行。這時，AddNum 函數入口和出口處棧的狀態變化，就如下圖所示

全局變量和局部變量

在熟悉了匯編語言后，接下來我們來了解一下全局變量和局部變量，在函數外部定義的變量稱為全局變量，在函數內部定義的變量稱為局部變量，全局變量可以在任意函數中使用，局部變量只能在函數定義局部變量的內部使用。下面，我們就通過匯編語言來看一下全局變量和局部變量的不同之處。

下面定義的 C 語言代碼分別定義了局部變量和全局變量，並且給各變量進行了賦值，我們先看一下源代碼部分

// 定義被初始化的全局變量
int a1 = 1;
int a2 = 2;
int a3 = 3;
int a4 = 4;
int a5 = 5;

// 定義沒有初始化的全局變量
int b1,b2,b3,b4,b5;

// 定義函數
void MyFunc(){
  // 定義局部變量
  int c1,c2,c3,c4,c5,c6,c7,c8,c9,c10;
  
  // 給局部變量賦值
  c1 = 1;
  c2 = 2;
  c3 = 3;
  c4 = 4;
  c5 = 5;
  c6 = 6;
  c7 = 7;
  c8 = 8;
  c9 = 9;
  c10 = 10;
  
  // 把局部變量賦值給全局變量
  a1 = c1;
  a2 = c2;
  a3 = c3;
  a4 = c4;
  a5 = c5;
  b1 = c6;
  b2 = c7;
  b3 = c8;
  b4 = c9;
  b5 = c10;
}

上面的代碼挺暴力的，不過沒關系，能夠便於我們分析其匯編源碼就好，我們用 Borland C++ 編譯后的匯編代碼如下，編譯完成后的源碼比較長，這里我們只拿出來一部分作為分析使用（我們改變了一下段定義順序，刪除了部分注釋）

_DATA segment dword public use32 'DATA'
   align 4
  _a1 label dword
   			dd 1
   align 4
  _a2 label dword
   			dd 2
   align 4
  _a3 label dword
   			dd 3
   align 4
  _a4 label dword
   			dd 4
   align 4
  _a5 label dword
   			dd 5
_DATA ends

_BSS segment dword public use32 'BSS'
 align 4
  _b1 label dword
   			db 4 dup(?)
   align 4
  _b2 label dword
   			db 4 dup(?)
   align 4
  _b3 label dword
   			db 4 dup(?)
   align 4
  _b4 label dword
   			db 4 dup(?)
   align 4
  _b5 label dword
   			db 4 dup(?)
_BSS ends

_TEXT segment dword public use32 'CODE'
_MyFunc proc near

 push      ebp
 mov       ebp,esp
 add       esp,-20
 push      ebx
 push      esi
 mov       eax,1
 mov       edx,2
 mov       ecx,3
 mov       ebx,4
 mov       esi,5
 mov       dword ptr [ebp-4],6
 mov       dword ptr [ebp-8],7
 mov       dword ptr [ebp-12],8
 mov       dword ptr [ebp-16],9
 mov       dword ptr [ebp-20],10
 mov       dword ptr [_a1],eax
 mov       dword ptr [_a2],edx
 mov       dword ptr [_a3],ecx
 mov       dword ptr [_a4],ebx
 mov       dword ptr [_a5],esi
 mov       eax,dword ptr [ebp-4]
 mov       dword ptr [_b1],eax
 mov       edx,dword ptr [ebp-8]
 mov       dword ptr [_b2],edx
 mov       ecx,dword ptr [ebp-12]
 mov       dword ptr [_b3],ecx
 mov       eax,dword ptr [ebp-16]
 mov       dword ptr [_b4],eax
 mov       edx,dword ptr [ebp-20]
 mov       dword ptr [_b5],edx
 pop       esi
 pop       ebx
 mov       esp,ebp
 pop       ebp
 ret
 
_MyFunc   endp
_TEXT 	ends

編譯后的程序，會被歸類到名為段定義的組。

• 初始化的全局變量，會匯總到名為 _DATA 的段定義中

_DATA segment dword public use32 'DATA'
...
_DATA ends

• 沒有初始化的全局變量，會匯總到名為 _BSS 的段定義中

_BSS segment dword public use32 'BSS'
 ...
_BSS ends

• 被段定義 _TEXT 圍起來的匯編代碼則是 Borland C++ 的定義

_TEXT segment dword public use32 'CODE'
_MyFunc proc near
...
_MyFunc   endp
_TEXT 	ends

我們在分析上面匯編代碼之前，先來認識一下更多的匯編指令，此表是對上面部分操作碼及其功能的接續

操作碼	操作數	功能
add	A,B	把A和B的值相加，並把結果賦值給A
call	A	調用函數A
cmp	A,B	對A和B進行比較，比較結果會自動存入標志寄存器中
inc	A	對A的值 + 1
ige	標簽名	和 cmp 命令組合使用。跳轉到標簽行
jl	標簽名	和 cmp 命令組合使用。跳轉到標簽行
jle	標簽名	和 cmp 命令組合使用。跳轉到標簽行
jmp	標簽名	和 cmp 命令組合使用。跳轉到標簽行
mov	A,B	把 B 的值賦給 A
pop	A	從棧中讀取數值並存入A
push	A	把A的值存入棧中
ret	無	將處理返回到調用源
xor	A,B	A和B的位進行亦或比較，並將結果存入A中

我們首先來看一下 _DATA 段定義的內容。 _a1 label dword 定義了 _a1 這個標簽。標簽表示的是相對於段定義起始位置的位置。由於_a1 在 _DATA 段定義的開頭位置，所以相對位置是0。 _a1 就相當於是全局變量a1。編譯后的函數名和變量名前面會加一個(_)，這也是 Borland C++ 的規定。dd 1 指的是，申請分配了4字節的內存空間，存儲着1這個初始值。 dd指的是 define double word 表示有兩個長度為2的字節領域(word)，也就是4字節的意思。

Borland C++ 中，由於int 類型的長度是4字節，因此匯編器就把 int a1 = 1 變換成了 _a1 label dword 和 dd 1。同樣，這里也定義了相當於全局變量的 a2 - a5 的標簽 _a2 - _a5，它們各自的初始值 2 - 5 也被存儲在各自的4字節中。

接下來，我們來說一說 _BSS 段定義的內容。這里定義了相當於全局變量 b1 - b5 的標簽 _b1 - _b5。其中的db 4dup(?) 表示的是申請分配了4字節的領域，但值尚未確定（這里用 ? 來表示）的意思。db(define byte) 表示有1個長度是1字節的內存空間。因而，db 4 dup(?) 的情況下，就是4字節的內存空間。

注意：db 4 dup(?) 不要和 dd 4 混淆了，前者表示的是4個長度是1字節的內存空間。而 db 4 表示的則是雙字節( = 4 字節) 的內存空間中存儲的值是 4

臨時確保局部變量使用的內存空間

我們知道，局部變量是臨時保存在寄存器和棧中的。函數內部利用棧進行局部變量的存儲，函數調用完成后，局部變量值被銷毀，但是寄存器可能用於其他目的。所以，局部變量只是函數在處理期間臨時存儲在寄存器和棧中的。

回想一下上述代碼是不是定義了10個局部變量？這是為了表示存儲局部變量的不僅僅是棧，還有寄存器。為了確保 c1 - c10 所需的域，寄存器空閑的時候就會使用寄存器，寄存器空間不足的時候就會使用棧。

讓我們繼續來分析上面代碼的內容。_TEXT段定義表示的是 MyFunc 函數的范圍。在 MyFunc 函數中定義的局部變量所需要的內存領域。會被盡可能的分配在寄存器中。大家可能認為使用高性能的寄存器來替代普通的內存是一種資源浪費，但是編譯器不這么認為，只要寄存器有空間，編譯器就會使用它。由於寄存器的訪問速度遠高於內存，所以直接訪問寄存器能夠高效的處理。局部變量使用寄存器，是 Borland C++ 編譯器最優化的運行結果。

代碼清單中的如下內容表示的是向寄存器中分配局部變量的部分

mov       eax,1
mov       edx,2
mov       ecx,3
mov       ebx,4
mov       esi,5

僅僅對局部變量進行定義是不夠的，只有在給局部變量賦值時，才會被分配到寄存器的內存區域。上述代碼相當於就是給5個局部變量 c1 - c5 分別賦值為 1 - 5。eax、edx、ecx、ebx、esi 是 x86 系列32位 CPU 寄存器的名稱。至於使用哪個寄存器，是由編譯器來決定的 。

x86 系列 CPU 擁有的寄存器中，程序可以操作的是十幾，其中空閑的最多會有幾個。因而，局部變量超過寄存器數量的時候，可分配的寄存器就不夠用了，這種情況下，編譯器就會把棧派上用場，用來存儲剩余的局部變量。

在上述代碼這一部分，給局部變量c1 - c5 分配完寄存器后，可用的寄存器數量就不足了。於是，剩下的5個局部變量c6 - c10 就被分配給了棧的內存空間。如下面代碼所示

mov       dword ptr [ebp-4],6
mov       dword ptr [ebp-8],7
mov       dword ptr [ebp-12],8
mov       dword ptr [ebp-16],9
mov       dword ptr [ebp-20],10

函數入口 add esp,-20 指的是，對棧數據存儲位置的 esp 寄存器(棧指針)的值做減20的處理。為了確保內存變量 c6 - c10 在棧中，就需要保留5個 int 類型的局部變量（4字節 * 5 = 20 字節）所需的空間。 mov ebp,esp這行指令表示的意思是將 esp 寄存器的值賦值到 ebp 寄存器。之所以需要這么處理，是為了通過在函數出口處 mov esp ebp 這一處理，把 esp 寄存器的值還原到原始狀態，從而對申請分配的棧空間進行釋放，這時棧中用到的局部變量就消失了。這也是棧的清理處理。在使用寄存器的情況下，局部變量則會在寄存器被用於其他用途時自動消失，如下圖所示。

 mov       dword ptr [ebp-4],6
 mov       dword ptr [ebp-8],7
 mov       dword ptr [ebp-12],8
 mov       dword ptr [ebp-16],9
 mov       dword ptr [ebp-20],10

這五行代碼是往棧空間代入數值的部分，由於在向棧申請內存空間前，借助了 mov ebp, esp 這個處理，esp 寄存器的值被保存到了 esp 寄存器中，因此，通過使用[ebp - 4]、[ebp - 8]、[ebp - 12]、[ebp - 16]、[ebp - 20] 這樣的形式，就可以申請分配20字節的棧內存空間切分成5個長度為4字節的空間來使用。例如， mov dword ptr [ebp-4],6 表示的就是，從申請分配的內存空間的下端(ebp寄存器指示的位置)開始向前4字節的地址([ebp - 4]) 中，存儲着6這一4字節數據。

循環控制語句的處理

上面說的都是順序流程，那么現在就讓我們分析一下循環流程的處理，看一下 for 循環以及 if 條件分支等 c 語言程序的 流程控制是如何實現的，我們還是以代碼以及編譯后的結果為例，看一下程序控制流程的處理過程。

// 定義MySub 函數
void MySub(){
  // 不做任何處理
  
}

// 定義MyFunc 函數
void Myfunc(){
  int i;
  for(int i = 0;i < 10;i++){
    // 重復調用MySub十次
    MySub();
  }
}

上述代碼將局部變量 i 作為循環條件，循環調用十次MySub 函數，下面是它主要的匯編代碼

		xor 		ebx, ebx 	; 將寄存器清0
@4  call		_MySub		; 調用MySub函數
		inc			ebx				; ebx寄存器的值 + 1
		cmp			ebx,10		;	將ebx寄存器的值和10進行比較
		jl			short @4	; 如果小於10就跳轉到 @4

C 語言中的 for 語句是通過在括號中指定循環計數器的初始值(i = 0)、循環的繼續條件(i < 10)、循環計數器的更新(i++) 這三種形式來進行循環處理的。與此相對的匯編代碼就是通過比較指令(cmp) 和 跳轉指令(jl)來實現的。

下面我們來對上述代碼進行說明

MyFunc 函數中用到的局部變量只有 i ，變量 i 申請分配了 ebx 寄存器的內存空間。for 語句括號中的 i = 0 被轉換為 xor ebx,ebx 這一處理，xor 指令會對左起第一個操作數和右起第二個操作數進行 XOR 運算，然后把結果存儲在第一個操作數中。由於這里把第一個操作數和第二個操作數都指定為了 ebx，因此就變成了對相同數值的 XOR 運算。也就是說不管當前寄存器的值是什么，最終的結果都是0。類似的，我們使用 mov ebx,0 也能得到相同的結果，但是 xor 指令的處理速度更快，而且編譯器也會啟動最優化功能。

XOR 指的就是異或操作，它的運算規則是 如果a、b兩個值不相同，則異或結果為1。如果a、b兩個值相同，異或結果為0。

相同數值進行 XOR 運算，運算結果為0。XOR 的運算規則是，值不同時結果為1，值相同時結果為0。例如 01010101 和 01010101 進行運算，就會分別對各個數字位進行 XOR 運算。因為每個數字位都相同，所以運算結果為0。

ebx 寄存器的值初始化后，會通過 call 指定調用 _MySub 函數，從 _MySub 函數返回后，會執行inc ebx 指令，對 ebx 的值進行 + 1 操作，這個操作就相當於 i++ 的意思，++ 表示的就是當前數值 + 1。

這里需要知道 i++ 和 ++i 的區別

i++ 是先賦值，復制完成后再對 i執行 + 1 操作

++i 是先進行 +1 操作，完成后再進行賦值

inc 下一行的 cmp 是用來對第一個操作數和第二個操作數的數值進行比較的指令。 cmp ebx,10 就相當於 C 語言中的 i < 10 這一處理，意思是把 ebx 寄存器的值與10進行比較。匯編語言中比較指令的結果，會存儲在 CPU 的標志寄存器中。不過，標志寄存器的值，程序是無法直接參考的。那如何判斷比較結果呢？

匯編語言中有多個跳轉指令，這些跳轉指令會根據標志寄存器的值來判斷是否進行跳轉操作，例如最后一行的 jl，它會根據 cmp ebx,10 指令所存儲在標志寄存器中的值來判斷是否跳轉，jl 這條指令表示的就是 jump on less than(小於的話就跳轉)。發現如果 i 比 10 小，就會跳轉到 @4 所在的指令處繼續執行。

那么匯編代碼的意思也可以用 C 語言來改寫一下，加深理解

		i ^= i;
L4: MySub();
		i++;
		if(i < 10) goto L4;

代碼第一行 i ^= i 指的就是 i 和 i 進行異或運算，也就是 XOR 運算，MySub() 函數用 L4 標簽來替代，然后進行 i 自增操作，如果i 的值小於 10 的話，就會一直循環 MySub() 函數。

條件分支的處理方法

條件分支的處理方式和循環的處理方式很相似，使用的也是 cmp 指令和跳轉指令。下面是用 C 語言編寫的條件分支的代碼

// 定義MySub1 函數
void MySub1(){

 // 不做任何處理
}

// 定義MySub2 函數
void MySub2(){
  
 // 不做任何處理
}

// 定義MySub3 函數
void MySub3(){

 // 不做任何處理
}

// 定義MyFunc 函數
void MyFunc(){

 int a = 123;
 // 根據條件調用不同的函數
 if(a > 100){
  MySub1();
 }
 else if(a < 50){
  MySub2();
 }
 else
 {
  MySub3();
 }

}

很簡單的一個實現了條件判斷的 C 語言代碼，那么我們把它用 Borland C++ 編譯之后的結果如下

_MyFunc proc near
 push      ebp 				
 mov       ebp,esp
 mov       eax,123			; 把123存入 eax 寄存器中
 cmp       eax,100			; 把 eax 寄存器的值同100進行比較
 jle       short @8			; 比100小時，跳轉到@8標簽
 call      _MySub1			; 調用MySub1函數
 jmp 			 short @11 		; 跳轉到@11標簽
@8:
 cmp       eax,50				; 把 eax 寄存器的值同50進行比較
 jge       short @10		; 比50大時，跳轉到@10標簽
 call      _MySub2			; 調用MySub2函數
 jmp			 short @11		; 跳轉到@11標簽
@10:
 call      _MySub3			; 調用MySub3函數
@11:
 pop       ebp
 ret 
_MyFunc endp

上面代碼用到了三種跳轉指令，分別是jle(jump on less or equal) 比較結果小時跳轉，jge(jump on greater or equal) 比較結果大時跳轉，還有不管結果怎樣都會進行跳轉的jmp，在這些跳轉指令之前還有用來比較的指令 cmp，構成了上述匯編代碼的主要邏輯形式。

了解程序運行邏輯的必要性

通過對上述匯編代碼和 C 語言源代碼進行比較，想必大家對程序的運行方式有了新的理解，而且，從匯編源代碼中獲取的知識，也有助於了解 Java 等高級語言的特性，比如 Java 中就有 native 關鍵字修飾的變量，那么這個變量的底層就是使用 C 語言編寫的，還有一些 Java 中的語法糖只有通過匯編代碼才能知道其運行邏輯。在某些情況下，對於查找 bug 的原因也是有幫助的。

上面我們了解到的編程方式都是串行處理的，那么串行處理有什么特點呢？

串行處理最大的一個特點就是專心只做一件事情，一件事情做完之后才會去做另外一件事情。

計算機是支持多線程的，多線程的核心就是 CPU切換，如下圖所示

我們還是舉個實際的例子，讓我們來看一段代碼

// 定義全局變量
int counter = 100;

// 定義MyFunc1()
void MyFunc(){
  counter *= 2;
}

// 定義MyFunc2()
void MyFunc2(){
  counter *= 2;
}

上述代碼是更新 counter 的值的 C 語言程序，MyFunc1() 和 MyFunc2() 的處理內容都是把 counter 的值擴大至原來的二倍，然后再把 counter 的值賦值給 counter 。這里，我們假設使用多線程處理，同時調用了一次MyFunc1 和 MyFunc2 函數，這時，全局變量 counter 的值，理應編程 100 * 2 * 2 = 400。如果你開啟了多個線程的話，你會發現 counter 的數值有時也是 200，對於為什么出現這種情況，如果你不了解程序的運行方式，是很難找到原因的。

我們將上面的代碼轉換成匯編語言的代碼如下

mov eax,dword ptr[_counter] 	; 將 counter 的值讀入 eax 寄存器
add eax,eax										; 將 eax 寄存器的值擴大2倍。
mov dword ptr[_counter],eax		; 將 eax 寄存器的值存入 counter 中。

在多線程程序中，用匯編語言表示的代碼每運行一行，處理都有可能切換到其他線程中。因而，假設 MyFun1 函數在讀出 counter 數值100后，還未來得及將它的二倍值200寫入 counter 時，正巧 MyFun2 函數讀出了 counter 的值100，那么結果就將變為 200 。

為了避免該bug，我們可以采用以函數或 C 語言代碼的行為單位來禁止線程切換的鎖定方法，或者使用某種線程安全的方式來避免該問題的出現。

現在基本上沒有人用匯編語言來編寫程序了，因為 C、Java等高級語言的效率要比匯編語言快很多。不過，匯編語言的經驗還是很重要的，通過借助匯編語言，我們可以更好的了解計算機運行機制。

文章參考

https://www.computerhope.com/jargon/m/memory.htm

https://baike.baidu.com/item/隊列/14580481?fr=aladdin

https://baike.baidu.com/item/棧/12808149?fr=aladdin

https://baike.baidu.com/item/環形緩沖器/22701730?fr=aladdin

《程序是怎樣跑起來的》

https://baike.baidu.com/item/匯編語言/61826?fr=aladdin

https://baike.baidu.com/item/Windows操作系統/852149?fr=aladdin

磁盤

磁盤緩存

虛擬內存

https://baike.baidu.com/item/壓縮算法/2762648

https://en.wikipedia.org/wiki/Central_processing_unit

https://www.digitaltrends.com/computing/what-is-a-cpu/

https://baike.baidu.com/item/寄存器/187682?fr=aladdin

https://baike.baidu.com/item/內存/103614?fr=aladdin

https://blog.csdn.net/mark_lq/article/details/44245423

https://baike.baidu.com/item/程序計數器/3219536?fr=aladdin

https://zhidao.baidu.com/question/124425422.html