C++宏定義詳解

1、#define的基本用法

    #define是C語言中提供的宏定義命令，其主要目的是爲程序員在編程時提供必定的方便，並能在必定程度上提升程序的運行效率，但學生在學習時每每不能 理解該命令的本質，老是在此處產生一些困惑，在編程時誤用該命令，使得程序的運行與預期的目的不一致，或者在讀別人寫的程序時，把運行結果理解錯誤，這對 C語言的學習很不利。

1　#define命令剖析

1.1   #define的概念

    #define命令是C語言中的一個宏定義命令，它用來將一個標識符定義爲一個字符串，該標識符被稱爲宏名，被定義的字符串稱爲替換文本。
該命令有兩種格式：一種是簡單的宏定義，另外一種是帶參數的宏定義。

(1)簡單的宏定義：

#define <宏名>　　<字符串>
例： #define PI 3.1415926

(2) 帶參數的宏定義
 

#define <宏名> (<參數表>) <宏體>
例： #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 #define N 2+2
void main()
{
   int a=N*N;
   printf(「%d」,a);
}

    (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)解決辦法：

 

/*將宏定義寫成以下形式*/
#define N (2+2)
/*這樣就可替換成(2+2)*(2+2)=16*/

2.2 帶參數的宏定義出現的問題

    在帶參數的宏定義的使用中，極易引發誤解。例如咱們須要作個宏替換能求任何數的平方，這就須要使用參數，以便在程序中用實際參數來替換宏定義中的參數。通常學生容易寫成以下形式：

#define area(x) x*x
/*這在使用中是很容易出現問題的，看以下的程序*/

void main()
{
    int y = area(2+2);
    printf(「%d」,y);
}

    按理說給的參數是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語言中用宏定義的好處吧。

如：

#include <iostream.h>
#define product(x)    x*x
int main()
{
    int i=3;
    int j,k;
    j = product(i++);
    cout<<"j="<<j<<endl;
    cout<<"i="<<i<<endl;
    k = product(++i);
    cout<<"k="<<k<<endl;
    cout<<"i="<<i<<endl;
    return 0;
}

依次輸出結果：

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的處理進行了分析，也對它的優勢進行 了闡述。只要可以理解宏展開的規則，掌握使用宏定義時，是在預處理階段對源程序進行替換，只是用對應的字符串替換程序中出現的宏名，這樣就可在正確使用的 基礎上充分享受使用宏定義帶來的方便和效率了

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

 

#define Conn(x,y) x##y
#define ToChar(x) #@x
#define ToString(x) #x

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

int n = Conn(123,456); /* 結果就是n=123456;*/
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";

3、經常使用的一些宏定義

1 防止一個頭文件被重複包含

#ifndef BODYDEF_H
#define BODYDEF_H
 //頭文件內容

#endif

 

2 獲得指定地址上的一個字節或字

 

#define MEM_B( x ) ( *( (byte *) (x) ) )
#define MEM_W( x ) ( *( (word *) (x) ) )

用法以下：

#include <iostream>
#include <windows.h>

#define MEM_B(x) (*((byte*)(x)))
#define MEM_W(x) (*((WORD*)(x)))

int main()
{
    int bTest = 0x123456;

    byte m = MEM_B((&bTest));/*m=0x56*/
    int n = MEM_W((&bTest));/*n=0x3456*/

    return 0;
}

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

 

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

    請參考文章：詳解寫宏定義：獲得一個field在結構體（struct type）中的偏移量。

4 獲得一個結構體中field所佔用的字節數

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

5 獲得一個變量的地址（word寬度）

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

6 將一個字母轉換爲大寫

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

7 判斷字符是否是10進值的數字

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

8 判斷字符是否是16進值的數字

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

9 防止溢出的一個方法

 

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

10 返回數組元素的個數

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

11 使用一些宏跟蹤調試

ANSI標準說明了五個預約義的宏名。它們是：

_LINE_ /*(兩個下劃線)，對應%d*/
_FILE_ /*對應%s*/
_DATE_ /*對應%s*/
_TIME_ /*對應%s*/