#define命令是C語言中的一個宏定義命令，它用來將一個標識符定義為一個字符串，該標識符被稱為宏名，被定義的字符串稱為替換文本。
定義宏的作用一般是用一個短的名字代表一個長的字符串。
主要參考與：https://www.cnblogs.com/fnlingnzb-learner/p/6903966.html
一、一般形式為：
1）#define 標識符 字符串
這就是已經介紹過的定義符號常量。
如：#define PI 3.1415926
2）還可以用#define命令定義帶參數的宏定義。其定義的一般形式為：
#define 宏名(參數表) 字符串
如：#define S(a, b) a*b //定義宏S(矩形面積)，a､b為宏的參數
使用的形式如下：
area=S(3, 2);
用3､2分別代替宏定義中的形式參數a和b，即用3*2代替S(3, 2)。因此賦值語句展開為：
area=3*2;
由於C++增加了內置函數(inline)，比用帶參數的宏定義更方便，因此在C++中基本上已不再用#define命令定義宏了，主要用於條件編譯中。
二、帶參數的宏替換最好加括號，否則可能會出錯
需要注意的就是在涉及運算或着其他一些情況下，要加上括號來避免結合律影響運算結果
如：
#define add(x, y) (x + y)
5*add(2,3)，你期望的結果是25,但是，在不加括號的情況下 5*2+3 結果是30.
三、一個標識符被宏定義后，該標識符便是一個宏名。這時，在程序中出現的是宏名，在該程序被編譯前，先將宏名用被定義的字符串替換，這稱為宏替換，替換后才進行編譯，宏替換是簡單的替換。
四、當需要換行時，需要在行尾加上\ 比如：
1 #define NULL_RETURN(varName) \
2 if(varName == nullptr) \
3 { \
4 return;\
5 } //程序的結束處，即最后不用加符號 \
五、宏替換發生的時機
為了能夠真正理解#define的作用，讓我們來了解一下對C語言源程序的處理過程。當我們在一個集成的開發環境如Turbo C中將編寫好的源程序進行編譯時，實際經過了預處理、編譯、匯編和連接幾個過程。其中預處理器產生編譯器的輸出，它實現以下的功能：
（1）文件包含
可以把源程序中的#include 擴展為文件正文，即把包含的.h文件找到並展開到#include 所在處。
（2）條件編譯
預處理器根據#if和#ifdef等編譯命令及其后的條件，將源程序中的某部分包含進來或排除在外，通常把排除在外的語句轉換成空行。
（3）宏展開
預處理器將源程序文件中出現的對宏的引用展開成相應的宏 定義，即本文所說的#define的功能，由預處理器來完成。
經過預處理器處理的源程序與之前的源程序有所有不同，在這個階段所進行的工作只是純粹的替換與展開，沒有任何計算功能，所以在學習#define命令時只要能真正理解這一點，這樣才不會對此命令引起誤解並誤用。
六、#define使用中的常見問題解析
1. 簡單宏定義使用中出現的問題
例1 #define N 2+2
void main()
{
int a=N*N;
printf(“%d”,a);
}
- /*將宏定義寫成如下形式*/
- #define N (2+2)
- /*這樣就可替換成(2+2)*(2+2)=16*/
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))，不要覺得這沒必要，沒有它，是不行的。
如果是自己編程使用宏替換，則在使用簡單宏定義時，當字符串中不只一個符號時，加上括號表現出優先級，如果是帶參數的宏定義，則要給宏體中的每個參數加上括號，並在整個宏體上再加一個括號。
七、幾個實例
1. 現在定義有以下一個計算 “乘法” 的宏
#include <stdio.h>
#define MUL(a) ((a)*(a)*(a))
int main(int argc,char *argv[])
{
int i = 10;
int sum = MUL(i);
printf("MUL(%d) = %d\n",i,sum);
return 0;
}
上面程序的這種做法對於非負數而言那就是沒有問題的，比如，程序中的 變量 i=10，這個時候，調用宏得到的數據如下：
MUL(10)=1000
但是如何變量的數值是自加或者自減的操作的話，結果就不一樣了。
1）int sum = MUL(i++);
得到的結果並不是 11 * 11 *11 = 1331這個數據，而是 1872。
當使用了 ++i 和 i++ 的時候，要特別注意在宏中是全部使用 ++i或者i++的，變成的格式如下
MUL（i++) ((i++)*(i++)*(i++))
MUL(++i) ((++i)*(++i)*(++i))
當 i = 10的時候，MUL(i++)就是為 (i++)*(i++)*(i++)的計算結果，考慮到C/C++的運算符結合性，先計算第一個 i++，這是一個先計算后賦值的自加方式，那么這是后第一個 (i++)的數值待定為 10 ，那么第二個的i是因為第一個數據的 (i++)起了作用而變化的，這時候第二個(i++)的數值為11，然后加1,這時候 根據結合性，先計算前面兩個數據，就是(i++) * (i++)的數值了，即為：10 * 11了，這時候的i數值是 12；然后計算第三個 i++的數值，這時候第三個i++中的i數值為 12，計算后再加1，也就是說，10 * 11 * 12之后，i= 12 的數值在進行i++變為 13了。所以 MUL(i++) = 10 * 11 * 12 = 1320。
2）int sum = MUL(++i);
MUL(++i) ((++i)*(++i)*(++i))
當 i = 10的時候，MUL(++i)實際上也為 (++i)*(++i)*(++i)的方式，這時候先計算第一個 (++i),這是一個先計算后賦值的結合方式，那么 i = i+1 = 11；這時候准備計算第二個(++i)的時候，因為需要先計算后賦值，所以第二個 ++i 之后的數值為12，但是因為i屬於同一個變量和屬性，那么第一個i也會變成 12了，這時候結合性考慮應該是計算前兩個(++i)的結果，再與第三個(++i)計算，即(++i)*(++i) = 12 * 12;然后，我們計算第三個(++i)的數值，由於前面第二個++i的i值，所以第三個++i即為 13，此時，12 * 12 * 13。
注意計算順序：先計算前兩個括號內的運算，然后再計算前兩個括號的相乘結果。
有人可能顧慮，為什么最后不是13 * 13 * 13的呢？那不是最后都是13嗎？？ ------》其實這種想法是錯誤的，這必須先理解運算符的結合性。我們知道，當計算中遇到了括號的時候，我們先計算括號的內容，這是我們在數學中的慣性思維。但是對於計算機而言，計算機必須 有計算的優先級，也就是運算符的優先級問題。首先我們計算前面兩個括號的內容，因為兩個括號之間有乘號(*)，所以計算前面兩個(++i)之后，必須進行乘法計算，這就是優先級中的乘法計算，自左向右計算。所以結果變為了 12 * 12的最終結果在和第三個括號的(++i)計算，就是144 * (++ i) = 144 * 13;所以MUL(++i)的結果如下：
MUL(++i)=12*12*13=1872
慎用宏在計算方面的，但是宏的有點還是很多的，對於C語言來說，宏可以減少運行的時間。在C++中，宏由於不會對類型進行檢查，安全性不夠，所以建議使用const來進行使用，這樣可以保證類型一致。
2. 求輸出結果
#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;
}
八、宏定義的優點
使用簡單宏定義可 用宏代替一個在程序中 經常使用的常量，這樣在將該常量改變時，不用對整個程序進行修改，只修改宏定義的字符串即可，而且當 常量比較長時， 我們可以 用較短的有意義的標識符來寫程序，這樣更方便一些。我們所說的常量改變不是在程序運行期間改變，而是在編程期間的修改，舉一個大家比較熟悉的例子，圓周率π是在數學上常用的一個值，有時我們會用3.14來表示，有時也會用3.1415926等，這要看計算所需要的精度，如果我們編制的一個程序中 要多次使用它，那么需要確定一個數值，在本次運行中不改變，但也許后來發現程序所表現的精度有變化，需要改變它的值， 這就需要修改程序中所有的相關數值，這會給我們帶來一定的不便，但如果使用宏定義，使用一個標識符來代替，則在修改時只修改宏定義即可，還可以減少輸入 3.1415926這樣長的數值多次的情況，我們可以如此定義 #define pi 3.1415926，既減少了輸入又便於修改，何樂而不為呢？
(2) 提高程序的運行效率
使用帶參數的宏定義可完 成函數調用的功能，又能 減少系統開銷， 提高運行效率。正如C語言中所講，函數的使用可以使程序更加模塊化，便於組織，而且可重復利用， 但在發生函數調用時，需要保留調用函數的現場，以便子 函數執行結束后能返回繼續執行，同樣在子函數執行完后要恢復調用函數的現場，這都需要一定的時間，如果子函數執行的操作比較多，這種轉換時間開銷可以忽略，但如果子函數完成的功能比較少，甚至於只完成一點操作，如一個乘法語句的操作，則這部分轉換開銷就相對較大了，但使用帶參數的宏定義就不會出現這個問題， 因為它是在預處理階段即進行了宏展開，在執行時不需要轉換，即在當地執行。 宏定義可完成簡單的操作，但復雜的操作還是要由函數調用來完成，而且宏定義所占用的目標代碼空間相對較大。所以在使用時要依據具體情況來決定是否使用宏定義。
九、對於宏定義還要說明以下幾點：
-
宏定義是用宏名來表示一個字符串，在宏展開時又以該字符串取代宏名，這只是一種簡單的代換，字符串中可以含任何字符，可以是常數，也可以是表達式，預處理程序對它不作任何檢查。如有錯誤，只能在編譯已被宏展開后的源程序時發現。
-
宏定義不是說明或語句，在行末不必加分號，如加上分號則連分號也一起置換。
- 宏定義必須寫在函數之外，其作用域為宏定義命令起到源程序結束。如要終止其作用域可使用# undef命令。
- 宏名在源程序中若用引號括起來，則預處理程序不對其作宏代換。
- 宏定義允許嵌套，在宏定義的字符串中可以使用已經定義的宏名。在宏展開時由預處理程序層層代換。
- 習慣上宏名用大寫字母表示，以便於與變量區別。但也允許用小寫字母。
- 可用宏定義表示數據類型，使書寫方便。如：#define STU struct stu 在程序中可用STU作變量說明：STU body[5],*p;
- 對“輸出格式”作宏定義，可以減少書寫麻煩。
#define P printf
#define D "%d\n"
#define F "%f\n"
main(){
int a=5, c=8, e=11;
float b=3.8, d=9.7, f=21.08;
P(D F,a,b);
P(D F,c,d);
P(D F,e,f);
}
注意用宏定義表示數據類型和用typedef定義數據說明符的區別：
宏定義只是簡單的字符串代換，是在預處理完成的，而typedef是在編譯時處理的，它不是作簡單的代換，而是對類型說明符重新命名。被命名的標識符具有類型定義說明的功能。
#define PIN1 int * typedef (int *) PIN2;
從形式上看這兩者相似， 但在實際使用中卻不相同。
下面用PIN1，PIN2說明變量時就可以看出它們的區別：
PIN1 a,b;在宏代換后變成:
int *a,b;
表示a是指向整型的指針變量，而b是整型變量。
PIN2 a,b;
表示a,b都是指向整型的指針變量。因為PIN2是一個類型說明符。
由這個例子可見，宏定義雖然也可表示數據類型， 但畢竟是作字符代換。在使用時要分外小心，以避出錯。
十、對於帶參的宏定義有以下問題需要說明：
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. 在帶參宏定義中，形式參數不分配內存單元，因此不必作類型定義。而宏調用中的實參有具體的值。要用它們去代換形參，因此必須作類型說明。這是與函數中的情況不同的。在函數中，形參和實參是兩個不同的量，各有自己的作用域，調用時要把實參值賦予形參，進行“值傳遞”。而在帶參宏中，只是符號代換，不存在值傳遞的問題。
3. 在宏定義中的形參是標識符，而宏調用中的實參可以是表達式。
#define SQ(y) (y)*(y)
main(){
int a,sq;
printf("input a number: ");
scanf("%d",&a);
sq=SQ(a+1);
printf("sq=%d\n",sq);
}
上例中第一行為宏定義，形參為y。程序第七行宏調用中實參為a+1，是一個表達式，在宏展開時，用a+1代換y，再用(y)*(y) 代換SQ，得到如下語句：sq=(a+1)*(a+1);
這與函數的調用是不同的，函數調用時要把實參表達式的值求出來再賦予形參。而宏代換中對實參表達式不作計算直接地照原樣代換。
4. 在宏定義中，字符串內的形參通常要用括號括起來以避免出錯。
十一、define中的三個特殊符號：#，##，#@
- #define Conn(x,y) x##y
- #define ToChar(x) #@x
- #define ToString(x) #x
- int n = Conn(123,456); /* 結果就是n=123456;*/
- char* str = Conn("asdf", "adf"); /*結果就是 str = "asdfadf";*/
做個越界試驗char a = ToChar(123);結果就錯了;
但是如果你的參數超過四個字符，編譯器就給給你報錯了！
（3）#x，給x加雙引號
char* str = ToString(123132);就成了str="123132";
十二、常用的一些宏定義
#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）中的偏移量
(type *)0：把0地址當成type類型的指針。 ((type *)0)->field：對應域的變量。 &((type *)0)->field:取該變量的地址，其實就等於該域相對於0地址的偏移量。 (size_t)&(((type *)0)->field)：將該地址（偏移量）轉化為size_t型數據。
ANSI C標准允許任何值為0的常量被強制轉換成任何一種類型的指針，並且轉換結果是一個NULL指針，因此((s*)0)的結果就是一個類型為s*的NULL指針。如果利用這個NULL指針來訪問s的成員當然是非法的，但&(((s*)0)->m)的意圖並非想存取s字段內容，而僅僅是計算當結構體實例的首址為((s*)0)時m字段的地址。聰明的編譯器根本就不生成訪問m的代碼，而僅僅是根據s的內存布局和結構體實例首址在編譯期計算這個(常量)地址，這樣就完全避免了通過NULL指針訪問內存的問題。
https://www.cnblogs.com/zhangjianlaoda/p/4356835.html
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]) ) )
注意：變量a要單獨括起來，即使sizeof調用時有括號。
11 使用一些宏跟蹤調試
ANSI標准說明了五個預定義的宏名。它們是： _LINE_ /*(兩個下划線)，對應%d*/ _FILE_ /*對應%s*/ _DATE_ /*對應%s*/ _TIME_ /*對應%s*/
參考鏈接：
https://blog.csdn.net/zhouqt/article/details/82718409
https://www.jb51.net/article/105807.htm
http://c.biancheng.net/cpp/biancheng/view/147.html
https://www.linuxidc.com/Linux/2017-02/140697.htm