宏定義及相關用法

歡迎各位補充

目錄

• 一些成熟軟件中常用的宏定義：
• 使用一些內置宏跟蹤調試：
• 宏定義防止使用時錯誤：
• 宏與函數
  • 帶副作用的宏參數
• 特殊符號：’#’、’##’
  • 1、一般用法
  • 2、當宏參數是另一個宏的時候
• __VA_ARGS__與##__VA_ARGS__

一些成熟軟件中常用的宏定義：

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

#ifndef COMDEF_H #define COMDEF_H//頭文件內容 … #endif

2，重新定義一些類型，防止由于各種平臺和編譯器的不同，而產生的類型字節數差異，方便移植。

typedef unsigned long int uint32; /* Unsigned 32 bit value */

3，得到指定地址上的一個字節或字

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

4，求最大值和最小值

#define MAX( x, y ) ( ((x) > (y)) ? (x) : (y) ) #define MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )

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

#define FPOS( type, field ) ( (dword) &(( type *) 0)-> field )

6, 得到一個結構體中field所占用的字節數

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

7，按照LSB格式把兩個字節轉化為一個word

#define FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )

8，按照LSB格式把一個word轉化為兩個字節

#define FLOPW( ray, val ) \ (ray)[0] = ((val) / 256); \ (ray)[1] = ((val) & 0xFF)

9，得到一個變量的地址（word寬度）

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

10，得到一個字的高位和低位字節

#define WORD_LO(xxx) ((byte) ((word)(var) & 255)) #define WORD_HI(xxx) ((byte) ((word)(var) >> 8))

11，返回一個比X大的最接近的8的倍數

#define RND8( x ) ((((x) + 7) / 8 ) * 8 )

12，將一個字母轉換為大寫

#define UPCASE( ch ) ( ((ch) >= ’a' && (ch) <= ’z') ? ((ch) - 0×20) : (ch) )

13，判斷字符是不是10進值的數字

#define DECCHK( ch ) ((ch) >= ’0′ && (ch) <= ’9′)

14，判斷字符是不是16進值的數字

#define HEXCHK( ch ) \ (((ch) >= ’0′ && (ch) <= ’9′) || \ ((ch) >= ’A' && (ch) <= ’F') || \ ((ch) >= ’a' && (ch) <= ’f') )

15，防止溢出的一個方法

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

16，返回數組元素的個數

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

17，對于IO空間映射在存儲空間的結構，輸入輸出處理

#define inp(port) (*((volatile byte *) (port))) #define inpw(port) (*((volatile word *) (port))) #define inpdw(port) (*((volatile dword *)(port)))#define outp(port, val) (*((volatile byte *) (port)) = ((byte) (val))) #define outpw(port, val) (*((volatile word *) (port)) = ((word) (val))) #define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))

18，字符串拼接打印日志
兩個相鄰字符串會被拼接成一個字符串的技巧。每行都需要使用雙引號將字符串引起來再加反斜杠，否則字符串將會把每一行前面的空格包含進去。

#define DEBUG_PRINT printf("File %s line %d :"\"x=%d,y=%d,z=%d",\__FILE__,__LINE,x,y,z)

---

使用一些內置宏跟蹤調試：

ANSI標準定義了幾個個預定義的宏名。它們包括但不止于：

__LINE__ __FILE__ __DATE__ __TIME__ __STDC__

注： 常用的還有__FUNCTION__等【非標準】，詳細信息可查看： Predefined Macros，如果編譯不是標準的，則可能僅支持以上宏名中的幾個，或根本不支持。記住編譯程序 也許還提供其它預定義的宏名。可以定義宏，例如:當定義了_DEBUG，輸出數據信息和所在文件所在行

#ifdef _DEBUG #define DEBUGMSG(msg,date) printf(msg);printf("%d%d%d", date, __LINE__, __FILE__) #else #define DEBUGMSG(msg,date) #endif

---

宏定義防止使用時錯誤：

用小括號包含。

//例如： #define ADD(a,b) （(a)+(b)）

用do{}while(0)語句包含多語句防止錯誤（注意while(0)后無分號）.

//例如： #difne DO(a,b) a+b; a++; //應寫成： #difne DO(a,b) do{a+b; a++;}while(0)

為什么需要do{…}while(0)形式?大致有以下幾個原因：

• 空的宏定義避免warning:
  #define foo() do{}while(0)

• 存在一個獨立的block，可以用來進行重復性變量定義，進行比較復雜的實現。

• 如果出現在判斷語句過后的宏，這樣可以保證作為一個整體來是實現：

#define foo(x) action1(); action2(); //在以下情況下： if(NULL == pPointer)foo(); //就會出現action2必然被執行的情況，而這顯然不是程序設計的目的。

• 以上的第3種情況用單獨的{}也可以實現，但是為什么一定要一個do{}while(0)呢，看以下代碼：

#define switch(x,y) {int tmp; tmp=x;x=y;y=tmp;} if(x>y)switch(x,y); else //error, parse error before elseotheraction();

在把宏引入代碼中，會多出一個分號，從而會報錯。使用do{….}while(0) 把它包裹起來，成為一個獨立的語法單元，從而不會與上下文發生混淆。同時因為絕大多數的編譯器都能夠識別do{…}while(0)這種無用的循環并進行優化，所以使用這種方法也不會導致程序的性能降低，【但是并非所有情況都用這種形式，有些情況不需要，有些情況則不能夠夠】。

---

宏與函數

宏相比函數而言的優勢主要在于：

宏因為是文本替換，沒有函數棧的維護代價

宏參數不帶類型，可以做函數不能做的工作。

解釋一下，第一點 函數調用是利用函數棧幀來實現的，這個需要一定的系統資源。但是宏是直接文本替換，無函數調用過程。
第二點是因為函數的參數列表要求每個參數必須帶類型，宏不需要（亦可代替函數重載），當我們想實現把類型也當作參數傳入時，函數是無法做到。例如下面的宏：

#define MALLOC(size,type) ((type*)malloc(sizeof(type) * (size))) int * p = MALLOC(10, int);

這個宏有點厲害了，傳入大小和類型兩個參數，然后動態分配出所需要的內存。這個肯定是無法用函數實現的。這個是不是與 C++ 的模版有點相像？模版能夠實現的技術基礎就是能夠把參數類型當作一種參數，而宏正好就支持！！！

然而，宏的文本替換大法這么厲害，為什么還會有函數的存在嘞？
最主要的原因是：宏的文本替換大法在處理帶副作用的宏參數時會導致不可預料的后果。

帶副作用的宏參數

什么叫帶副作用的宏參數？副作用是指某些運算符在求值的同時也會永久地改變操作數，比如：i+1

這個表達式求值沒有副作用，這個式子不管運算多少次，式子的值不變。但是：
++i

卻不一樣了，它運算 100 次與運算 1 次的結果是不一樣的，因為每次運算都會永久改變 i 的值。

那當副作用遇上宏參數會發生什么呢？看一個經典例子：

#define MAX(a,b) ((a)>(b)?(a):(b)) int a = 0; int b = 1; int c = MAX(a++, b++);

根據宏替換大法，我們看c被預編譯器處理后的樣子：

int c = ((a++)>(b++)?(a++):(b++));

ok，副作用一目了然。因為 a++

int max(a, b) {return a>b?a:b; } int a = 0; int b = 1; int c = max(a++, b++);

這么執行的結果就是
c = 1,a = 1,b = 2;

這是我們想要的。
上面兩者的區別在于，使用函數時，只在參數列表里面進行一次帶副作用的運算；使用宏時，在宏的列表，宏的內容都執行了帶副作用的運算。而我們通常只希望副作用運算執行一次。

---

特殊符號：’#’、’##’

1、一般用法

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

＃include<cstdio> ＃include<climits> using namespace std;#define STR(s) #s #define CONS(a,b) int(a##e##b)int main() {// 輸出字符串vckprintf(STR(vck)); // 2e3 輸出:2000，科學計數法printf("%d\n", CONS(2,3)); return 0; }

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

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

沒有’#'和’##’的情況

#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).

當有’#'或’##’的時候

#define A (2) #define STR(s) #s #define CONS(a,b) int(a##e##b) printf("int max: %s\n", STR(INT_MAX)); // INT_MAX ＃include<climits> printf("%s\n", CONS(A, A)); // compile error

第一個 printf() 這行會被展開為：
printf(“int max: %s\n”, #INT_MAX);

第二個 printf() 則是：
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: 0x7fffffff STR(INT_MAX) –> _STR(0x7fffffff) 然后再轉換成字符串；printf("%d\n", CONS(A, A)); 輸出為：200 CONS(A, A) –> _CONS((2), (2)) –> int((2)e(2))

’#'和’##’的一些應用特例：

合并匿名變量名，例：

#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__在第二層才能被解開；

填充結構

#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“} };

記錄文件名

#define _GET_FILE_NAME(f) #f #define GET_FILE_NAME(f) _GET_FILE_NAME(f) static char FILE_NAME[] = GET_FILE_NAME(__FILE__);

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

#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”)]; char buf[sizeof “0x7fffffff”]; 這里相當于： char buf[11];

---

__VA_ARGS__與##__VA_ARGS__

\_\_VA_ARGS__ 是一個可變參數的宏，很少人知道這個宏，這個可變參數的宏是新的 C99 規范中新增的，目前似乎只有 gcc 支持（VC6.0的編譯器不支持）。實現思想就是宏定義中參數列表的最后一個參數為省略號（也就是三個點）。
##\_\_VA_ARGS__ 宏，在 \_\_VA_ARGS__ 前面加上 ## 的作用在于，當可變參數的個數為0時，這里的 ## 起到把前面多余的逗號去掉的作用,否則會編譯出錯。

總結

以上是生活随笔為你收集整理的宏定义及相关用法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。