C++中頭文件與源文件的做用詳解

時間 2019-12-11

標籤 c++ 中頭文件詳解欄目 C&C++ 简体版

原文原文鏈接

1、C++ 編譯模式html

一般，在一個 C++ 程序中，只包含兩類文件―― .cpp 文件和 .h 文件。其中，.cpp 文件被稱做 C++ 源文件，裏面放的都是 C++ 的源代碼；而 .h 文件則被稱做 C++ 頭文件，裏面放的也是 C++ 的源代碼。mysql

C++ 語言支持"分別編譯"（separatecompilation）。也就是說，一個程序全部的內容，能夠分紅不一樣的部分分別放在不一樣的 .cpp 文件裏。.cpp 文件裏的東西都是相對獨立的，在編譯（compile）時不須要與其餘文件互通，只須要在編譯成目標文件後再與其餘的目標文件作一次連接（link）就好了。好比，在文件 a.cpp 中定義了一個全局函數 "void a(){}"，而在文件 b.cpp 中須要調用這個函數。即便這樣，文件 a.cpp 和文件 b.cpp 並不須要相互知道對方的存在，而是能夠分別地對它們進行編譯，編譯成目標文件以後再連接，整個程序就能夠運行了。ios

這是怎麼實現的呢？從寫程序的角度來說，很簡單。在文件 b.cpp 中，在調用 "void a()" 函數以前，先聲明一下這個函數 "voida();"，就能夠了。這是由於編譯器在編譯 b.cpp 的時候會生成一個符號表（symbol table），像 "void a()" 這樣的看不到定義的符號，就會被存放在這個表中。再進行連接的時候，編譯器就會在別的目標文件中去尋找這個符號的定義。一旦找到了，程序也就能夠順利地生成了。程序員

注意這裏提到了兩個概念，一個是"定義"，一個是"聲明"。簡單地說，"定義"就是把一個符號完完整整地描述出來：它是變量仍是函數，返回什麼類型，須要什麼參數等等。而"聲明"則只是聲明這個符號的存在，即告訴編譯器，這個符號是在其餘文件中定義的，我這裏先用着，你連接的時候再到別的地方去找找看它究竟是什麼吧。定義的時候要按 C++ 語法完整地定義一個符號（變量或者函數），而聲明的時候就只須要寫出這個符號的原型了。須要注意的是，一個符號，在整個程序中能夠被聲明屢次，但卻要且僅要被定義一次。試想，若是一個符號出現了兩種不一樣的定義，編譯器該聽誰的？sql

這種機制給 C++ 程序員們帶來了不少好處，同時也引出了一種編寫程序的方法。考慮一下，若是有一個很經常使用的函數 "void f() {}"，在整個程序中的許多 .cpp 文件中都會被調用，那麼，咱們就只須要在一個文件中定義這個函數，而在其餘的文件中聲明這個函數就能夠了。一個函數還好對付，聲明起來也就一句話。可是，若是函數多了，好比是一大堆的數學函數，有好幾百個，那怎麼辦？能保證每一個程序員均可以完徹底全地把全部函數的形式都準確地記下來並寫出來嗎？數據庫

2、什麼是頭文件函數

很顯然，答案是不可能。可是有一個很簡單地辦法，能夠幫助程序員們省去記住那麼多函數原型的麻煩：咱們能夠把那幾百個函數的聲明語句全都先寫好，放在一個文件裏，等到程序員須要它們的時候，就把這些東西所有 copy 進他的源代碼中。佈局

這個方法當然可行，但仍是太麻煩，並且還顯得很笨拙。因而，頭文件即可以發揮它的做用了。所謂的頭文件，其實它的內容跟 .cpp 文件中的內容是同樣的，都是 C++ 的源代碼。但頭文件不用被編譯。咱們把全部的函數聲明所有放進一個頭文件中，當某一個 .cpp 源文件須要它們時，它們就能夠經過一個宏命令 "#include" 包含進這個 .cpp 文件中，從而把它們的內容合併到 .cpp 文件中去。當 .cpp 文件被編譯時，這些被包含進去的 .h 文件的做用便發揮了。學習

舉一個例子吧，假設全部的數學函數只有兩個：f1 和 f2，那麼咱們把它們的定義放在 math.cpp 裏：ui

/* 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(); 的句子。這些纔是聲明。若是寫上 inta;或者 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++ 頭文件和源文件的區別

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

一、系統自帶的頭文件用尖括號括起來，這樣編譯器會在系統文件目錄下查找。

二、用戶自定義的文件用雙引號括起來，編譯器首先會在用戶目錄下查找，而後在到 C++ 安裝目錄（好比 VC 中能夠指定和修改庫文件查找路徑，Unix 和 Linux 中能夠經過環境變量來設定）中查找，最後在系統文件中查找。
#include "xxx.h"（我一直覺得 "" 和 <> 沒什麼區別，可是 tinyxml.h 是非系統下的都文件，因此要用 ""）

2、頭文件如何來關聯源文件

這個問題其實是說，已知頭文件 "a.h" 聲明瞭一系列函數，"b.cpp" 中實現了這些函數，那麼若是我想在 "c.cpp" 中使用 "a.h" 中聲明的這些在 "b.cpp"中實現的函數，一般都是在 "c.cpp" 中使用 #include "a.h"，那麼 c.cpp 是怎樣找到 b.cpp 中的實現呢？

其實 .cpp 和 .h 文件名稱沒有任何直接關係，不少編譯器均可以接受其餘擴展名。好比偶如今看到偶們公司的源代碼，.cpp 文件由 .cc 文件替代了。

在 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"。

綜上所訴

.h文件中能包含：