第一篇： ? ??
首先是預(yù)編譯，這一步可以粗略的認(rèn)為只做了一件事情，那就是“宏展開”，也就是對那些#***的命令的一種展開。

????? 例如define MAX 1000就是建立起MAX和1000之間的對等關(guān)系，好在編譯階段進(jìn)行替換。

????? 例如ifdef/ifndef就是從一個(gè)文件中有選擇性的挑出一些符合條件的代碼來交給下一步的編譯階段來處理。這里面最復(fù)雜的莫過于include了，其實(shí)也很簡單，就是相當(dāng)于把那個(gè)對應(yīng)的文件里面的內(nèi)容一下子替換到這條include***語句的地方來。

????? 其次是編譯，這一步很重要，編譯是以一個(gè)個(gè)獨(dú)立的文件作為單元的，一個(gè)文件就會(huì)編譯出一個(gè)目標(biāo)文件。（這里插入一點(diǎn)關(guān)于編譯的文件的說明，編譯器通過后綴名來辨識(shí)是否編譯該文件，因此“.h”的頭文件一概不理會(huì)，而“.cpp”的源文件一律都要被編譯，我實(shí)驗(yàn)過把.h文件的后綴名改為.cpp，然后在include的地方相應(yīng)的改為***.cpp，這樣一來，編譯器就會(huì)編譯許多不必要的頭文件，只不過頭文件里我們通常只放置聲明而不是定義，因此最后鏈接生成的可執(zhí)行文件的大小是不會(huì)改變的）

????? 清楚編譯是以一個(gè)個(gè)單獨(dú)的文件為單元的，這一點(diǎn)很重要，因此編譯只負(fù)責(zé)本單元的那些事，而對外部的事情一概不理會(huì)，在這一步里，我們可以調(diào)用一個(gè)函數(shù)而不必給出這個(gè)函數(shù)的定義，但是要在調(diào)用前得到這個(gè)函數(shù)的聲明（其實(shí)這就是include的本質(zhì)，不就是為了給你提前提供個(gè)聲明而好讓你使用嗎？至于那個(gè)函數(shù)到底是如何實(shí)現(xiàn)的，需要在鏈接這一步里去找函數(shù)的入口地址。因此提供聲明的方式可以是用include把放在別的文件中的聲明拿過來，也可以是在調(diào)用之前自己寫一句void max(int,int);都行。），編譯階段剩下的事情就是分析語法的正確性之類的工作了。好啦，總結(jié)一下，可以粗略的認(rèn)為編譯階段分兩步：????

??????? 第一步，檢驗(yàn)函數(shù)或者變量是否存在它們的聲明；

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

最后一步是鏈接，它會(huì)把所有編譯好的單元全部鏈接為一個(gè)整體文件，其實(shí)這一步可以比作一個(gè)“連線”的過程，比如A文件用了B文件中的函數(shù)，那么鏈接的這一步會(huì)建立起這個(gè)關(guān)聯(lián)。鏈接時(shí)最重要的我認(rèn)為是檢查全局空間里面是不是有重復(fù)定義或者缺失定義。這也就解釋了為什么我們一般不在頭文件中出現(xiàn)定義，因?yàn)轭^文件有可能被釋放到多個(gè)源文件中，每個(gè)源文件都會(huì)單獨(dú)編譯，鏈接時(shí)就會(huì)發(fā)現(xiàn)全局空間中有多個(gè)定義了。

標(biāo)準(zhǔn)C和C++將編譯過程定義為9個(gè)階段(Phases of Translation)：

1.字符映射(Character Mapping)

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

2.行合并(Line Splicing)

??? 以反斜杠/結(jié)束的行和它接下來的行合并。

3.標(biāo)記化(Tokenization)

??? 每一條注釋被一個(gè)單獨(dú)的空字符所替換。C++雙字符運(yùn)算符被識(shí)別為標(biāo)記(為了開發(fā)可讀性更強(qiáng)的程序，C++為非ASCII碼開發(fā)者定義了一套雙字符運(yùn)算符集和新的保留字集)。源代碼被分析成預(yù)處理標(biāo)記。

4.預(yù)處理(Preprocessing)

??? 調(diào)用預(yù)處理指令并擴(kuò)展宏。使用#include指令包含的文件，重復(fù)步驟1到4。上述四個(gè)階段統(tǒng)稱為預(yù)處理階段。

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

??? 源字符集成員、轉(zhuǎn)義序列被轉(zhuǎn)換成等價(jià)的執(zhí)行字符集成員。例如：'/a'在ASCII環(huán)境下會(huì)被轉(zhuǎn)換成值為一個(gè)字節(jié)，值為7。

6.字符串連接(String Concatenation)

??? 相鄰的字符串被連接。例如："""hahaha""huohuohuo"將成為"hahahahuohuohuo"。

7.翻譯(Translation)

??? 進(jìn)行語法和語義分析編譯，并翻譯成目標(biāo)代碼。

8.處理模板

??? 處理模板實(shí)例。

9.連接(Linkage)

??? 解決外部引用的問題，準(zhǔn)備好程序映像以便執(zhí)行。
第二篇：

一、C++編譯模式
通常，在一個(gè)C++程序中，只包含兩類文件——.cpp文件和.h文件。其中，.cpp文件被稱作C++源文件，里面放的都是C++的源代碼；而.h文件則被稱作C++頭文件，里面放的也是C++的源代碼。
C+ +語言支持“分別編譯”（separate compilation）。也就是說，一個(gè)程序所有的內(nèi)容，可以分成不同的部分分別放在不同的.cpp文件里。.cpp文件里的東西都是相對獨(dú)立的，在編 譯（compile）時(shí)不需要與其他文件互通，只需要在編譯成目標(biāo)文件后再與其他的目標(biāo)文件做一次鏈接（link）就行了。比如，在文件a.cpp中定義 了一個(gè)全局函數(shù)“void a() {}”，而在文件b.cpp中需要調(diào)用這個(gè)函數(shù)。即使這樣，文件a.cpp和文件b.cpp并不需要相互知道對方的存在，而是可以分別地對它們進(jìn)行編譯， 編譯成目標(biāo)文件之后再鏈接，整個(gè)程序就可以運(yùn)行了。
這是怎么實(shí)現(xiàn)的呢？從寫程序的角度來講，很簡單。在文件b.cpp中，在調(diào)用 “void a()”函數(shù)之前，先聲明一下這個(gè)函數(shù)“void a();”，就可以了。這是因?yàn)榫幾g器在編譯b.cpp的時(shí)候會(huì)生成一個(gè)符號表（symbol table），像“void a()”這樣的看不到定義的符號，就會(huì)被存放在這個(gè)表中。再進(jìn)行鏈接的時(shí)候，編譯器就會(huì)在別的目標(biāo)文件中去尋找這個(gè)符號的定義。一旦找到了，程序也就可以 順利地生成了。
注意這里提到了兩個(gè)概念，一個(gè)是“定義”，一個(gè)是“聲明”。簡單地說，“定義”就是把一個(gè)符號完完整整地描述出來：它是變 量還是函數(shù)，返回什么類型，需要什么參數(shù)等等。而“聲明”則只是聲明這個(gè)符號的存在，即告訴編譯器，這個(gè)符號是在其他文件中定義的，我這里先用著，你鏈接 的時(shí)候再到別的地方去找找看它到底是什么吧。定義的時(shí)候要按C++語法完整地定義一個(gè)符號（變量或者函數(shù)），而聲明的時(shí)候就只需要寫出這個(gè)符號的原型了。 需要注意的是，一個(gè)符號，在整個(gè)程序中可以被聲明多次，但卻要且僅要被定義一次。試想，如果一個(gè)符號出現(xiàn)了兩種不同的定義，編譯器該聽誰的？
這 種機(jī)制給C++程序員們帶來了很多好處，同時(shí)也引出了一種編寫程序的方法。考慮一下，如果有一個(gè)很常用的函數(shù)“void f() {}”，在整個(gè)程序中的許多.cpp文件中都會(huì)被調(diào)用，那么，我們就只需要在一個(gè)文件中定義這個(gè)函數(shù)，而在其他的文件中聲明這個(gè)函數(shù)就可以了。一個(gè)函數(shù)還 好對付，聲明起來也就一句話。但是，如果函數(shù)多了，比如是一大堆的數(shù)學(xué)函數(shù)，有好幾百個(gè)，那怎么辦？能保證每個(gè)程序員都可以完完全全地把所有函數(shù)的形式都 準(zhǔn)確地記下來并寫出來嗎？

二、什么是頭文件
很顯然，答案是不可能。但是有一個(gè)很簡單地辦法，可以幫助程序員們省去記住那么多函數(shù)原型的麻煩：我們可以把那幾百個(gè)函數(shù)的聲明語句全都先寫好，放在一個(gè)文件里，等到程序員需要它們的時(shí)候，就把這些東西全部copy進(jìn)他的源代碼中。
這 個(gè)方法固然可行，但還是太麻煩，而且還顯得很笨拙。于是，頭文件便可以發(fā)揮它的作用了。所謂的頭文件，其實(shí)它的內(nèi)容跟.cpp文件中的內(nèi)容是一樣的，都是 C++的源代碼。但頭文件不用被編譯。我們把所有的函數(shù)聲明全部放進(jìn)一個(gè)頭文件中，當(dāng)某一個(gè).cpp源文件需要它們時(shí)，它們就可以通過一個(gè)宏命令 “#include”包含進(jìn)這個(gè).cpp文件中，從而把它們的內(nèi)容合并到.cpp文件中去。當(dāng).cpp文件被編譯時(shí)，這些被包含進(jìn)去的.h文件的作用便發(fā) 揮了。
舉一個(gè)例子吧，假設(shè)所有的數(shù)學(xué)函數(shù)只有兩個(gè)：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 */
并把“這些”函數(shù)的聲明放在一個(gè)頭文件math.h中：
/* math.h */

double f1();
double f2(double);
/* end of math.h */
在另一個(gè)文件main.cpp中，我要調(diào)用這兩個(gè)函數(shù)，那么就只需要把頭文件包含進(jìn)來：
/* main.cpp */
#include "math.h"
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of main.cpp */
這 樣，便是一個(gè)完整的程序了。需要注意的是，.h文件不用寫在編譯器的命令之后，但它必須要在編譯器找得到的地方（比如跟main.cpp在一個(gè)目錄下）。 main.cpp和math.cpp都可以分別通過編譯，生成main.o和math.o，然后再把這兩個(gè)目標(biāo)文件進(jìn)行鏈接，程序就可以運(yùn)行了。

三、#include
#include 是一個(gè)來自C語言的宏命令，它在編譯器進(jìn)行編譯之前，即在預(yù)編譯的時(shí)候就會(huì)起作用。#include的作用是把它后面所寫的那個(gè)文件的內(nèi)容，完完整整地、 一字不改地包含到當(dāng)前的文件中來。值得一提的是，它本身是沒有其它任何作用與副功能的，它的作用就是把每一個(gè)它出現(xiàn)的地方，替換成它后面所寫的那個(gè)文件的 內(nèi)容。簡單的文本替換，別無其他。因此，main.cpp文件中的第一句（#include "math.h"），在編譯之前就會(huì)被替換成math.h文件的內(nèi)容。即在編譯過程將要開始的時(shí)候，main.cpp的內(nèi)容已經(jīng)發(fā)生了改變：
/* ~main.cpp */
double f1();
double f2(double);
main()
{
int number1 = f1();
int number2 = f2(number1);
}
/* end of ~main.cpp */
不多不少，剛剛好。同理可知，如果我們除了main.cpp以外，還有其他的很多.cpp文件也用到了f1和f2函數(shù)的話，那么它們也通通只需要在使用這兩個(gè)函數(shù)前寫上一句#include "math.h"就行了。

四、頭文件中應(yīng)該寫什么
通 過上面的討論，我們可以了解到，頭文件的作用就是被其他的.cpp包含進(jìn)去的。它們本身并不參與編譯，但實(shí)際上，它們的內(nèi)容卻在多個(gè).cpp文件中得到了 編譯。通過“定義只能有一次”的規(guī)則，我們很容易可以得出，頭文件中應(yīng)該只放變量和函數(shù)的聲明，而不能放它們的定義。因?yàn)橐粋€(gè)頭文件的內(nèi)容實(shí)際上是會(huì)被引 入到多個(gè)不同的.cpp文件中的，并且它們都會(huì)被編譯。放聲明當(dāng)然沒事，如果放了定義，那么也就相當(dāng)于在多個(gè)文件中出現(xiàn)了對于一個(gè)符號（變量或函數(shù)）的定 義，縱然這些定義都是相同的，但對于編譯器來說，這樣做不合法。
所以，應(yīng)該記住的一點(diǎn)就是，.h頭文件中，只能存在變量或者函數(shù)的聲明， 而不要放定義。即，只能在頭文件中寫形如：extern int a;和void f();的句子。這些才是聲明。如果寫上int a;或者void f() {}這樣的句子，那么一旦這個(gè)頭文件被兩個(gè)或兩個(gè)以上的.cpp文件包含的話，編譯器會(huì)立馬報(bào)錯(cuò)。（關(guān)于extern，前面有討論過，這里不再討論定義跟 聲明的區(qū)別了。）
但是，這個(gè)規(guī)則是有三個(gè)例外的。
一，頭文件中可以寫const對象的定義。因?yàn)槿值腸onst對象默 認(rèn)是沒有extern的聲明的，所以它只在當(dāng)前文件中有效。把這樣的對象寫進(jìn)頭文件中，即使它被包含到其他多個(gè).cpp文件中，這個(gè)對象也都只在包含它的 那個(gè)文件中有效，對其他文件來說是不可見的，所以便不會(huì)導(dǎo)致多重定義。同時(shí)，因?yàn)檫@些.cpp文件中的該對象都是從一個(gè)頭文件中包含進(jìn)去的，這樣也就保證 了這些.cpp文件中的這個(gè)const對象的值是相同的，可謂一舉兩得。同理，static對象的定義也可以放進(jìn)頭文件。
二，頭文件中可 以寫內(nèi)聯(lián)函數(shù)（inline）的定義。因?yàn)閕nline函數(shù)是需要編譯器在遇到它的地方根據(jù)它的定義把它內(nèi)聯(lián)展開的，而并非是普通函數(shù)那樣可以先聲明再鏈 接的（內(nèi)聯(lián)函數(shù)不會(huì)鏈接），所以編譯器就需要在編譯時(shí)看到內(nèi)聯(lián)函數(shù)的完整定義才行。如果內(nèi)聯(lián)函數(shù)像普通函數(shù)一樣只能定義一次的話，這事兒就難辦了。因?yàn)樵?一個(gè)文件中還好，我可以把內(nèi)聯(lián)函數(shù)的定義寫在最開始，這樣可以保證后面使用的時(shí)候都可以見到定義；但是，如果我在其他的文件中還使用到了這個(gè)函數(shù)那怎么辦 呢？這幾乎沒什么太好的解決辦法，因此C++規(guī)定，內(nèi)聯(lián)函數(shù)可以在程序中定義多次，只要內(nèi)聯(lián)函數(shù)在一個(gè).cpp文件中只出現(xiàn)一次，并且在所有的.cpp文 件中，這個(gè)內(nèi)聯(lián)函數(shù)的定義是一樣的，就能通過編譯。那么顯然，把內(nèi)聯(lián)函數(shù)的定義放進(jìn)一個(gè)頭文件中是非常明智的做法。

三，頭文件中可以寫類 （class）的定義。因?yàn)樵诔绦蛑袆?chuàng)建一個(gè)類的對象時(shí)，編譯器只有在這個(gè)類的定義完全可見的情況下，才能知道這個(gè)類的對象應(yīng)該如何布局，所以，關(guān)于類的 定義的要求，跟內(nèi)聯(lián)函數(shù)是基本一樣的。所以把類的定義放進(jìn)頭文件，在使用到這個(gè)類的.cpp文件中去包含這個(gè)頭文件，是一個(gè)很好的做法。在這里，值得一提 的是，類的定義中包含著數(shù)據(jù)成員和函數(shù)成員。數(shù)據(jù)成員是要等到具體的對象被創(chuàng)建時(shí)才會(huì)被定義（分配空間），但函數(shù)成員卻是需要在一開始就被定義的，這也就 是我們通常所說的類的實(shí)現(xiàn)。一般，我們的做法是，把類的定義放在頭文件中，而把函數(shù)成員的實(shí)現(xiàn)代碼放在一個(gè).cpp文件中。這是可以的，也是很好的辦法。 不過，還有另一種辦法。那就是直接把函數(shù)成員的實(shí)現(xiàn)代碼也寫進(jìn)類定義里面。在C++的類中，如果函數(shù)成員在類的定義體中被定義，那么編譯器會(huì)視這個(gè)函數(shù)為 內(nèi)聯(lián)的。因此，把函數(shù)成員的定義寫進(jìn)類定義體，一起放進(jìn)頭文件中，是合法的。注意一下，如果把函數(shù)成員的定義寫在類定義的頭文件中，而沒有寫進(jìn)類定義中， 這是不合法的，因?yàn)檫@個(gè)函數(shù)成員此時(shí)就不是內(nèi)聯(lián)的了。一旦頭文件被兩個(gè)或兩個(gè)以上的.cpp文件包含，這個(gè)函數(shù)成員就被重定義了。

五、頭文件中的保護(hù)措施
考 慮一下，如果頭文件中只包含聲明語句的話，它被同一個(gè).cpp文件包含再多次都沒問題——因?yàn)槁暶髡Z句的出現(xiàn)是不受限制的。然而，上面討論到的頭文件中的 三個(gè)例外也是頭文件很常用的一個(gè)用處。那么，一旦一個(gè)頭文件中出現(xiàn)了上面三個(gè)例外中的任何一個(gè)，它再被一個(gè).cpp包含多次的話，問題就大了。因?yàn)檫@三個(gè) 例外中的語法元素雖然“可以定義在多個(gè)源文件中”，但是“在一個(gè)源文件中只能出現(xiàn)一次”。設(shè)想一下，如果a.h中含有類A的定義，b.h中含有類B的定 義，由于類B的定義依賴了類A，所以b.h中也#include了a.h。現(xiàn)在有一個(gè)源文件，它同時(shí)用到了類A和類B，于是程序員在這個(gè)源文件中既把 a.h包含進(jìn)來了，也把b.h包含進(jìn)來了。這時(shí)，問題就來了：類A的定義在這個(gè)源文件中出現(xiàn)了兩次！于是整個(gè)程序就不能通過編譯了。你也許會(huì)認(rèn)為這是程序 員的失誤——他應(yīng)該知道b.h包含了a.h——但事實(shí)上他不應(yīng)該知道。
使用"#define"配合條件編譯可以很好地解決這個(gè)問題。在一 個(gè)頭文件中，通過#define定義一個(gè)名字，并且通過條件編譯#ifndef...#endif使得編譯器可以根據(jù)這個(gè)名字是否被定義，再?zèng)Q定要不要繼 續(xù)編譯該頭文中后續(xù)的內(nèi)容。這個(gè)方法雖然簡單，但是寫頭文件時(shí)一定記得寫進(jìn)去。