C/C++編譯原理

轉自：http://m.blog.csdn.net/blog/business122/21722039    http://m.blog.csdn.net/blog/business122/21722151

C/C++編譯就是要將C/C++的代碼映射到相應的機器碼，以及討論其中的內存管理模式，包括內存的分配，如何使用等等，整型、數組、指針等這些在內存中的實現機制。

C/C++的編譯包括幾個部分，分別是編譯，彙編和連接。

1. 編譯，就是將相應的高級語言代碼映射到彙編語言，處理define，include等命令，加載外部的代碼；

2. 彙編，就是將彙編語言映射到機器碼；

3. 連接，造成相應的動態和靜態連接庫。動態鏈接庫是在程序運行時動態的加載，靜態鏈接庫是直接拷貝進入程序，在程序執行時，這些靜態鏈接庫加載進來。

第一篇：     
首先是預編譯，這一步能夠粗略的認爲只作了一件事情，那就是「宏展開」，也就是對那些#***的命令的一種展開。

      例如define MAX 1000就是創建起MAX和1000之間的對等關係，好在編譯階段進行替換。

      例如ifdef/ifndef就是從一個文件中有選擇性的挑出一些符合條件的代碼來交給下一步的編譯階段來處理。這裏面最複雜的莫過於include了，其實也很簡單，就是至關於把那個對應的文件裏面的內容一會兒替換到這條include***語句的地方來。

      其次是編譯，這一步很重要，編譯是以一個個獨立的文件做爲單元的，一個文件就會編譯出一個目標文件。（這裏插入一點關於編譯的文件的說明，編譯器經過後綴名來辨識是否編譯該文件，所以「.h」的頭文件一律不理會，而「.cpp」的源文件一概都要被編譯，我實驗過把.h文件的後綴名改成.cpp，而後在include的地方相應的改成***.cpp，這樣一來，編譯器就會編譯許多沒必要要的頭文件，只不過頭文件裏咱們一般只放置聲明而不是定義，所以最後連接生成的可執行文件的大小是不會改變的）

      清楚編譯是以一個個單獨的文件爲單元的，這一點很重要，所以編譯只負責本單元的那些事，而對外部的事情一律不理會，在這一步裏，咱們能夠調用一個函數而沒必要給出這個函數的定義，可是要在調用前獲得這個函數的聲明（其實這就是include的本質，不就是爲了給你提早提供個聲明而好讓你使用嗎？至於那個函數究竟是如何實現的，須要在連接這一步裏去找函數的入口地址。所以提供聲明的方式能夠是用include把放在別的文件中的聲明拿過來，也能夠是在調用以前本身寫一句void max(int,int);都行。），編譯階段剩下的事情就是分析語法的正確性之類的工做了。好啦，總結一下，能夠粗略的認爲編譯階段分兩步：    

        第一步，檢驗函數或者變量是否存在它們的聲明；

        第二步，檢查語句是否符合C++語法。

最後一步是連接，它會把全部編譯好的單元所有連接爲一個總體文件，其實這一步能夠比做一個「連線」的過程，好比A文件用了B文件中的函數，那麼連接的這一步會創建起這個關聯。連接時最重要的我認爲是檢查全局空間裏面是否是有重複定義或者缺失定義。這也就解釋了爲何咱們通常不在頭文件中出現定義，由於頭文件有可能被釋放到多個源文件中，每一個源文件都會單獨編譯，連接時就會發現全局空間中有多個定義了。

標準C和C++將編譯過程定義爲9個階段(Phases of Translation)：

1.字符映射(Character Mapping)

    文件中的物理源字符被映射到源字符集中，其中包括三字符運算符的替換、控制字符(行尾的回車換行)的替換。許多非美式鍵盤不支持基本源字符集中的一些字符，文件中可用三字符來代替這些基本源字符，以??爲前導。但若是所用鍵盤是美式鍵盤，有些編譯器可能不對三字符進行查找和替換，須要增長-trigraphs編譯參數。在C++程序中，任何不在基本源字符集中的字符都被它的通用字符名替換。

2.行合併(Line Splicing)

    以反斜槓/結束的行和它接下來的行合併。

3.標記化(Tokenization)

    每一條註釋被一個單獨的空字符所替換。C++雙字符運算符被識別爲標記(爲了開發可讀性更強的程序，C++爲非ASCII碼開發者定義了一套雙字符運算符集和新的保留字集)。源代碼被分析成預處理標記。

4.預處理(Preprocessing)

    調用預處理指令並擴展宏。使用#include指令包含的文件，重複步驟1到4。上述四個階段統稱爲預處理階段。

5.字符集映射(Character-set Mapping)

    源字符集成員、轉義序列被轉換成等價的執行字符集成員。例如：'/a'在ASCII環境下會被轉換成值爲一個字節，值爲7。

6.字符串鏈接(String Concatenation)

    相鄰的字符串被鏈接。例如："""hahaha""huohuohuo"將成爲"hahahahuohuohuo"。

7.翻譯(Translation)

    進行語法和語義分析編譯，並翻譯成目標代碼。

8.處理模板

    處理模板實例。

9.鏈接(Linkage)

    解決外部引用的問題，準備好程序映像以便執行。

第二篇：

1、C++編譯模式
一般，在一個C++程序中，只包含兩類文件——.cpp文件和.h文件。其中，.cpp文件被稱做C++源文件，裏面放的都是C++的源代碼；而.h文件則被稱做C++頭文件，裏面放的也是C++的源代碼。
C+ +語言支持「分別編譯」（separate compilation）。也就是說，一個程序全部的內容，能夠分紅不一樣的部分分別放在不一樣的.cpp文件裏。.cpp文件裏的東西都是相對獨立的，在編 譯（compile）時不須要與其餘文件互通，只須要在編譯成目標文件後再與其餘的目標文件作一次連接（link）就好了。好比，在文件a.cpp中定義 了一個全局函數「void a() {}」，而在文件b.cpp中須要調用這個函數。即便這樣，文件a.cpp和文件b.cpp並不須要相互知道對方的存在，而是能夠分別地對它們進行編譯， 編譯成目標文件以後再連接，整個程序就能夠運行了。
這是怎麼實現的呢？從寫程序的角度來說，很簡單。在文件b.cpp中，在調用 「void a()」函數以前，先聲明一下這個函數「void a();」，就能夠了。這是由於編譯器在編譯b.cpp的時候會生成一個符號表（symbol table），像「void a()」這樣的看不到定義的符號，就會被存放在這個表中。再進行連接的時候，編譯器就會在別的目標文件中去尋找這個符號的定義。一旦找到了，程序也就能夠 順利地生成了。
注意這裏提到了兩個概念，一個是「定義」，一個是「聲明」。簡單地說，「定義」就是把一個符號完完整整地描述出來：它是變 量仍是函數，返回什麼類型，須要什麼參數等等。而「聲明」則只是聲明這個符號的存在，即告訴編譯器，這個符號是在其餘文件中定義的，我這裏先用着，你連接 的時候再到別的地方去找找看它究竟是什麼吧。定義的時候要按C++語法完整地定義一個符號（變量或者函數），而聲明的時候就只須要寫出這個符號的原型了。 須要注意的是，一個符號，在整個程序中能夠被聲明屢次，但卻要且僅要被定義一次。試想，若是一個符號出現了兩種不一樣的定義，編譯器該聽誰的？
這 種機制給C++程序員們帶來了不少好處，同時也引出了一種編寫程序的方法。考慮一下，若是有一個很經常使用的函數「void f() {}」，在整個程序中的許多.cpp文件中都會被調用，那麼，咱們就只須要在一個文件中定義這個函數，而在其餘的文件中聲明這個函數就能夠了。一個函數還 好對付，聲明起來也就一句話。可是，若是函數多了，好比是一大堆的數學函數，有好幾百個，那怎麼辦？能保證每一個程序員均可以完徹底全地把全部函數的形式都 準確地記下來並寫出來嗎？

2、什麼是頭文件
很顯然，答案是不可能。可是有一個很簡單地辦法，能夠幫助程序員們省去記住那麼多函數原型的麻煩：咱們能夠把那幾百個函數的聲明語句全都先寫好，放在一個文件裏，等到程序員須要它們的時候，就把這些東西所有copy進他的源代碼中。
這 個方法當然可行，但仍是太麻煩，並且還顯得很笨拙。因而，頭文件即可以發揮它的做用了。所謂的頭文件，其實它的內容跟.cpp文件中的內容是同樣的，都是 C++的源代碼。但頭文件不用被編譯。咱們把全部的函數聲明所有放進一個頭文件中，當某一個.cpp源文件須要它們時，它們就能夠經過一個宏命令 「#include」包含進這個.cpp文件中，從而把它們的內容合併到.cpp文件中去。當.cpp文件被編譯時，這些被包含進去的.h文件的做用便發 揮了。
舉一個例子吧，假設全部的數學函數只有兩個：f1和f2，那麼咱們把它們的定義放在math.cpp裏：
/* math.cpp */
double f1()
{
//do something here....
return;
}
double f2(double a)
{
//do something here...
return a * a;
}
/* end of math.cpp */
並把「這些」函數的聲明放在一個頭文件math.h中：
/* math.h */

double f1();
double f2(double);
/* end of math.h */
在另外一個文件main.cpp中，我要調用這兩個函數，那麼就只須要把頭文件包含進來：
/* main.cpp */
#include "math.h"
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of main.cpp */
這 樣，即是一個完整的程序了。須要注意的是，.h文件不用寫在編譯器的命令以後，但它必需要在編譯器找獲得的地方（好比跟main.cpp在一個目錄下）。 main.cpp和math.cpp均可以分別經過編譯，生成main.o和math.o，而後再把這兩個目標文件進行連接，程序就能夠運行了。

3、#include
#include 是一個來自C語言的宏命令，它在編譯器進行編譯以前，即在預編譯的時候就會起做用。#include的做用是把它後面所寫的那個文件的內容，完完整整地、 一字不改地包含到當前的文件中來。值得一提的是，它自己是沒有其它任何做用與副功能的，它的做用就是把每個它出現的地方，替換成它後面所寫的那個文件的 內容。簡單的文本替換，別無其餘。所以，main.cpp文件中的第一句（#include "math.h"），在編譯以前就會被替換成math.h文件的內容。即在編譯過程將要開始的時候，main.cpp的內容已經發生了改變：
/* ~main.cpp */
double f1();
double f2(double);
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of ~main.cpp */
很少很多，剛恰好。同理可知，若是咱們除了main.cpp之外，還有其餘的不少.cpp文件也用到了f1和f2函數的話，那麼它們也統統只須要在使用這兩個函數前寫上一句#include "math.h"就好了。

4、頭文件中應該寫什麼
通 過上面的討論，咱們能夠了解到，頭文件的做用就是被其餘的.cpp包含進去的。它們自己並不參與編譯，但實際上，它們的內容卻在多個.cpp文件中獲得了 編譯。經過「定義只能有一次」的規則，咱們很容易能夠得出，頭文件中應該只放變量和函數的聲明，而不能放它們的定義。由於一個頭文件的內容其實是會被引 入到多個不一樣的.cpp文件中的，而且它們都會被編譯。放聲明固然沒事，若是放了定義，那麼也就至關於在多個文件中出現了對於一個符號（變量或函數）的定 義，縱然這些定義都是相同的，但對於編譯器來講，這樣作不合法。
因此，應該記住的一點就是，.h頭文件中，只能存在變量或者函數的聲明， 而不要放定義。即，只能在頭文件中寫形如：extern int a;和void f();的句子。這些纔是聲明。若是寫上int a;或者void f() {}這樣的句子，那麼一旦這個頭文件被兩個或兩個以上的.cpp文件包含的話，編譯器會立馬報錯。（關於extern，前面有討論過，這裏再也不討論定義跟 聲明的區別了。）
可是，這個規則是有三個例外的。
一，頭文件中能夠寫const對象的定義。由於全局的const對象默 認是沒有extern的聲明的，因此它只在當前文件中有效。把這樣的對象寫進頭文件中，即便它被包含到其餘多個.cpp文件中，這個對象也都只在包含它的 那個文件中有效，對其餘文件來講是不可見的，因此便不會致使多重定義。同時，由於這些.cpp文件中的該對象都是從一個頭文件中包含進去的，這樣也就保證 了這些.cpp文件中的這個const對象的值是相同的，可謂一箭雙鵰。同理，static對象的定義也能夠放進頭文件。
二，頭文件中可 以寫內聯函數（inline）的定義。由於inline函數是須要編譯器在遇到它的地方根據它的定義把它內聯展開的，而並不是是普通函數那樣能夠先聲明再鏈 接的（內聯函數不會連接），因此編譯器就須要在編譯時看到內聯函數的完整定義才行。若是內聯函數像普通函數同樣只能定義一次的話，這事兒就難辦了。由於在 一個文件中還好，我能夠把內聯函數的定義寫在最開始，這樣能夠保證後面使用的時候均可以見到定義；可是，若是我在其餘的文件中還使用到了這個函數那怎麼辦 呢？這幾乎沒什麼太好的解決辦法，所以C++規定，內聯函數能夠在程序中定義屢次，只要內聯函數在一個.cpp文件中只出現一次，而且在全部的.cpp文 件中，這個內聯函數的定義是同樣的，就能經過編譯。那麼顯然，把內聯函數的定義放進一個頭文件中是很是明智的作法。

三，頭文件中能夠寫類 （class）的定義。由於在程序中建立一個類的對象時，編譯器只有在這個類的定義徹底可見的狀況下，才能知道這個類的對象應該如何佈局，因此，關於類的 定義的要求，跟內聯函數是基本同樣的。因此把類的定義放進頭文件，在使用到這個類的.cpp文件中去包含這個頭文件，是一個很好的作法。在這裏，值得一提 的是，類的定義中包含着數據成員和函數成員。數據成員是要等到具體的對象被建立時纔會被定義（分配空間），但函數成員倒是須要在一開始就被定義的，這也就 是咱們一般所說的類的實現。通常，咱們的作法是，把類的定義放在頭文件中，而把函數成員的實現代碼放在一個.cpp文件中。這是能夠的，也是很好的辦法。 不過，還有另外一種辦法。那就是直接把函數成員的實現代碼也寫進類定義裏面。在C++的類中，若是函數成員在類的定義體中被定義，那麼編譯器會視這個函數爲 內聯的。所以，把函數成員的定義寫進類定義體，一塊兒放進頭文件中，是合法的。注意一下，若是把函數成員的定義寫在類定義的頭文件中，而沒有寫進類定義中， 這是不合法的，由於這個函數成員此時就不是內聯的了。一旦頭文件被兩個或兩個以上的.cpp文件包含，這個函數成員就被重定義了。

5、頭文件中的保護措施
考 慮一下，若是頭文件中只包含聲明語句的話，它被同一個.cpp文件包含再屢次都沒問題——由於聲明語句的出現是不受限制的。然而，上面討論到的頭文件中的 三個例外也是頭文件很經常使用的一個用處。那麼，一旦一個頭文件中出現了上面三個例外中的任何一個，它再被一個.cpp包含屢次的話，問題就大了。由於這三個 例外中的語法元素雖然「能夠定義在多個源文件中」，可是「在一個源文件中只能出現一次」。設想一下，若是a.h中含有類A的定義，b.h中含有類B的定 義，因爲類B的定義依賴了類A，因此b.h中也#include了a.h。如今有一個源文件，它同時用到了類A和類B，因而程序員在這個源文件中既把 a.h包含進來了，也把b.h包含進來了。這時，問題就來了：類A的定義在這個源文件中出現了兩次！因而整個程序就不能經過編譯了。你也許會認爲這是程序 員的失誤——他應該知道b.h包含了a.h——但事實上他不該該知道。
使用"#define"配合條件編譯能夠很好地解決這個問題。在一 個頭文件中，經過#define定義一個名字，而且經過條件編譯#ifndef...#endif使得編譯器能夠根據這個名字是否被定義，再決定要不要繼 續編譯該頭文中後續的內容。這個方法雖然簡單，可是寫頭文件時必定記得寫進去。

[轉]C++編譯器與連接器工做原理

這裏並沒不是討論大學課程中所學的《編譯原理》，只是寫一些我本身對C++編譯器及連接器的工做原理的理解和見解吧，以個人水平，還達不到講解編譯原理（這個很複雜，大學時幾乎沒學明白）。

要明白的幾個概念：

    一、編譯：編譯器對源文件進行編譯，就是把源文件中的文本形式存在的源代碼翻譯成機器語言形式的目標文件的過程，在這個過程當中，編譯器會進行一系列的語法檢查。若是編譯經過，就會把對應的CPP轉換成OBJ文件。

    二、編譯單元：根據C++標準，每個CPP文件就是一個編譯單元。每一個編譯單元之間是相互獨立而且互相不可知。

    三、目標文件：由編譯所生成的文件，以機器碼的形式包含了編譯單元裏全部的代碼和數據，還有一些期他信息，如未解決符號表，導出符號表和地址重定向表等。目標文件是以二進制的形式存在的。

    根據C++標準，一個編譯單元（Translation Unit）是指一個.cpp文件以及這所include的全部.h文件，.h文件裏面的代碼將會被擴展到包含它的.cpp文件裏，而後編譯器編譯該.cpp文件爲一個.obj文件，後者擁有PE（Portable Executable，即Windows可執行文件）文件格式，而且自己包含的就是二進制代碼，可是不必定能執行，由於並不能保證其中必定有main函數。當編譯器將一個工程裏的全部.cpp文件以分離的方式編譯完畢後，再由連接器進行連接成爲一個.exe或.dll文件。

下面讓咱們來分析一下編譯器的工做過程：

咱們跳過語法分析，直接來到目標文件的生成，假設咱們有一個A.cpp文件，以下定義：

    int n = 1;

    void FunA()

    {

        ++n;

    }

    它編譯出來的目標文件A.obj就會有一個區域（或者說是段），包含以上的數據和函數，其中就有n、FunA，以文件偏移量形式給出可能就是下面這種狀況：

    偏移量    內容    長度

    0x0000    n       4

    0x0004    FunA    ??

    注意：這只是說明，與實際目標文件的佈局可能不同，??表示長度未知，目標文件的各個數據可能不是連續的，也不必定是從0x0000開始。

    FunA函數的內容可能以下：

    0x0004 inc DWORD PTR[0x0000]

    0x00?? ret

    這時++n已經被翻譯成inc DWORD PTR[0x0000]，也就是說把本單元0x0000位置的一個DWORD（4字節）加1。

    有另一個B.cpp文件，定義以下：

    extern int n;

    void FunB()

    {

        ++n;

    }

    它對應的B.obj的二進制應該是：

    偏移量    內容    長度

    0x0000    FunB    ??

    這裏爲何沒有n的空間呢，由於n被聲明爲extern，這個extern關鍵字就是告訴編譯器n已經在別的編譯單元裏定義了，在這個單元裏就不要定義了。因爲編譯單元之間是互不相關的，因此編譯器就不知道n究竟在哪裏，因此在函數FunB就沒有辦法生成n的地址，那麼函數FunB中就是這樣的：

    0x0000 inc DWORD PTR[????]

    0x00?? ret

    那怎麼辦呢？這個工做就只能由連接器來完成了。

    爲了能讓連接器知道哪些地方的地址沒有填好（也就是還????），那麼目標文件中就要有一個表來告訴連接器，這個表就是「未解決符號表」，也就是unresolved symbol table。一樣，提供n的目標文件也要提供一個「導出符號表」也就是exprot symbol table，來告訴連接器本身能夠提供哪些地址。

    好，到這裏咱們就已經知道，一個目標文件不只要提供數據和二進制代碼外，還至少要提供兩個表：未解決符號表和導出符號表，來告訴連接器本身須要什麼和本身能提供些什麼。那麼這兩個表是怎麼創建對應關係的呢？這裏就有一個新的概念：符號。在C/C++中，每個變量及函數都會有本身的符號，如變量n的符號就是n，函數的符號會更加複雜，假設FunA的符號就是_FunA（根據編譯器不一樣而不一樣）。

    因此，

    A.obj的導出符號表爲

    符號    地址

    n       0x0000

    _FunA   0x0004

    未解決符號爲空（由於他沒有引用別的編譯單元裏的東西）。

    B.obj的導出符號表爲

    符號    地址

    _FunB   0x0000

    未解決符號表爲

    符號    地址

    n       0x0001

    這個表告訴連接器，在本編譯單元0x0001位置有一個地址，該地址不明，但符號是n。

    在連接的時候，連接在B.obj中發現了未解決符號，就會在全部的編譯單元中的導出符號表去查找與這個未解決符號相匹配的符號名，若是找到，就把這個符號的地址填到B.obj的未解決符號的地址處。若是沒有找到，就會報連接錯誤。在此例中，在A.obj中會找到符號n，就會把n的地址填到B.obj的0x0001處。

    可是，這裏還會有一個問題，若是是這樣的話，B.obj的函數FunB的內容就會變成inc DWORD PTR[0x000]（由於n在A.obj中的地址是0x0000）,因爲每一個編譯單元的地址都是從0x0000開始，那麼最終多個目標文件連接時就會致使地址重複。因此連接器在連接時就會對每一個目標文件的地址進行調整。在這個例子中，假如B.obj的0x0000被定位到可執行文件的0x00001000上，而A.obj的0x0000被定位到可執行文件的0x00002000上，那麼實現上對連接器來講，A.obj的導出符號地地址都會加上0x00002000，B.obj全部的符號地址也會加上0x00001000。這樣就能夠保證地址不會重複。

    既然n的地址會加上0x00002000，那麼FunA中的inc DWORD PTR[0x0000]就是錯誤的，因此目標文件還要提供一個表，叫地址重定向表，address redirect table。

    總結一下：

    目標文件至少要提供三個表：未解決符號表，導出符號表和地址重定向表。

    未解決符號表：列出了本單元裏有引用可是不在本單元定義的符號及其出現的地址。

    導出符號表：提供了本編譯單元具備定義，而且能夠提供給其餘編譯單元使用的符號及其在本單元中的地址。

    地址重定向表：提供了本編譯單元全部對自身地址的引用記錄。

    連接器的工做順序：

    當連接器進行連接的時候，首先決定各個目標文件在最終可執行文件裏的位置。而後訪問全部目標文件的地址重定義表，對其中記錄的地址進行重定向（加上一個偏移量，即該編譯單元在可執行文件上的起始地址）。而後遍歷全部目標文件的未解決符號表，而且在全部的導出符號表裏查找匹配的符號，並在未解決符號表中所記錄的位置上填寫實現地址。最後把全部的目標文件的內容寫在各自的位置上，再做一些另的工做，就生成一個可執行文件。

    說明：實現連接的時候會更加複雜，通常實現的目標文件都會把數據，代碼分紅好向個區，重定向按區進行，但原理都是同樣的。

    明白了編譯器與連接器的工做原理後，對於一些連接錯誤就容易解決了。

    下面再看一看C/C++中提供的一些特性：

    extern：這就是告訴編譯器，這個變量或函數在別的編譯單元裏定義了，也就是要把這個符號放到未解決符號表裏面去（外部連接）。

    static：若是該關鍵字位於全局函數或者變量的聲明前面，代表該編譯單元不導出這個函數或變量，因些這個符號不能在別的編譯單元中使用（內部連接）。若是是static局部變量，則該變量的存儲方式和全局變量同樣，可是仍然不導出符號。 

    默認連接屬性：對於函數和變量，默認連接是外部連接，對於const變量，默認內部連接。

外部連接的利弊：外部連接的符號在整個程序範圍內都是可使用的，這就要求其餘編譯單元不能導出相同的符號（否則就會報duplicated external symbols）。

內部連接的利弊：內部連接的符號不能在別的編譯單元中使用。但不一樣的編譯單元能夠擁有一樣的名稱的符號。

    爲何頭文件裏通常只能夠有聲明不能有定義：頭文件能夠被多個編譯單元包含，若是頭文件裏面有定義的話，那麼每一個包含這頭文件的編譯單元都會對同一個符號進行定義，若是該符號爲外部連接，則會致使duplicated external symbols連接錯誤。

    爲何公共使用的內聯函數要定義於頭文件裏：由於編譯時編譯單元之間互不知道，若是內聯被定義於.cpp文件中，編譯其餘使用該函數的編譯單元的時候沒有辦法找到函數的定義，因些沒法對函數進行展開。因此若是內聯函數定義於.cpp裏，那麼就只有這個.cpp文件能使用它。