頭文件編譯通過的句子

1. include包含頭文件的語句中,雙引號和尖括弧的區別是什麼

雙引號表示先在程序源文件所在目錄查找，如果未找到則去系統默認目錄查找，通常用於包含程序作者編寫的頭文件;
尖括弧表示只在系統默認目錄或者括弧內的路徑查找，通常用於包含系統中自帶的頭文件;尖括弧：
在包含文件目錄中去查找(包含目錄是由用戶在設置環境時設置的)，而不在源文件目錄去查找；
雙引號：
首先在當前的源文件目錄中查找，若未找到才到包含目錄中去查找。

詳解：

預處理器發現 #include 指令後，就會尋找後跟的文件名並把這個文件的內容包含到當前文件中。被包含文件中的文本將替換源代碼文件中的#include指令，就像你把被包含文件中的全部內容鍵入到源文件中的這個位置一樣。
#include 指令有兩種使用形式
#include <stdio.h> 文件名放在尖括弧中
#include 「mystuff.h」 文件名放在雙引號中

尖括弧< 和> 括起來表明這個文件是一個工程或標准頭文件。查找過程會檢查預定義的目錄，我們可以通過設置搜索路徑環境變數或命令行選項來修改這些目錄。
如果文件名用一對引號括起來則表明該文件是用戶提供的頭文件，查找該
文件時將從當前文件目錄（或文件名指定的其他目錄）中尋找文件，然後再在標准位置尋找文件。
為什麼要包含文件呢？
因為這些文件包含了編譯器所需的信息。例如，stdio.h文件通常包含EOF,NULL,
getchar()和putchar()的定義。
包含大型頭文件並不一定顯著增加程序的大小。很多情況下，頭文件中的內容是編譯器產生最終代碼所需的信息，而不是加到最終代碼里的具體語句。
被包含的文件還可以含有#include 指示符，由於嵌套包含文件的原因，一個頭文件可能會被多次包含在一個源文件中，條件指示符可防止這種頭文件的重復處理。
例如：
#ifndef BOOKSTORE_H
#define BOOKSTORE_H

#endif
條件指示符#ifndef 檢查BOOKSTORE_H 在前面是否已經被定義，這里BOOKSTORE_H是一個預編譯器常量習慣上預編譯器常量往往被寫成大寫字母，如BOOKSTORE_H在前面沒有被定義，則條件指示符的值為真於是從#ifndef 到#endif 之間的所有語句都被包含進來進行處理。相反，如果#ifndef 指示符的值為假則它與#endif 指示符之間的行將被忽略，為了保證頭文件只被處理一次，把如下#define 指示符
#define BOOKSTORE_H
放在#ifndef 後面，這樣在頭文件的內容第一次被處理時，BOOKSTORE_H 將被定義
從而防止了在程序文本文件中以後#ifndef指示符的值為真。
只要不存在兩個必須包含的頭文件要檢查一個同名的預處理器常量這樣的情形，這個策略就能夠很好地運作。#ifdef 指示符常被用來判斷一個預處理器常量是否已被定義以便有條件地包含程序代碼。

2. c語言中如何編譯頭文件啊

1. 只要在程序開頭加入#include<頭文件名>，在編譯過程當中，頭文件自動會被添加到源文件當中一起進行編譯。

2. 編譯，編譯程序讀取源程序（字元流），對之進行詞法和語法的分析，將高級語言指令轉換為功能等效的匯編代碼，再由匯編程序轉換為機器語言，並且按照操作系統對可執行文件格式的要求鏈接生成可執行程序。
   C源程序頭文件－－>預編譯處理(cpp)－－>編譯程序本身－－>優化程序－－>匯編程序－－>鏈接程序-->可執行文件。
   

3. 為什麼C程序多文件編譯，沒有導入自己的頭文件也能正常編譯通過

在C中，函數在使用前沒有必要先聲明，會在調用時自動聲明，即使不include stdio.h，程序也可以正常編譯運行。但如果你把Max.c刪除的話會出現連接錯誤。

4. c++中如何編譯頭文件，編譯頭文件的作用，

編譯頭文件的理解竅門，在include語句。
你可以理解為，include就是替換，在編譯的時候，在include的位置完整的將頭文件「嵌入」進去，在cpp文件中共同編譯。如果一個頭文件沒有被任何文件包含（include），那麼它不會編譯。
頭文件，你可以簡單的認為就是「避免重復」，將重復的聲明放在一起，方便代碼閱讀和管理，同時頭文件具有方便介面和安全檢查方面的作用。

5. C語言，頭文件不包含也能編譯通過

turbo
c
2.0編譯系統中如果用到輸入輸出函數是可以不寫，用到其他函數就要寫對應得頭文件，但是turbo
c
3.0中都要寫。
你最好是寫起嘛，這是一種規范，反正又不累！

6. 為什麼在頭文件裡面用條件編譯呢程序如下

防止重復編譯。比如，第一次使用該頭文件後，LCDHEARD被定義過，以後再使用該頭文件，就不會重新編譯了。

7. C語言頭文件裡面應該寫什麼東西

1、一般做法是頭文件里只寫 函數 原型。函數定義部分可以編譯成 .obj 形式。應用時，調用程序里寫頭文件和調用語句，編譯時，把.obj 鏈接進去就可以了。你也可以把頭文件和 .obj 給別人，別人可以使用你的函數，但看不見你的源程序 -- 庫程序的基本原理就是這樣的。當然，不編成.obj ，而直接把10多個函數源程序寫進去也可以。

2、C語言頭文件

（1）在C語言家族程序中，頭文件被大量使用。一般而言，每個C++/C程序通常由頭文件(header files)和定義文件(definition files)組成。頭文件作為一種包含功能函數、數據介面聲明的載體文件，主要用於保存程序的聲明(declaration)，而定義文件用於保存程序的實現 (implementation)。 .c就是你寫的程序文件。

（2）一般在一個應用開發體系中，功能的真正邏輯實現是以硬體層為基礎，在驅動程序、功能層程序以及用戶的應用程序中完成的。頭文件的主要作用在於多個代碼文件全局變數(函數)的重用、防止定義的沖突，對各個被調用函數給出一個描述，其本身不需要包含程序的邏輯實現代碼，它只起描述性作用，用戶程序只需要按照頭文件中的介面聲明來調用相關函數或變數，鏈接器會從庫中尋找相應的實際定義代碼。

（3）從以上結構圖來看，頭文件是用戶應用程序和函數庫之間的橋梁和紐帶。在整個軟體中，頭文件不是最重要的部分，但它是C語言家族中不可缺少的組成部分。編譯時，編譯器通過頭文件找到對應的函數庫，進而把已引用函數的實際內容導出來代替原有函數。進而在硬體層面實現功能。

8. 頭文件里經常出現的這種語句是什麼意思

第一句：如果沒有 定義過 __STDINT_H_ 就接著執行下面的內容。否則跳過下面所有的內容。

第二句，只有當沒有定義過__STDINT_H_才會執行。這句就會定義__STDINT_H_。這就意味著：從此以後，這個stdint.h 再也不會執行了（只會執行這一遍）。

這樣做是為了方便以後的編程，任何源程序都可以在前面加入
#include <stdint.h>
而不用擔心次序和有多少文件加入了這個頭。因為：只會有一個文件將這個頭文件執行一遍，剩下的都會直接跳過去。（如果沒有這兩個命令，重復執行頭文件編譯的時候就會有錯誤！無法通過！）

希望你能滿意！對了，後面還要有 #endif，跟前面的#ifdef對應的。

看到樓上沒回答你的追問，我回答一下：
1，__STDINT_H_ 後面沒有東西，就是說只聲明定義了這個宏，但沒有給它任何的內容。因為前面一句只要判斷是否定義，而不用看它的內容。當然，你想加上任何的內容都可以，完全不影響。
2，__STDINT_H_ 這么寫完全是習慣。很多人還喜歡寫成 __STDINT_H__ 或者STDINT_H。

9. C++ 裡面的頭文件是什麼意思，具體，好評

一、C++編譯模式
通常，在一個C++程序中，只包含兩類文件——.cpp文件和.h文件。其中，.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()」函數之前，先聲明一下這個函數「void a();」，就可以了。這是因為編譯器在編譯b.cpp的時候會生成一個符號表（symbol table），像「void a()」這樣的看不到定義的符號，就會被存放在這個表中。再進行鏈接的時候，編譯器就會在別的目標文件中去尋找這個符號的定義。一旦找到了，程序也就可以 順利地生成了。

注意這里提到了兩個概念，一個是「定義」，一個是「聲明」。簡單地說，「定義」就是把一個符號完完整整地描述出來：它是變 量還是函數，返回什麼類型，需要什麼參數等等。而「聲明」則只是聲明這個符號的存在，即告訴編譯器，這個符號是在其他文件中定義的，我這里先用著，你鏈接 的時候再到別的地方去找找看它到底是什麼吧。定義的時候要按C++語法完整地定義一個符號（變數或者函數），而聲明的時候就只需要寫出這個符號的原型了。 需要注意的是，一個符號，在整個程序中可以被聲明多次，但卻要且僅要被定義一次。試想，如果一個符號出現了兩種不同的定義，編譯器該聽誰的？

這 種機制給C++程序員們帶來了很多好處，同時也引出了一種編寫程序的方法。考慮一下，如果有一個很常用的函數「void f() {}」，在整個程序中的許多.cpp文件中都會被調用，那麼，我們就只需要在一個文件中定義這個函數，而在其他的文件中聲明這個函數就可以了。一個函數還 好對付，聲明起來也就一句話。但是，如果函數多了，比如是一大堆的數學函數，有好幾百個，那怎麼辦？能保證每個程序員都可以完完全全地把所有函數的形式都 准確地記下來並寫出來嗎？
二、什麼是頭文件
很顯然，答案是不可能。但是有一個很簡單地辦法，可以幫助程序員們省去記住那麼多函數原型的麻煩：我們可以把那幾百個函數的聲明語句全都先寫好，放在一個文件里，等到程序員需要它們的時候，就把這些東西全部進他的源代碼中。

這 個方法固然可行，但還是太麻煩，而且還顯得很笨拙。於是，頭文件便可以發揮它的作用了。所謂的頭文件，其實它的內容跟.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，然後再把這兩個目標文件進行鏈接，程序就可以運行了。
三、#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"就行了。
四、頭文件中應該寫什麼
通 過上面的討論，我們可以了解到，頭文件的作用就是被其他的.cpp包含進去的。它們本身並不參與編譯，但實際上，它們的內容卻在多個.cpp文件中得到了 編譯。通過「定義只能有一次」的規則，我們很容易可以得出，頭文件中應該只放變數和函數的聲明，而不能放它們的定義。因為一個頭文件的內容實際上是會被引 入到多個不同的.cpp文件中的，並且它們都會被編譯。放聲明當然沒事，如果放了定義，那麼也就相當於在多個文件中出現了對於一個符號（變數或函數）的定 義，縱然這些定義都是相同的，但對於編譯器來說，這樣做不合法。
所以，應該記住的一點就是，.h頭文件中，只能存在變數或者函數的聲明， 而不要放定義。即，只能在頭文件中寫形如：extern int a;和void f();的句子。這些才是聲明。如果寫上int a;或者void f() {}這樣的句子，那麼一旦這個頭文件被兩個或兩個以上的.cpp文件包含的話，編譯器會立馬報錯。（關於extern，前面有討論過，這里不再討論定義跟 聲明的區別了。）
但是，這個規則是有三個例外的。

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

二，頭文件中可 以寫內聯函數（inline）的定義。因為inline函數是需要編譯器在遇到它的地方根據它的定義把它內聯展開的，而並非是普通函數那樣可以先聲明再鏈 接的（內聯函數不會鏈接），所以編譯器就需要在編譯時看到內聯函數的完整定義才行。如果內聯函數像普通函數一樣只能定義一次的話，這事兒就難辦了。因為在 一個文件中還好，我可以把內聯函數的定義寫在最開始，這樣可以保證後面使用的時候都可以見到定義；但是，如果我在其他的文件中還使用到了這個函數那怎麼辦 呢？這幾乎沒什麼太好的解決辦法，因此C++規定，內聯函數可以在程序中定義多次，只要內聯函數在一個.cpp文件中只出現一次，並且在所有的.cpp文 件中，這個內聯函數的定義是一樣的，就能通過編譯。那麼顯然，把內聯函數的定義放進一個頭文件中是非常明智的做法。

三，頭文件中可以寫類 （class）的定義。因為在程序中創建一個類的對象時，編譯器只有在這個類的定義完全可見的情況下，才能知道這個類的對象應該如何布局，所以，關於類的 定義的要求，跟內聯函數是基本一樣的。所以把類的定義放進頭文件，在使用到這個類的.cpp文件中去包含這個頭文件，是一個很好的做法。在這里，值得一提 的是，類的定義中包含著數據成員和函數成員。數據成員是要等到具體的對象被創建時才會被定義（分配空間），但函數成員卻是需要在一開始就被定義的，這也就 是我們通常所說的類的實現。一般，我們的做法是，把類的定義放在頭文件中，而把函數成員的實現代碼放在一個.cpp文件中。這是可以的，也是很好的辦法。 不過，還有另一種辦法。那就是直接把函數成員的實現代碼也寫進類定義裡面。在C++的類中，如果函數成員在類的定義體中被定義，那麼編譯器會視這個函數為 內聯的。因此，把函數成員的定義寫進類定義體，一起放進頭文件中，是合法的。注意一下，如果把函數成員的定義寫在類定義的頭文件中，而沒有寫進類定義中， 這是不合法的，因為這個函數成員此時就不是內聯的了。一旦頭文件被兩個或兩個以上的.cpp文件包含，這個函數成員就被重定義了。

四、頭文件中的保護措施
考 慮一下，如果頭文件中只包含聲明語句的話，它被同一個.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使得編譯器可以根據這個名字是否被定義，再決定要不要繼 續編譯該頭文中後續的內容。這個方法雖然簡單，但是寫頭文件時一定記得寫進去。

10. C語言中#include "stdafx.h"這個頭文件是什麼意思啊

"stdafx.h"這個頭文件意思是編譯器通過一個頭文件stdafx.h來使用預編譯頭文件。

"stdafx.h"頭文件沒有函數庫，只是定義了一些環境參數，使得編譯出來的程序能在32位的操作系統環境下運行。

使用AppWizard來自動生成某些項目的時候，系統會自動把所需要include的頭文件在stdafx.h中先include一下，這樣，只需要直接include這個stdafx.h文件即可。

(10)頭文件編譯通過的句子擴展閱讀

編譯器通過一個頭文件stdafx.h來使用預編譯頭文件。stdafx.h這個頭文件名是可以在project的編譯設置里指定的。編譯器認為，所有在指令#include "stdafx.h"前的代碼都是預編譯的，它跳過#include "stdafx. h"指令，使用projectname.pch編譯這條指令之後的所有代碼。

預編譯頭文件通過編譯stdafx.cpp生成，以工程名命名，由於預編譯的頭文件的後綴是「pch」，所以編譯結果文件是projectname.pch。