㈠ C語言中，include是什麼意思
在C系統的編程語言中，#include是為了聲明在這個地方插入別的文件中的代碼。
以#開頭，包含某個頭文件，如#include <stdio.h>，就是相當於引用stdio.h這個文件，然後這個文件裡面所定義的一些函數就可以直接使用了。
(1)include可以包含c文件嗎擴展閱讀
include()語句包含並運行指定文件。
以下文檔也適用於require()。這兩種結構除了在如何處理失敗之外完全一樣。include()產生一個警告而require()則導致一個致命錯誤。換句話說，如果想在遇到丟失文件時停止處理頁面就用require()。include()就不是這樣，腳本會繼續運行。
同時也要確認設置了合適的 include_path。注意在 php 4.3.5 之前，包含文件中的語法錯誤不會導致程序停止，但從此版本之後會。
尋找包含文件的順序先是在當前工作目錄的相對的 include_path 下尋找，然後是當前運行腳本所在目錄相對的 include_path 下尋找。
例如 include_path 是 .，當前工作目錄是 /www/，腳本中要 include 一個 include/a.php 並且在該文件中有一句 include "b.php"，則尋找 b.php 的順序先是 /www/，然後是 /www/include/。如果文件名以 ../ 開始，則只在當前工作目錄相對的 include_path 下尋找。
當一個文件被包含時，其中所包含的代碼繼承了 include 所在行的變數范圍。從該處開始，調用文件在該行處可用的任何變數在被調用的文件中也都可用。不過所有在包含文件中定義的函數和類都具有全局作用域。
㈡ c語言宏定義中，可以文件包含另一個c源程序嗎
c語言文件包含的預處理命令是#include。
從純粹的文本文件來說，#include的作用就是搜索它後面指示的文件，並把這個文件的內容加到當前的文件中。一般編程時，都是包含一些與.h為後綴的頭文件，但是它可以包含任何後綴的任何形式的text文件的，而不僅僅是.h為後綴的頭文件，也可以C源文件，如下：
#include
"test.c"
#include一般兩種形式，如下
#include
<syshead.h>
#include
"userhead.h"
用尖括弧表示的是包含系統的標准頭文件，用雙引號包含的是用戶自己的頭文件。
㈢ #include應該包含頭文件還是源文件
include是C/C++標准輸入頭文件。包含指令不僅僅限於.h頭文件，可以包含任何編譯器能識別的C/C++代碼文件，包括.c,.hpp,.cpp,.hxx,.cxx等，甚至.txt,.abc等等都可以
㈣ #include命令可以包括有函數定義的C語言源程序文件對嗎
#include命令可以包括任何符合標準的文本格式文件，包括.c/.cpp等格式。
但在實際編譯鏈接過程中，包含有函數定義的.c/.cpp源文件，會報錯，因為包含會造成鏈接歧義。
因此，這句話是不正確的。
㈤ c語言中，#include中包含的文件是什麼頭文件還是源文件
C/C++等一些語言在運行時需要導入需要的庫，常用的比如stdio.h， 如果代碼中需要數學運算符比如開方sqrt函數，就要導入數學庫math.h，每個庫都有自己特殊的函數，看你的程序需求。
㈥ 請問 #include "文件名.c" 是什麼意思啊
include是C語言的文件包含指令，表示在編譯的時候將「文件名.c」中的內容包含進來。當然「文件名.c」形式的C源文件中的內容不僅僅限於C語言的庫函數，也可以是自已編寫的自定義函數。
㈦ 一個 include 命令可指定多個被包含文件嗎
一個include命令只能包含一個被包含文件。只要找到具有給定名稱的文件，預處理器就會停止搜索。 如果在兩個雙引號 (" ") 之間括住包含文件的完整明確的路徑說明，則預處理器只搜索該路徑說明，並忽略標准目錄。
預處理器指令（如 #define 和 #include）通常用於簡化源程序在不同的執行環境中的更改和編譯，而#include用於告知預處理器將已指定文件的內容視為它們在源程序中指令出現處出現的方式處理。一般將常數和宏定義編入包含文件中，然後使用 #include 指令將它們添加到任何源文件中。 包含文件還可用於合並外部變數和復雜數據類型的聲明。 在為此目的而創建的包含文件中，類型只能定義和命名一次。
㈧ c語言include的用法是什麼
我整理了c語言 include的用法。希望對你有幫助哦!
其實這個只要了解了文件包含的基本處理方法就可以對文件包含有一個很好的理解與應用了，下來我們一起來看一下：
文件包含的處理方法：
處理時間：文件包含也是以"#"開頭來寫的(#include ), 那麼它就是寫給預處理器來看了, 也就是說文件包含是會在編譯預處理階段進行處理的。
處理方法：在預處理階段，系統自動對#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
好了，大家不防想想這兩種方法的優缺點，這里就只寫不足之處了：
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文件就可以了。
㈨ 「include」是C語言關鍵字嗎
「include」不是C語言關鍵字，是預處理命令。
include是一個計算機專業術語，表示包含C/C++標准輸入輸出頭文件的預處理命令，用於將指定頭文件嵌入源文件中。不僅僅限於.h頭文件，可以包含任何編譯器能識別的C/C++代碼文件，包括.c、.hpp、.cpp、.hxx、.cxx等，甚至.txt、.abc等等都可以。
(9)include可以包含c文件嗎擴展閱讀：
預處理器發現 #include 指令後，就會尋找指令後面<>中的文件名，並把這個文件的內容包含到當前文件中。被包含文件中的文本將替換源代碼文件中的#include 指令， 就像把被包含文件中的全部內容鍵入到源文件中的這個位置一樣。
只要是用符合標準的代碼編寫的文本文件，就可以使用#include來進行包含，包括.cpp .c等常見的源文件擴展名。這些指令的實現是由編譯器來決定的。
㈩ C語言可以直接include一個C文件嗎
語法上講可以,
但是多文件編譯不是這么做的,是通過添加編譯器選項或者用IDE的話是修改項目設置來實現的