C++宏定義

1.不帶參數的宏定義：

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

　　格式：

　　#define 辨別符 字元串

　　其中的辨別符就是所謂的符号常量，也稱為“宏名”。

　　預處理（預編譯）工作也叫做宏展開：将宏名替換為字元串。

　　掌握"宏"概念的關鍵是“換”。一切以換為前提、做任何事情之前先要換，準确了解之前就要“換”。

　　即在對相關指令或語句的含義和功能作具體分析之前就要換：

　　例：

　　#define PI 3.1415926

　　把程式中出現的PI全部換成3.1415926

　　說明：

　　（1）宏名一般用大寫

　　（2）使用宏可提高程式的通用性和易讀性，減少不一緻性，減少輸入錯誤和便于修改。例如：數組大小常用宏定義

　　（3）預處理是在編譯之前的處理，而編譯工作的任務之一就是文法檢查，預處理不做文法檢查。

　　（4）宏定義末尾不加分号；

　　（5）宏定義寫在函數的花括号外邊，作用域為其後的程式，通常在檔案的最開頭。

　　（6）可以用#undef指令終止宏定義的作用域

　　（7）宏定義可以嵌套

　　（8）字元串" "中永遠不包含宏

　　（9）宏定義不配置設定記憶體，變量定義配置設定記憶體。

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）宏展開不占運作時間，隻占編譯時間，函數調用占運作時間（配置設定記憶體、保留現場、值傳遞、傳回值）

3.技巧：

 #define用法

　　1、 用無參宏定義一個簡單的常量

　　#define LEN 12

　　這個是最常見的用法，但也會出錯。

　　比如下面幾個知識點你會嗎？可以看下：

　　（1） #define NAME "zhangyuncong"

　　程式中有"NAME"則，它會不會被替換呢？

　　（2） #define 0x abcd

　　可以嗎？也就是說，可不可以用把辨別符的字母替換成别的東西？

　　（3） #define NAME "zhang

　　這個可以嗎？

　　（4） #define NAME "zhangyuncong"

　　程式中有上面的宏定義，并且，程式裡有句：

　　NAMELIST這樣，會不會被替換成"zhangyuncong"LIST

　　四個題答案都是否定的。

　　第一個，""内的東西不會被宏替換。這一點應該大都知道。

　　第二個，宏定義前面的那個必須是合法的使用者辨別符

　　第三個，宏定義也不是說後面東西随便寫，不能把字元串的兩個""拆開。

　　第四個：隻替換辨別符，不替換别的東西。NAMELIST整體是個辨別符，而沒有NAME辨別符，是以不替換。

　　也就是說，這種情況下記住：#define 第一位置第二位置

　　（1） 不替換程式中字元串裡的東西。

　　（2） 第一位置隻能是合法的辨別符（可以是關鍵字）

　　（3） 第二位置如果有字元串，必須把""配對。

　　（4） 隻替換與第一位置完全相同的辨別符

　　還有就是老生常談的話：記住這是簡單的替換而已，不要在中間計算結果，一定要替換出表達式之後再算。

　　2、 帶參宏一般用法

　　比如#define MAX(a,b) ((a)>(b)?(a):(b))

　　則遇到MAX(1+2,value)則會把它替換成：

　　((1+2)>(value)?(1+2):(value))

　　注意事項和無參宏差不多。

　　但還是應注意

　　#define FUN(a) "a"

　　則，輸入FUN(345)會被替換成什麼？

　　其實，如果這麼寫，無論宏的實參是什麼，都不會影響其被替換成"a"的命運。

　　也就是說，""内的字元不被當成形參，即使它和一模一樣。

　　那麼，你會問了，我要是想讓這裡輸入FUN(345)它就替換成"345"該怎麼實作呢？

　　請看下面關于#的用法

　　3、 有參宏定義中#的用法

　　#define STR(str) #str

　　#用于把宏定義中的參數兩端加上字元串的""

　　比如，這裡STR(my#name)會被替換成"my#name"

　　一般由任意字元都可以做形參，但以下情況會出錯：

　　STR())這樣，編譯器不會把“)”當成STR()的參數。

　　STR(,)同上，編譯器不會把“,”當成STR的參數。

　　STR(A,B)如果實參過多，則編譯器會把多餘的參數舍去。（VC++2008為例）

　　STR((A,B))會被解讀為實參為：(A,B)，而不是被解讀為兩個實參，第一個是(A第二個是B)。

　　4、 有參宏定義中##的用法

　　#define WIDE(str) L##str

　　則會将形參str的前面加上L

　　比如：WIDE("abc")就會被替換成L"abc"

　　如果有#define FUN(a,b) vo##a##b()

　　那麼FUN(id ma,in)會被替換成void main()

　　5、 多行宏定義：

　　#define doit(m,n) for(int i=0;i<(n);++i)\

　　{\

　　m+=i;\

　　}

4.宏中"#"和"##"的用法：

       一、一般用法

我們使用#把宏參數變為一個字元串,用##把兩個宏參數貼合在一起.

用法:

#include<cstdio>

#include<climits>

using namespace std;

#define STR(s)     #s

#define CONS(a,b)  int(a##e##b)

int main()

{

    printf(STR(vck));           // 輸出字元串"vck"

    printf("%d/n", CONS(2,3));  // 2e3 輸出:2000

    return 0;

}

        二、當宏參數是另一個宏的時候

需要注意的是凡宏定義裡有用'#'或'##'的地方宏參數是不會再展開.

1, 非'#'和'##'的情況

#define TOW      (2)

#define MUL(a,b) (a*b)

printf("%d*%d=%d/n", TOW, TOW, MUL(TOW,TOW));

這行的宏會被展開為：

printf("%d*%d=%d/n", (2), (2), ((2)*(2)));

MUL裡的參數TOW會被展開為(2).

2, 當有'#'或'##'的時候

#define A          (2)

printf("int max: %s/n",  STR(INT_MAX));    // INT_MAX #include<climits>

這行會被展開為：

printf("int max: %s/n", "INT_MAX");

printf("%s/n", CONS(A, A));               // compile error 

這一行則是：

printf("%s/n", int(AeA));

INT_MAX和A都不會再被展開, 然而解決這個問題的方法很簡單. 加多一層中間轉換宏.

加這層宏的用意是把所有宏的參數在這層裡全部展開, 那麼在轉換宏裡的那一個宏(_STR)就能得到正确的宏參數.

#define A           (2)

#define _STR(s)     #s

#define STR(s)      _STR(s)          // 轉換宏

#define _CONS(a,b)  int(a##e##b)

#define CONS(a,b)   _CONS(a,b)       // 轉換宏

printf("int max: %s/n", STR(INT_MAX));          // INT_MAX,int型的最大值,為一個變量 #include<climits>

輸出為: int max: 0x7fffffff

STR(INT_MAX) -->  _STR(0x7fffffff) 然後再轉換成字元串;

printf("%d/n", CONS(A, A));

輸出為：200

CONS(A, A)  -->  _CONS((2), (2))  --> int((2)e(2))

        三、'#'和'##'的一些應用特例

1、合并匿名變量名

#define  ___ANONYMOUS1(type, var, line)  type  var##line

#define  __ANONYMOUS0(type, line)  ___ANONYMOUS1(type, _anonymous, line)

#define  ANONYMOUS(type)  __ANONYMOUS0(type, __LINE__)

例：ANONYMOUS(static int);  即: static int _anonymous70;  70表示該行行号;

第一層：ANONYMOUS(static int);  -->  __ANONYMOUS0(static int, __LINE__);

第二層：                        -->  ___ANONYMOUS1(static int, _anonymous, 70);

第三層：                        -->  static int  _anonymous70;

即每次隻能解開目前層的宏,是以__LINE__在第二層才能被解開;

2、填充結構

#define  FILL(a)   {a, #a}

enum IDD{OPEN, CLOSE};

typedef struct MSG{

  IDD id;

  const char * msg;

}MSG;

MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};

相當于：

MSG _msg[] = {{OPEN, "OPEN"},

              {CLOSE, "CLOSE"}};

3、記錄檔案名

#define  _GET_FILE_NAME(f)   #f

#define  GET_FILE_NAME(f)    _GET_FILE_NAME(f)

static char  FILE_NAME[] = GET_FILE_NAME(__FILE__);

4、得到一個數值類型所對應的字元串緩沖大小

#define  _TYPE_BUF_SIZE(type)  sizeof #type

#define  TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type)

char  buf[TYPE_BUF_SIZE(INT_MAX)];

     -->  char  buf[_TYPE_BUF_SIZE(0x7fffffff)];