警號define命令是在編譯之前處理的

Ⅰ 什麼是預處理命令

打個比方，你做飯之前是不是准備一下。我們現在設定做飯當中你那些撿菜，洗菜這些不算是做飯的范圍，整理廚房等等都不屬於做飯的范圍。我們將點火，燒油，放菜，等等算是做菜。那麼預編譯就是前面那些整理廚房。編譯器在正式編譯之前就開始做預編譯工作。

Ⅱ c語言裡面的#define預處理命令是干什麼的

宏定義
c程序提供的預處理功能之一。包括帶參數的宏定義和不帶參數的宏定義。具體是指用一個指定的標志符來進行簡單的字元串替換或者進行闡述替換。形式為：
#define 標志符（參數表） 字元串
宏名
在上定義中的標志符被稱為「宏名」。
宏展開
在c程序編譯時將宏名替換成字元串的過程稱為「宏展開」。
define 是對宏的定義：如定義了一個宏m，代表100.也就在下面的程序中只要是遇到變數m，它的值就是100

Ⅲ C語言中， #define PI 3.1415926 中的define 是編譯預處理命令。這句

這個是把PI定義為3.1415926是宏定義

Ⅳ 對預處理命令的處理是在編譯過程中還是連接過程中

A)如果代碼是注釋它就不起作用了.如
/*注釋
#define
*/A可以說對也可以說錯看你咬文嚼字到什麼程度
B)預處理命令行不可以宏定義是可以的
C)對的
D)預處理當然是最先處理,比編譯,鏈接都早怎麼可能在執行過程中進行
如果是考試我選錯誤最明顯的..選D嗯...

Ⅳ #define命令是干什麼用的

轉自http://blog.csdn.net/djsl6071/archive/2007/04/02/1549539.aspx

1.簡單的define定義

#define MAXTIME 1000

一個簡單的MAXTIME就定義好了，它代表1000，如果在程序裡面寫

if(i<MAXTIME){.........}

編譯器在處理這個代碼之前會對MAXTIME進行處理替換為1000。

這樣的定義看起來類似於普通的常量定義CONST，但也有著不同，因為define的定義更像是簡單的文本替換，而不是作為一個量來使用，這個問題在下面反映的尤為突出。

2.define的「函數定義」

define可以像函數那樣接受一些參數，如下

#define max(x,y) (x)>(y)?(x):(y);

這個定義就將返回兩個數中較大的那個，看到了嗎？因為這個「函數」沒有類型檢查，就好像一個函數模板似的，當然，它絕對沒有模板那麼安全就是了。可以作為一個簡單的模板來使用而已。

但是這樣做的話存在隱患，例子如下：
#define Add(a,b) a+b;
在一般使用的時候是沒有問題的，但是如果遇到如：c * Add(a,b) * d的時候就會出現問題，代數式的本意是a+b然後去和c，d相乘，但是因為使用了define（它只是一個簡單的替換），所以式子實際上變成了
c*a + b*d

另外舉一個例子：
#define pin (int*);
pin a,b;
本意是a和b都是int型指針，但是實際上變成int* a,b;
a是int型指針，而b是int型變數。
這是應該使用typedef來代替define，這樣a和b就都是int型指針了。

所以我們在定義的時候，養成一個良好的習慣，建議所有的層次都要加括弧。

3.宏的單行定義
#define A(x) T_##x
#define B（x) #@x

#define C（x) #x
我們假設：x=1，則有：
A(1)------〉T_1
B(1)------〉'1'
C(1)------〉"1"

（這里參考了 hustli的文章）

3.define的多行定義

define可以替代多行的代碼，例如MFC中的宏定義（非常的經典，雖然讓人看了惡心）

#define MACRO(arg1, arg2) do { \
/* declarations */ \
stmt1; \
stmt2; \
/* ... */ \
} while(0) /* (no trailing ; ) */
關鍵是要在每一個換行的時候加上一個"\

修補了幾個bug

4.在大規模的開發過程中，特別是跨平台和系統的軟體里，define最重要的功能是條件編譯。

就是：
#ifdef WINDOWS
......
......
#endif
#ifdef LINUX
......
......
#endif

可以在編譯的時候通過#define設置編譯環境

5.如何定義宏、取消宏

//定義宏
#define [MacroName] [MacroValue]
//取消宏
#undef [MacroName]
普通宏
#define PI (3.1415926)

帶參數的宏
#define max(a,b) ((a)>(b)? (a),(b))
關鍵是十分容易產生錯誤，包括機器和人理解上的差異等等。

6.條件編譯
#ifdef XXX…(#else) …#endif
例如 #ifdef DV22_AUX_INPUT
#define AUX_MODE 3
#else
#define AUY_MODE 3
＃endif
#ifndef XXX … (#else) … #endif

7.頭文件(.h)可以被頭文件或C文件包含；
重復包含（重復定義）
由於頭文件包含可以嵌套，那麼C文件就有可能包含多次同一個頭文件，就可能出現重復定義的問題的。
通過條件編譯開關來避免重復包含（重復定義）
例如
#ifndef __headerfileXXX__
＃define __headerfileXXX__
…
文件內容
…
#endif

以上只是我從網路上搜集了一些關於define的一些用法，可能還不全面，而且#define的使用本來也存在這爭議，如果你對#define的用法也很有興趣，可以來參加我們的討論（點擊下面的鏈接）
http://www.dingge.com/forum/dispbbs.asp?boardID=43&ID=6972&page=1

＃define和typedef的區別

1) #define是預處理指令，在編譯預處理時進行簡單的替換，不作正確性檢查，不關含義是否正確照樣帶入，只有在編譯已被展開的源程序時才會發現可能的錯誤並報錯。例如：
#define PI 3.1415926
程序中的：area=PI*r*r 會替換為3.1415926*r*r
如果你把#define語句中的數字9 寫成字母g 預處理也照樣帶入。

2）typedef是在編譯時處理的。它在自己的作用域內給一個已經存在的類型一個別名，但是You cannot use the typedef specifier inside a function definition。

3）typedef int * int_ptr;
與
#define int_ptr int *
作用都是用int_ptr代表 int * ,但是二者不同，正如前面所說 ，#define在預處理 時進行簡單的替換，而typedef不是簡單替換 ，而是採用如同定義變數的方法那樣來聲明一種類型。也就是說;

//refer to (xzgyb(老達摩))
#define int_ptr int *
int_ptr a, b; //相當於int * a, b; 只是簡單的宏替換

typedef int* int_ptr;
int_ptr a, b; //a, b 都為指向int的指針,typedef為int* 引入了一個新的助記符

這也說明了為什麼下面觀點成立
//QunKangLi(維護成本與程序員的創造力的平方成正比)
typedef int * pint ;
#define PINT int *

那麼：
const pint p ;//p不可更改，但p指向的內容可更改
const PINT p ;//p可更改，但是p指向的內容不可更改。

pint是一種指針類型 const pint p 就是把指針給鎖住了 p不可更改
而const PINT p 是const int * p 鎖的是指針p所指的對象。

3）也許您已經注意到#define 不是語句 不要在行末加分號，否則 會連分號一塊置換。

Ⅵ #define是預處理指令,typedef是在編譯時處理的,編譯預處理和編譯時處理有什麼不同。

編譯預處理會在編譯前處理好，比如#define N 7 則遇到N的地方都直接用7替換，然後在進行整個程序的編譯，typedef則是在編譯時遇到你所定義的東西，再回到typedef語句中尋找解釋，繼續編譯下去的

Ⅶ 為什麼A是對的，預處理命令行都必須以#號開始 才是對的把

因為如果代碼是注釋它就不起作用了。

如/*注釋#define。

B、預處理命令行不可以 宏定義是可以的。

C、程序在執行過程中對預處理命令行進行處理。是在執行過程之前，所以才稱為預處理，就是先於程序處理的意思，這是對的。

宏定義又稱為宏代換、宏替換，簡稱「宏」。格式：#define標識符文本，其中的標識符就是所謂的符號常量，也稱為「宏名」。

D、對預處理命令行的處理是在編譯之前完成的，不是程序執行的過程中，選D。

(7)警號define命令是在編譯之前處理的擴展閱讀：

正確的宏定義是#define S(r) ((r)*(r))

（2）宏名和參數的括弧間不能有空格

（3）宏替換只作替換，不做計算，不做表達式求解

（4）函數調用在編譯後程序運行時進行，並且分配內存。宏替換在編譯前進行，不分配內存

（5）宏的啞實結合不存在類型，也沒有類型轉換。

（6）宏展開使源程序變長，函數調用不會

（7）宏展開不佔運行時間，只佔編譯時間，函數調用占運行時間（分配內存、保留現場、值傳遞、返回值）。

Ⅷ c程序在執行過程中對預處理命令進行處理這一說法為什麼是錯誤的

C語言在編譯前由預處理器對預處理命令進行處理,編譯時進行語法分析。執行過程就是運行程序。

程序設計語言的預處理的概念：在編譯之前進行的處理。

C語言的預處理主要有三個方面的內容：

1、宏定義；

2、文件包含；

3、條件編譯。 預處理命令以符號「#」開頭。

C程序的源代碼中可包括各種編譯指令，這些指令稱為預處理命令。雖然它們實際上不是C語言的一部分，但卻擴展了C程序設計的環境。本節將介紹如何應用預處理程序和注釋簡化程序開發過程，並提高程序的可讀性。

(8)警號define命令是在編譯之前處理的擴展閱讀

C語言無參數宏定義

在C語言源程序中允許用一個標識符來表示一個字元串，稱為「宏」。被定義為「宏」的標識符稱為「宏名」。在編譯預處理時，對程序中所有出現的「宏名」，都用宏定義中的字元串去代換，這稱為「宏代換」或「宏展開」。

宏定義是由源程序中的宏定義命令完成的。宏代換是由預處理程序自動完成的。在C語言中，「宏」分為有參數和無參數兩種。本節討論無參數宏。

無參宏的宏名後不帶參數。其定義的一般形式為：#define 標識符 字元串

其中的「#」表示這是一條預處理命令。凡是以「#」開頭的均為預處理命令。「define」為宏定義命令。「標識符」為所定義的宏名。「字元串」可以是常數、表達式、格式串等。

在前面介紹過的符號常量的定義就是一種無參宏定義。此外，常對程序中反復使用的表達式進行宏定義。例如：#define M (y*y+3*y)

Ⅸ 關於C語言define的一個問題

define是C語言中的預處理命令，它用於宏定義，可以提高源代碼的可讀性，為編程提供方便。 預處理命令以「#」號開頭，如包含命令#include，宏定義命令#define等。一般都放在源文件的前面，它們稱為預處理部分。 所謂預處理是指在進行編譯之前所作的工作。預處理是C語言的一個重要功能，它由預處理程序負責完成。當對一個源文件進行編譯時，系統將自動引用預處理程序對源程序中的預處理部分作處理，處理完畢自動進入對源程序的編譯。 宏的定義 在C或C++語言源程序中允許用一個標識符來表示一個字元串，稱為「宏」。被定義為「宏」的標識符稱為「宏名」。在編譯預處理時，對程序中所有出現的「宏名」，都用宏定義中的字元串去代換，這稱為「宏代換」或「宏展開」。宏定義是由源程序中的宏定義命令完成的。宏代換是由預處理程序自動完成的。 在C或C++語言中，「宏」分為有參數和無參數兩種。 無參數宏定義 無參數宏就是不帶參數，其定義的一般形式為： #define 標識符 字元串 「標識符」為所定義的宏名。「字元串」可以是常數、表達式、格式串等。 例如： #define PI 3.14 它的作用是指定標識符PI來代替常數3.14。在編寫源程序時，所有用到3.14的地方都可用PI代替，而對源程序作編譯時，將先由預處理程序進行宏代換，即用3.14去置換所有的宏名PI，然後再進行編譯。 宏定義是用宏名來表示一個字元串，在宏展開時又以該字元串取代宏名，這只是一種簡單的代換，字元串可以是常數，也可以是表達式，預處理程序對它不作任何檢查。如有錯誤，只能在編譯已被宏展開後的源程序時發現。 宏定義不是說明或語句(它是預處理指令)，在行末不必加分號，如加上分號則連分號也一起置換。 下面舉一個無參數宏替代常數的例子： #define PI 3.14 #include <stdio.h> int main() { float r = 1.0; float area = PI*r*r; printf("The area of the circle is %f",area); return 0; } 再舉一個使用無參數宏替代字元串的例子： #define M (y*y+3*y) #include <stdio.h> int main() { int s,y; printf("input a number: "); scanf("%d",&y); s = 3*M + 4*M + 5*M; printf("s=%d\n",s); return 0; } # define M (y*y+3*y) 定義M表達式(y*y+3*y)。在編寫源程序時，所有的(y*y+3*y)都可由M代替，而對源程序作編譯時，將先由預處理程序進行宏代換，即用 (y*y+3*y)表達式去置換所有的宏名M，然後再進行編譯。 上常式序中首先進行宏定義，定義M表達式(y*y+3*y),在s= 3*M+4*M+5* M中作了宏調用。在預處理時經宏展開後該語句變為：s=3*(y*y+3*y)+4* (y*y+3*y)+5* (y*y+3*y);但要注意的是，在宏定義中表達式(y*y+3*y)兩邊的括弧不能少。否則會發生錯誤。 帶參數宏定義 C語言允許宏帶有參數。在宏定義中的參數稱為形式參數，在宏調用中的參數稱為實際參數。對帶參數的宏，在調用中，不僅要宏展開，而且要用實參去代換形參。 帶參數宏定義的一般形式為： #define 宏名(形參表) 字元串 在字元串中含有各個形參。 帶參數宏調用的一般形式為： 宏名(實參表) 例如： #define M(y) y*y+3*y .... k=M(5); .... 在宏調用時，用實參5去代替形參y，經預處理宏展開後的語句為: k=5*5+3*5 舉一個具體例子： #define MAX(a,b) (a>b)?a:b #include <stdio.h> int main() { int x,y,max; printf("input two numbers: "); scanf("%d%d",&x,&y); max = MAX(x,y); printf("max=%d\n",max); return 0; } 上常式序的第一行進行帶參數宏定義，用宏名MAX表示條件表達式(a>b)?a:b，形參a,b均出現在條件表達式中。程序第七行max = MAX(x, y)為宏調用，實參x,y，將代換形參a,b。宏展開後該語句為： max = (x>y)?x:y;用於計算x,y中的大數。 對於帶參的宏定義有以下問題需要說明： 1. 帶參宏定義中，宏名和形參表之間不能有空格出現。 例如把： #define MAX(a,b) (a>b)?a:b寫為： #define MAX (a,b) (a>b)?a:b 將被認為是無參宏定義，宏名MAX代表字元串 (a,b)(a>b)?a:b。 宏展開時，宏調用語句： max = MAX(x,y);將變為： max = (a,b)(a>b)?a:b(x,y);這顯然是錯誤的。 2. 在宏定義中的形參是標識符，而宏調用中的實參可以是表達式。 #define SQ(y) (y)*(y) #include <stdio.h> int main() { int a,sq; printf("input a number: "); scanf("%d",&a); sq=SQ(a+1); printf("sq=%d\n",sq); return 0; } 上例中第一行為宏定義，形參為y。程序第七行宏調用中實參為a+1，是一個表達式，在宏展開時，用a+1代換y，再用(y)*(y) 代換SQ，得到如下語句： sq=(a+1)*(a+1); 這與函數的調用是不同的，函數調用時要把實參表達式的值求出來再賦予形參。而宏代換中對實參表達式不作計算直接地照原樣代換。 3. 在宏定義中，字元串內的形參通常要用括弧括起來以避免出錯。在上例中的宏定義中(y)*(y)表達式的y都用括弧括起來，結果是正確的。如果去掉括弧，把程序改為以下形式： #define SQ(y) y*y #include <stdio.h> int main() { int a,sq; printf("input a number: "); scanf("%d",&a); sq=SQ(a+1); printf("sq=%d\n",sq); return 0; } 運行結果為：input a number:3 sq=7 （我們期望的結果卻是16）。 問題在哪裡呢? 這是由於代換只作符號代換而不作其它處理而造成的。 宏代換後將得到以下語句： sq=a+1*a+1; 由於a為3故sq的值為7。這顯然與題意相違，因此參數兩邊的括弧是不能少的。有時候，即使在參數兩邊加括弧還是不夠的，請看下面程序： #define SQ(y) (y)*(y) #include <stdio.h> int main() { int a,sq; printf("input a number: "); scanf("%d",&a); sq=160/SQ(a+1); printf("sq=%d\n",sq); return 0; } 本程序與前例相比，只把宏調用語句改為： sq=160/SQ(a+1); 運行本程序如輸入值仍為3時，希望結果為10。但實際運行的結果如下：input a number:3 sq=160。 為什麼會得這樣的結果呢?分析宏調用語句，在宏代換之後變為： sq=160/(a+1)*(a+1);a為3時，由於「/」和「*」運算符優先順序和結合性相同，則先作160/(3+1)得40，再作40*(3+1)最後得160。為了得到正確答案應在宏定義中的整個字元串外加括弧，程序修改如下： #define SQ(y) ((y)*(y)) #include <stdio.h> int main() { int a,sq; printf("input a number: "); scanf("%d",&a); sq=160/SQ(a+1); printf("sq=%d\n",sq); return 0; } 以上討論說明，對於宏定義，保險的做法是不僅應在參數兩側加括弧，也應在整個字元串外加括弧。 4. 帶參數的宏和帶參函數很相似，但有本質上的不同，把同一表達式用函數處理與用宏處理兩者的結果有可能是不同的。 下面舉一個例子進行對比： 使用函數： #include <stdio.h> int SQ(int); int main() { int i=1; while(i<=5) printf("%d\n",SQ(i++)); return 0; } int SQ(int y) { return((y)*(y)); } 使用宏： #define SQ(y) ((y)*(y)) #include <stdio.h> int main() { int i=1; while(i<=5) printf("%d\n",SQ(i++)); return 0; } 在使用函數的例子中函數名為SQ，形參為Y，函數體表達式為((y)*(y))。在使用宏的例子中宏名為SQ，形參也為y，字元串表達式為(y)*(y))。兩例表面是相同的，函數調用為SQ(i++)，宏調用為SQ(i++)，實參也是相同的。但輸出結果卻大不相同，分析如下： 在使用函數的例子中，函數調用是把實參i值傳給形參y後自增1。然後輸出函數值。因而要循環5次。輸出1～5的平方值。而在使用宏的例子中，宏調用時，只作代換。SQ(i++)被代換為((i++)*(i++))。在第一次循環時，由於i等於1，其計算過程為：表達式中前一個i初值為1，然後i自增1變為2，因此表達式中第2個i初值為2，兩相乘的結果也為2，然後i值再自增1，得3。在第二次循環時，i值已有初值為3，因此表達式中前一個i為3，後一個i為4，乘積為12，然後i再自增1變為5。進入第三次循環，由於i 值已為5，所以這將是最後一次循環。計算表達式的值為5*6等於30。i值再自增1變為6，不再滿足循環條件，停止循環。從以上分析可以看出函數調用和宏調用二者在形式上相似，在本質上是完全不同的。 "\","#","#@" 和"##" 在用#define 定義時 , 斜杠("\")是用來續行的，"#"用來把參數轉換成字元串，是給參數加上雙引號。"##"則用來連接前後兩個參數，把它們變成一個字元串,"#@"是給參數加上單引號。下面的例子會使您很容易理解。 #define Conn(x,y) x##y #define ToChar(a) #@a #define ToString(x) #x int n = Conn(123,456); 結果就是n=123456; char* str = Conn("asdf", "adf")結果就是 str = "asdfadf"; char a = ToChar(1);結果就是a='1'; char* str = ToString(123132);就成了str="123132"; 為什麼需要」#」,」 #@」和」##」這三個操作符呢？原因如下： 宏名在源程序中若用引號括起來，則預處理程序不對其作宏代換。如下： #define OK 100 #include <stdio.h> int main() { printf("OK"); printf("\n"); return 0; } 上例中定義宏名OK表示100，但在printf語句中OK被引號括起來，因此不作宏代換。程序的運行結果為：OK,這表示把「OK」當字元串處理。 同樣，宏名在源程序中若用單引號括起來，則預處理程序也不對其作宏代換。 宏定義的嵌套 宏定義允許嵌套，在宏定義的字元串中可以使用已經定義的宏名。在宏展開時由預處理程序層層代換。例如： #define PI 3.1415926 #define S PI*y*y 對語句： printf("%f",s); 在宏代換後變為： printf("%f",3.1415926*y*y); 結束語 使用宏代替一個在程序中經常使用的常量，這樣該常量改變時，不用對整個程序進行修改，只修改宏定義的字元串即可，而且當常量比較長時，我們可以用較短的有意義的標識符來寫程序，這樣更方便一些。舉一個大家比較熟悉的例子，圓周率π是在數學上常用的一個值，有時我們會用3.14來表示，有時也會用3.1415926等，這要看計算所需要的精度，如果我們編制的一個程序中要多次使用它，那麼需要確定一個數值，在本次運行中不改變，但也許後來發現程序所表現的精度有變化，需要改變它的值，這就需要修改程序中所有的相關數值，這會給我們帶來一定的不便，但如果使用宏定義，使用一個標識符來代替，則在修改時只修改宏定義即可，還可以減少輸入 3.1415926這樣長的數值多次的情況，我們可以如此定義 #define pi 3.1415926，既減少了輸入又便於修改，何樂而不為呢？ 另外，使用帶參數的宏定義可完成函數調用的功能，又能減少系統開銷，提高運行效率。正如C語言中所講，函數的使用可以使程序更加模塊化，便於組織，而且可重復利用，但在發生函數調用時，需要保留調用函數的現場，以便子函數執行結束後能返回繼續執行，同樣在子函數執行完後要恢復調用函數的現場，這都需要一定的時間，如果子函數執行的操作比較多，這種轉換時間開銷可以忽略，但如果子函數完成的功能比較少，甚至於只完成一點操作，如一個乘法語句的操作，則這部分轉換開銷就相對較大了，但使用帶參數的宏定義就不會出現這個問題，因為它是在預處理階段即進行了宏展開，在執行時不需要轉換，即在當地執行。宏定義可完成簡單的操作，但復雜的操作還是要由函數調用來完成，而且宏定義所佔用的目標代碼空間相對較大。所以在使用時要依據具體情況來決定是否使用宏定義。

Ⅹ c++ 在編譯時對define所定義的變數是怎麼處理的

宏定義在編譯的時候進行替換。
#define EXT 4 不安全，建議修改成 #define EXT （4）