1. C++ 編譯模式

通常，在一個 C++ 程序中，只包含兩類文件：

• .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() 函數之前，先聲明一下這個函數 voida();就可以了。這是因為編譯器在編譯 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，前面有討論過，這里不再討論定義跟聲明的區別了。）

但是，這個規則是有三個例外的:

4.1 頭文件中可以寫 const 對象的定義

因為全局的 const 對象默認是沒有 extern 的聲明的，所以它只在當前文件中有效。把這樣的對象寫進頭文件中，即使它被包含到其他多個 .cpp 文件中，這個對象也都只在包含它的那個文件中有效，對其他文件來說是不可見的，所以便不會導致多重定義。同時，因為這些 .cpp 文件中的該對象都是從一個頭文件中包含進去的，這樣也就保證了這些 .cpp 文件中的這個 const 對象的值是相同的，可謂一舉兩得。同理，static 對象的定義也可以放進頭文件。

4.2 頭文件中可以寫內聯函數（inline）的定義

因為 inline 函數是需要編譯器在遇到它的地方根據它的定義把它內聯展開的，而并非是普通函數那樣可以先聲明再鏈接的（內聯函數不會鏈接），所以編譯器就需要在編譯時看到內聯函數的完整定義才行。

如果內聯函數像普通函數一樣只能定義一次的話，這事兒就難辦了。因為在一個文件中還好，我可以把內聯函數的定義寫在最開始，這樣可以保證后面使用的時候都可以見到定義；但是，如果我在其他的文件中還使用到了這個函數那怎么辦呢？

這幾乎沒什么太好的解決辦法，因此 C++ 規定，內聯函數可以在程序中定義多次，只要內聯函數在一個 .cpp 文件中只出現一次，并且在所有的 .cpp 文件中，這個內聯函數的定義是一樣的，就能通過編譯。那么顯然，把內聯函數的定義放進一個頭文件中是非常明智的做法。

4.3 頭文件中可以寫類（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 使得編譯器可以根據這個名字是否被定義，再決定要不要繼續編譯該頭文中后續的內容。這個方法雖然簡單，但是寫頭文件時一定記得寫進去。

6. C++ 頭文件和源文件的區別

6.1 源文件如何根據 #include 來關聯頭文件

1、系統自帶的頭文件用尖括號 <...> 括起來，這樣編譯器會在系統文件目錄下查找。
2、用戶自定義的文件用雙引號 "..." 括起來，編譯器首先會在用戶目錄下查找，然后在到 C++ 安裝目錄（比如 VC 中可以指定和修改庫文件查找路徑，Unix 和 Linux 中可以通過環境變量來設定）中查找，最后在系統文件中查找。

6.2 頭文件如何來關聯源文件

這個問題實際上是說，已知頭文件 a.h 聲明了一系列函數，b.cpp 中實現了這些函數，那么如果我想在 c.cpp 中使用 a.h 中聲明的這些在 b.cpp 中實現的函數，通常都是在 c.cpp 中使用 #include "a.h"，那么 c.cpp 是怎樣找到 b.cpp 中的實現呢？

其實 .cpp 和 .h 文件名稱沒有任何直接關系，很多編譯器都可以接受其他擴展名。

在 Turbo C 中，采用命令行方式進行編譯，命令行參數為文件的名稱，默認的是 .cpp 和 .h，但是也可以自定義為 .xxx 等等。

譚浩強老師的《C 程序設計》一書中提到，編譯器預處理時，要對 #include 命令進行"文件包含處理"：將 file2.c 的全部內容復制到 #include "file2.c" 處。這也正說明了，為什么很多編譯器并不 care 到底這個文件的后綴名是什么----因為 #include 預處理就是完成了一個"復制并插入代碼"的工作。

編譯的時候，并不會去找 b.cpp 文件中的函數實現，只有在 link 的時候才進行這個工作。我們在 b.cpp 或 c.cpp 中用 #include "a.h" 實際上是引入相關聲明，使得編譯可以通過，程序并不關心實現是在哪里，是怎么實現的。源文件編譯后成生了目標文件（.o 或 .obj 文件），目標文件中，這些函數和變量就視作一個個符號。

在 link 的時候，需要在 makefile 里面說明需要連接哪個 .o 或 .obj 文件（在這里是 b.cpp 生成的 .o 或 .obj 文件），此時，連接器會去這個 .o 或 .obj 文件中找在 b.cpp 中實現的函數，再把他們 build 到 makefile 中指定的那個可以執行文件中。

在 Unix下，甚至可以不在源文件中包括頭文件，只需要在 makefile 中指名即可（不過這樣大大降低了程序可讀性，是個不好的習慣哦^_）。在 VC 中，一幫情況下不需要自己寫 makefile，只需要將需要的文件都包括在 project 中，VC 會自動幫你把 makefile 寫好。

通常，C++ 編譯器會在每個 .o或 .obj 文件中都去找一下所需要的符號，而不是只在某個文件中找或者說找到一個就不找了。因此，如果在幾個不同文件中實現了同一個函數，或者定義了同一個全局變量，鏈接的時候就會提示 “redefined”。

7. 總結

.h 文件中能包含：

• 類成員數據的聲明，但不能賦值
• 類靜態數據成員的定義和賦值，但不建議，只是個聲明就好。
• 類的成員函數的聲明
• 非類成員函數的聲明
• 常數的定義：如：constint a=5;
• 靜態函數的定義
• 類的內聯函數的定義

不能包含：

• 所有非靜態變量（不是類的數據成員）的聲明
• 默認命名空間聲明不要放在頭文件，using namespace std; 等應放在 .cpp 中，在 .h 文件中使用 std::string

原文地址：https://www.runoob.com/w3cnote/cpp-header.html

總結

以上是生活随笔為你收集整理的C++ 笔记（25）— 理解 C++ 中的头文件和源文件的作用的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。