c語言include的用法是什么

　　小編整理了c語言 include的用法。希望對你有幫助哦!

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

　　文件包含的處理方法：

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

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

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

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

　　2. 包含.c文件和編譯多文件程序是不同的。

　　多文件程序: 是在源文件編譯時把多個文件進行編譯、連接在一起生成一個可執(zhí)行文件。

　　包含.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文件的方法實現(xiàn)的。

　　在編譯時，直接去編譯main.c文件，預處理器會先把fun.c文件中的內(nèi)容復制到main.c中來，然后再對新的main.c進行編譯。

　　編譯命令：

　　gcc main.c -o main

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

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

　　編譯命令：

　　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里邊的內(nèi)容

　　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函數(shù)

　　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文件中的內(nèi)容添加到了main函數(shù)之前，然后對新的文件進行編譯，生成最終的可執(zhí)行程序。

　　(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和函數(shù)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

　　好了，大家不防想想這兩種方法的優(yōu)缺點，這里就只寫不足之處了：

　　1. 包含.c文件的方法: 容易產(chǎn)生"重定義",大家想想如果一個工程中有多個文件都同時包含了某一個件，那么這個被包含文件的內(nèi)容就會被復制到多個文件中去，也就相當于每個包含該文件的文件中都定義被包含文件中的變量和函數(shù)，這樣在鏈接時就會產(chǎn)生"重定義"錯誤。

　　2. 多文件分開編譯的方法: 這個比較好，不容易出現(xiàn)"重定義"之類的問題，這也是我們最常用的一種方法，但是并不是像上面這個例子中這樣直接去用，而是使用"頭文件"將各個.c文件聯(lián)系起來。

　　上邊這個例子大家會發(fā)現(xiàn)，在main.c中需要加上“extern int c;”這樣一句聲明，如果包含的文件較多?如果全局變量較多?...這個我們可以省掉嗎?回答是肯定的!方法就是給它寫上一個頭文件。

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

　　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) //函數(shù)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()函數(shù)的聲明

　　4: //end of file3

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

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

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