一、#define的基本用法
    #define是C語言中提供的巨集定義命令，其主要目的是為程式設計師在程式設計時提供一定的方便，並能在一定程度上提高程式的執行效率，但學生在學習時往往不能 理解該命令的本質，總是在此處產生一些困惑，在程式設計時誤用該命令，使得程式的執行與預期的目的不一致，或者在讀別人寫的程式時，把執行結果理解錯誤，這對 C語言的學習很不利。
1　#define命令剖析
1.1   #define的概念
    #define命令是C語言中的一個巨集定義命令，它用來將一個識別符號定義為一個字串，該識別符號被稱為巨集名，被定義的字串稱為替換文字。
該命令有兩種格式：一種是簡單的巨集定義，另一種是帶引數的巨集定義。

(1)簡單的巨集定義：

1. #define <巨集名>　　<字串>
   
2. 例： #define PI 3.1415926

(2) 帶引數的巨集定義
 

1. #define <巨集名> (<引數表>) <巨集體>
   
2. 例： #define A(x) x

    一個識別符號被巨集定義後，該識別符號便是一個巨集名。這時，在程式中出現的是巨集名，在該程式被編譯前，先將巨集名用被定義的字串替換，這稱為巨集替換，替換後才進行編譯， 巨集替換是簡單的替換

。
1.2 巨集替換髮生的時機
    為了能夠真正理解#define的作用，讓我們來了解一下對C語言源程式的處理過程。當我們在一個整合的開發環境如Turbo C中將編寫好的源程式進行編譯時，實際經過了預處理、編譯、彙編和連線幾個過程。其中前處理器產生編譯器的輸出，它實現以下的功能：
（1） 檔案包含
    可以把源程式中的#include 擴充套件為檔案正文，即把包含的.h檔案找到並展開到#include 所在處。
（2）條件編譯
    前處理器根據#if和#ifdef等編譯命令及其後的條件，將源程式中的某部分包含進來或排除在外，通常把排除在外的語句轉換成空行。
（3）巨集展開
    前處理器將源程式檔案中出現的對巨集的引用展開成相應的巨集 定義，即本文所說的#define的功能，由前處理器來完成。
    經過前處理器處理的源程式與之前的源程式有所有不同， 在這個階段所進行的工作只是純粹的替換與展開，沒有任何計算功能，所以在學習#define命令時只要能真正理解這一點，這樣才不會對此命令引起誤解並誤用。
2　#define使用中的常見問題解析
2.1 簡單巨集定義使用中出現的問題
    在簡單巨集定義的使用中，當替換文字所表示的字串為一個表示式時，容易引起誤解和誤用。如下例：
   

1. 例1 #define N 2+2
   
2. void main()
   
3. {
   
4.    int a=N*N;
   
5.    printf(“%d”,a);
   
6. }

     (1) 出現問題：       在此程式中存在著巨集定義命令，巨集N代表的字串是2+2，在程式中有對巨集N的使用，一般同學在讀該程式時，容易產生的問題是先求解N為2＋2＝4，然後在程式中計算a時使用乘法，即N*N=4*4=16, 其實該題的結果為8，為什麼結果有這麼大的偏差?
     (2) 問題解析：       如1節所述， 巨集展開是在預處理階段完成的，這個階段把替換文字只是看作一個字串，並不會有任何的計算髮生，在展開時是在巨集N出現的地方 只是簡單地使用串2＋2來代替N，並不會增添任何的符號，所以對該程式展開後的結果是a=2+2*2+2，計算後=8，這就是巨集替換的實質，如何寫程式才能完成結果為16的運算呢？
     (3)解決辦法：  

1. /*將巨集定義寫成如下形式*/
   
2. #define N (2+2)
   
3. /*這樣就可替換成(2+2)*(2+2)=16*/

2.2 帶引數的巨集定義出現的問題
    在帶引數的巨集定義的使用中，極易引起誤解。例如我們需要做個巨集替換能求任何數的平方，這就需要使用引數，以便在程式中用實際引數來替換巨集定義中的引數。一般學生容易寫成如下形式：

1. #define area(x) x*x
   
2. /*這在使用中是很容易出現問題的，看如下的程式*/
   
3. 
   
4. void main()
   
5. {
   
6.     int y = area(2+2);
   
7.     printf(“%d”,y);
   
8. }

    按理說給的引數是2+2，所得的結果應該為4*4=16，但是錯了，因為該程式的實際結果為8，仍然是沒能遵循純粹的簡單替換的規則，又是先計算再替換 了， 在這道程式裡，2+2即為area巨集中的引數，應該由它來替換巨集定義中的x，即替換成2+2*2+2=8了。那如果遵循(1)中的解決辦法，把2+2 括起來，即把巨集體中的x括起來，是否可以呢？#define area(x) (x)*(x)，對於area(2+2)，替換為(2+2)*(2+2)=16，可以解決， 但是對於area(2+2)/area(2+2)又會怎麼樣呢，有的學生一看到這道題馬上給出結果，因為分子分母一樣，又錯了，還是忘了遵循先替換再計算的規則了，這道題替換後會變為 (2+2)*(2+2)/(2+2)*(2+2)即4*4/4*4按照乘除運算規則，結果為16/4*4=4*4=16，那應該怎麼呢？解決方法是在整個巨集體上再加一個括號，即 #define   area(x) ((x)*(x))， 不要覺得這沒必要，沒有它，是不行的。
    要想能夠真正使用好巨集定義，那麼在讀別人的程式時， 一定要記住先將程式中對巨集的使用全部替換成它所代表的字串，不要自作主張地新增任何其他符號，完全展開後再進行相應的計算，就不會寫錯執行結果。      如果是自己程式設計使用巨集替換，則在使用簡單巨集定義時，當字串中不只一個符號時，加上括號表現出優先順序，如果是帶引數的巨集定義，則要給巨集體中的每個引數加上括號，並在整個巨集體上再加一個括號。看到這裡，不禁要問，用巨集定義這麼麻煩，這麼容易出錯，可不可以摒棄它， 那讓我們來看一下在C語言中用巨集定義的好處吧。 如：

1. #include <iostream.h>
   
2. #define product(x)    x*x
   
3. int main()
   
4. {
   
5.     int i=3;
   
6.     int j,k;
   
7.     j = product(i++);
   
8.     cout<<"j="<<j<<endl;
   
9.     cout<<"i="<<i<<endl;
   
10.     k = product(++i);
    
11.     cout<<"k="<<k<<endl;
    
12.     cout<<"i="<<i<<endl;
    
13.     return 0;
    
14. }

依次輸出結果： j=9;i=5;k=49;i=7

3 巨集定義的優點
(1)   方便程式的修改
    使用簡單巨集定義可用巨集代替一個在程式中經常使用的常量，這樣在將該常量改變時，不用對整個程式進行修改，只修改巨集定義的字串即可，而且當常量比較長時， 我們可以用較短的有意義的識別符號來寫程式，這樣更方便一些。我們所說的常量改變不是在程式執行期間改變，而是在程式設計期間的修改，舉一個大家比較熟悉的例子，圓周率π是在數學上常用的一個值，有時我們會用3.14來表示，有時也會用3.1415926等，這要看計算所需要的精度，如果我們編制的一個程式中 要多次使用它，那麼需要確定一個數值，在本次執行中不改變，但也許後來發現程式所表現的精度有變化，需要改變它的值， 這就需要修改程式中所有的相關數值，這會給我們帶來一定的不便，但如果使用巨集定義，使用一個識別符號來代替，則在修改時只修改巨集定義即可，還可以減少輸入 3.1415926這樣長的數值多次的情況，我們可以如此定義 #define   pi   3.1415926，既減少了輸入又便於修改，何樂而不為呢？
(2) 提高程式的執行效率
    使用帶引數的巨集定義可完成函式呼叫的功能，又能減少 系統開銷，提高執行效率。正如C語言中所講，函式的使用可以使程式更加模組化，便於組織，而且可重複利用，但在發生函式呼叫時，需要保留呼叫函式的現場，以便子 函式執行結束後能返回繼續執行，同樣在子函式執行完後要恢復呼叫函式的現場，這都需要一定的時間，如果子函式執行的操作比較多，這種轉換時間開銷可以忽 略，但如果子函式完成的功能比較少，甚至於只完成一點操作，如一個乘法語句的操作，則這部分轉換開銷就相對較大了，但使用帶引數的巨集定義就不會出現這個問 題，因為它是在預處理階段即進行了巨集展開，在執行時不需要轉換，即在當地執行。巨集定義可完成簡單的操作，但複雜的操作還是要由函式呼叫來完成，而且巨集定義所佔用的目的碼空間相對較大。所以在使用時要依據具體情況來決定是否使用巨集定義。

4 結語
    本文對C語言中巨集定義#define在使用時容易出現的問題進行了解析，並從C源程式處理過程的角度對#define的處理進行了分析，也對它的優點進行 了闡述。只要能夠理解巨集展開的規則，掌握使用巨集定義時，是在預處理階段對源程式進行替換，只是用對應的字串替換程式中出現的巨集名，這樣就可在正確使用的 基礎上充分享受使用巨集定義帶來的方便和效率了

二、define中的三個特殊符號：#，##，#@

1. #define Conn(x,y) x##y
   
2. #define ToChar(x) #@x
   
3. #define ToString(x) #x

(1)x##y表示什麼？表示x連線y，舉例說：

1. int n = Conn(123,456); /* 結果就是n=123456;*/
   
2. char* str = Conn("asdf", "adf"); /*結果就是 str = "asdfadf";*/

（2）再來看 #@x ，其實就是給x加上單引號，結果返回是一個const char。舉例說：
char a = ToChar(1);結果就是a='1';
做個越界試驗char a = ToChar(123);結果就錯了;
但是如果你的引數超過四個字元，編譯器就給給你報錯了！ error C2015: too many characters in constant   ：P
(3）最後看看#x,估計你也明白了，他是給x加雙引號
char* str = ToString(123132);就成了str="123132";
三、常用的一些巨集定義
1 防止一個頭檔案被重複包含 

1. #ifndef BODYDEF_H 
   
2. #define BODYDEF_H 
   
3.  //標頭檔案內容 
   
4. 
   
5. #endif

  2 得到指定地址上的一個位元組或字

1. #define MEM_B( x ) ( *( (byte *) (x) ) ) 
   
2. #define MEM_W( x ) ( *( (word *) (x) ) )

用法如下：

1. #include <iostream>
   
2. #include <windows.h>
   
3. 
   
4. #define MEM_B(x) (*((byte*)(x)))
   
5. #define MEM_W(x) (*((WORD*)(x)))
   
6. 
   
7. int main()
   
8. {
   
9.     int bTest = 0x123456;
   
10. 
    
11.     byte m = MEM_B((&bTest));/*m=0x56*/
    
12.     int n = MEM_W((&bTest));/*n=0x3456*/
    
13. 
    
14.     return 0;
    
15. }

3 得到一個field在結構體(struct)中的偏移量
 

1. #define OFFSETOF( type, field ) ( (size_t) &(( type *) 0)-> field )

     請參考文章：詳解寫巨集定義：得到一個field在結構體（struct type）中的偏移量。
4 得到一個結構體中field所佔用的位元組數 

1. #define FSIZ( type, field ) sizeof( ((type *) 0)->field )

5 得到一個變數的地址（word寬度） 

1. #define B_PTR( var ) ( (byte *) (void *) &(var) ) 
   
2. #define W_PTR( var ) ( (word *) (void *) &(var) )

6 將一個字母轉換為大寫

1. #define UPCASE( c ) ( ((c) >= ''a'' && (c) <= ''z'') ? ((c) - 0x20) : (c) )

7 判斷字元是不是10進值的數字

1. #define DECCHK( c ) ((c) >= ''0'' && (c) <= ''9'')

8 判斷字元是不是16進值的數字 

1. #define HEXCHK( c ) ( ((c) >= ''0'' && (c) <= ''9'') ||((c) >= ''A'' && (c) <= ''F'') ||((c) >= ''a'' && (c) <= ''f'') )

9 防止溢位的一個方法

1. #define INC_SAT( val ) (val = ((val)+1 > (val)) ? (val)+1 : (val))

10 返回陣列元素的個數 

1. #define ARR_SIZE( a ) ( sizeof( (a) ) / sizeof( (a[0]) ) )

11 使用一些巨集跟蹤除錯
ANSI標準說明了五個預定義的巨集名。它們是： 

1. _LINE_ /*(兩個下劃線)，對應%d*/
   
2. _FILE_ /*對應%s*/
   
3. _DATE_ /*對應%s*/
   
4. _TIME_ /*對應%s*/

巨集定義

　　巨集定義是C提供的三種預處理功能的其中一種，這三種預處理包括：巨集定義、檔案包含、條件編譯。

1.不帶引數的巨集定義：

　　巨集定義又稱為巨集代換、巨集替換，簡稱“巨集”。

 　  格式：  　    #define識別符號 字串  　   其中的識別符號就是所謂的符號常量，也稱為“巨集名”。  　   預處理（ 預編譯）工作也叫做巨集展開：將巨集名替換為字串。  　   掌握"巨集"概念的關鍵是“換”。一切以換為前提、做任何事情之前先要換，準確理解之前就要“換”。        即在對相關命令或語句的含義和功能作具體分析之前就要換： 　　例：  　　#define PI  3.1415926  　　把程式中出現的PI全部換成3.1415926  　　說明：  　　（1）巨集名一般用大寫。 　　 （2） 使用巨集可提高程式的通用性和易讀性，減少不一致性，減少輸入錯誤和便於修改。例如：陣列大小常用巨集定義。 　　 （3）預處理是在編譯之前的處理，而編譯工作的任務之一就是語法檢查，預處理不做語法檢查。  　　（4）巨集定義末尾不加分號。  　　（5）巨集定義寫在函式的花括號外邊，作用域為其後的程式，通常在檔案的最開頭。  　　（6）可以用 #undef命令終止巨集定義的作用域。  　　（7）巨集定義可以巢狀。  　　（8）字串" "中永遠不包含巨集。  　　（9）巨集定義不分配記憶體，變數定義分配記憶體。  　　（10）巨集定義不存在型別問題，它的引數也是無型別的。

2.帶引數的巨集定義：

　　除了一般的字串替換，還要做引數代換 　　格式：  　  #define 巨集名（引數表） 字串  　  例如：#define S(a,b) a*b 　　area=S(3,2)；第一步被換為area=a*b; ，第二步被換為area=3*2; 　　類似於函式呼叫，有一個啞實結合的過程：
　 　（1）實參如果是表示式容易出問題
　　　　#define S(r) r*r
　　　　area=S(a+b);第一步換為area=r*r;第二步被換為area=a+b*a+b;
　　　　正確的巨集定義是#define S(r) ((r)*(r))
　　（2）巨集名和引數的括號間不能有空格。
　　 （3）巨集替換隻作替換，不做計算，不做表示式求解。
　　 （4）函式呼叫在編譯後程序執行時進行，並且分配記憶體。巨集替換在編譯前進行，不分配記憶體。
　　 （5）巨集的啞實結合不存在型別，也沒有型別轉換。
　　（6）函式只有一個返回值，利用巨集則可以設法得到多個值。
　 　（7）巨集展開使源程式變長，函式呼叫不會。    　（8）巨集展開不佔執行時間，只佔編譯時間，函式呼叫佔執行時間（分配記憶體、保留現場、值傳遞、返回值）。