C_文件包含.h文件和包含.c文件總結

很多人對C語言中的 “文件包含”都不陌生了，文件包含處理在程序開發中會給我們的模塊化程序設計帶來很大的好處，通過文件包含的方法把程序中的各個功能模塊聯系起來是模塊化程序設計中的一種非常有利的手段。

       文件包含處理是指在一個源文件中，通過文件包含命令將另一個源文件的內容全部包含在此文件中。在源文件編譯時，連同被包含進來的文件一同編譯，生成目標目標文件。

    很多人再初學時都會對這個很暈，怎么寫文件件? 怎么包含才能避免重定義? 等等問題。。。

 

    其實這個只要了解了文件包含的基本處理方法就可以對文件包含有一個很好的理解與應用了，下來我們一起來看一下：

 

  文件包含的處理方法：

   首先大家需要清楚：

   (1) 處理時間：文件包含也是以"#"開頭來寫的(#include ), 那么它就是寫給預處理器來看了, 也就是說文件包含是會在編譯預處理階段進行處理的。

   (2) 處理方法：在預處理階段，系統自動對#include命令進行處理，具體做法是:降包含文件的內容復制到包含語句(#include )處，得到新的文件，然后再對這個新的文件進行編譯。

 

  抓住這兩點，那么這個東東就沒有什么難的了。。。

  一般情況下文件包含分為兩種：包含.h文件 和 包含.c文件

1. 當然對於這兩情況也都是按照上面說的方法來處理的。呵呵，這個肯定是沒得說的.

2.  包含.c文件 和編譯多文件程序 是不同的。
    多文件程序: 是在源文件編譯時把多個文件進行編譯、連接在一起生成一個可執行文件。
    包含.c文件: 按照我們上邊的說法則是把多個文件合並為一個文件進行編譯。

接下來通過例子看一下：
(1)包含.c文件:

   1: //file1:  main.c 

   2: #include 

   3: #include "fun.c"

   4: int main()

   5: {

   6:     int a=5,b=19;

   7:     c = a;    

   8:     sun(a,b);

   9:     printf("c=%d\n",c);

  10:     return 0;

  11: }

  12: //end of file1

   1: //file2: fun.c

   2: int c=0;

   3: void sun(int a, int b)

   4: {

   5:     printf("a+b=%d\n",a+b);

   6:     c=0;

   7:     printf("c=%d\n",c);

   8: }

   9: //end of file2   

  10:   

這個例子是采用 包含.c文件 的方法實現的。

 

在編譯時，直接去編譯main.c文件，預處理器會先把fun.c文件中的內容復制到main.c中來，然后再對新的main.c進行編譯。
編譯命令：
    gcc main.c -o main

可以看到，這里並沒有對fun.c進行編譯，但還是生成了最終的main可執行程序。

也可以通過命令來觀察一下預處理的結果：

編譯命令：
   gcc -E main.c -o main.cpp
在main.cpp文件末尾可以看來下面一段代碼：

   1: //main.cpp文件中

   2: 931 # 2 "main.c" 2

   3: 932 # 1 "fun.c" 1

   4: 933 //注意這里是fun.c里邊的內容

   5: 934 int c=0;

   6: 935 void sun(int a, int b)

   7: 936 {

   8: 937  printf("a+b=%d\n",a+b);

   9: 938  c=0;

  10: 939  printf("c=%d\n",c);

  11: 940 } 

  12:     //這里是main函數

  13: 941 # 3 "main.c" 2

  14: 942 int main()

  15: 943 { 

  16: 944  int a=5,b=19;

  17: 945  c = a;

  18: 946  printf("c=%d\n",c);

  19: 947  sun(a,b);

  20: 948  printf("c=%d\n",c);

  21: 949  return 0;

  22: 950 }

可見，其實就是將fun.c文件中的內容添加到了main函數之前，然后對新的文件進行編譯，生成最終的可執行程序。

 

(2)編譯多文件程序：
同樣是上邊的例子，把main.c中“ #include "fun.c" ”注釋掉，加上一句：“extern int c;”因為 c 變量在另外一個文件(fun.c)中定義。

   1: //file1:  main.c 

   2: #include 

   3: //#include "fun.c"  //注釋掉

   4: extern int c;        //添加這一句

   5: int main()

   6: {

   7:     int a=5,b=19;

   8:     c = a;    

   9:     sun(a,b);

  10:     printf("c=%d\n",c);

  11:     return 0;

  12: }

  13: //end of file1

  14:  

  15:  

  16: //file2: fun.c

  17: int c=0;

  18: void sun(int a, int b)

  19: {

  20:     printf("a+b=%d\n",a+b);

  21:     c=0;

  22:     printf("c=%d\n",c);

  23: }

  24: //end of file2  

 

這次如果還是按照上面的方法只編譯main.c的話就會出錯，因為變量c和函數sun並沒有在main.c中定義，所以編譯時需要將fun.c一起編譯：
編譯命令：   

    gcc -c main.c -o main.o                 #編譯main.c
    gcc -c fun.c -o fun.o                       #編譯fun.c
    gcc main.o fun.o -o main              #用main.o fun.o生成main

       到這里大家應該已經理解包含.c文件和多文件程序的本質區別了～～～

好了，大家不防想想這兩種方法的優缺點，這里就只寫不足之處了：
1. 包含.c文件的方法: 容易產生"重定義",大家想想如果一個工程中有多個文件都同時包含了某一個件，那么這個被包含文件的內容就會被復制到多個文件中去，也就相當於每個包含該文件的文件中都定義被包含文件中的變量和函數，這樣在鏈接時就會產生"重定義"錯誤。

2. 多文件分開編譯的方法: 這個比較好，不容易出現"重定義"之類的問題，這也是我們最常用的一種方法，但是並不是像上面這個例子中這樣直接去用，而是使用"頭文件"將各個.c文件聯系起來。
     上邊這個例子大家會發現，在main.c中需要加上“extern int c;”這樣一句聲明，如果包含的文件較多？如果全局變量較多？...這個我們可以省掉嗎？回答是肯定的！方法就是給它寫上一個頭文件。

 

       接下來看一下使用頭文件的來實現這個例子的方法：

   1: //file1:  main.c 

   2: #include 

   3: #include "fun.h"       //fun.c修改為fun.h

   4: //extern int c;        //這行也不要了

   5: int main()

   6: {

   7:     int a=5,b=19;

   8:     c = a;    

   9:     sun(a,b);

  10:     printf("c=%d\n",c);

  11:     return 0;

  12: }

  13: //end of file1

 

   1:  

   2: //file2: fun.c

   3: #include "fun.h"

   4: int c=0;                      //變量c的定義

   5: void sun(int a, int b)        //函數sun()的定義

   6: {

   7:     printf("a+b=%d\n",a+b);

   8:     c=0;

   9:     printf("c=%d\n",c);

  10: }

  11: //end of file2  

 

   1: //file3: fun.h 

   2: extern int c;             //把c聲明為外部可用的

   3: void sun(int a, int b);   //sun()函數的聲明

   4: //end of file3

這樣再看一下，在要用到fun.c中定義的函數或變量的文件中只要包含fun.h文件就可以了，是不是這樣？？？呵呵，當然是了。。。

預處理時會把fun.h中的內容復制到包含它的文件中去，而復制的這些內容只是聲名，不是定義，所以它被復制再多份也不會出現"重定義"的錯誤。。。

呵呵，對，就是這樣，這就是頭文件給我們再來的好處。

 

前面說了頭文件的方法也是模塊化程序設計中的一種非常有利的手段。

        把同一類功能寫到一個.c文件中，這樣可以把他們划為一個模塊，另外再對應的寫上一個.h文件做它的聲明。這樣以后再使用這個模塊時只需要把這兩個文件添加進工程，同時在要使用模塊內函數或變量的文件中包含.h文件就可以了。

         

        舉個很實際的例子，在單片機、ARM或其他嵌入式開發中，每一個平台可能本身都有多種不同的硬件模塊，使用時需要去寫相應的驅動程序，這樣就可以把各個硬件模塊的驅動程序作為一個模塊(比如lcd驅動對對應lcd.c和lcd.h，IIC驅動對應I2C.c和I2C.h等)，當具體使用到某個模塊時，只需要在將對應的.c和.h文件添加進工程，並在文件中包含對就的.h文件即可。

 

所以關於頭文件的寫法個人 總結以下幾點:
(1) 對應的.c文件中寫變量、函數的定義
(2) 對應的.h文件中寫變量、函數的聲明
(3) 如果有數據類型的定義 和 宏定義 ，請寫的頭文件(.h)中
(4) 頭文件中一定加上#ifndef...#define....#endif之類的防止重包含的語句
(5) 模塊的.c文件中別忘包含自己的.h文件