宏分为两种，一种是 object-like 宏，比如:
#define STR "Hello, World!"
另一种是 function-like 宏，比如:
#define MIN(X, Y) ((X) < (Y) ? (X) : (Y))
对于 function-like 宏，定义时的参数叫 Parameters，比如上面宏 MIN 的参数 X、Y，当调用时，传递的参数叫 Arguments。
宏参数 Arguments
当给宏传递参数 Arguments 时，可以不用全部传递，比如:
MIN(a, b) -> ((a) < (b) ? (a) : (b)) // 完全传递 MIN(, b) -> (() < (b) ? () : (b)) // 只传递后一个 MIN(a, ) -> ((a) < () ? (a) : ()) // 只传递前一个 MIN(,) -> (() < () ? () :()) // 这种允许 MIN(, ,) // 报错，接收2个参数，传递了3个 MIN() // 报错，接收2个参数，传递了1个
宏参数 Arguments 的扩展
当向宏中传递参数 Arguments 时，在参数替换到宏里面之前，首先要对参数 Arguments 进行完全的扩展，当参数扩展完毕之后，才将最终扩展的结果替换到宏里面，同时再对整个宏进行扩展。比如调用宏 MIN(MIN(a, b), c)，那么首先第一个参数 MIN(a, b)要进行扩展，扩展的结果为 ((a) < (b) ? (a) : (b))，由于第2个参数 c 不用扩展，也就是第1步得到的扩展结果为:
MIN(((a) < (b) ? (a) : (b)), c)
接下来进行第2步扩展，得到的结果为:
((((a) < (b) ? (a) : (b))) < (c) ? (((a) < (b) ? (a) : (b))) : (c))
这样做的一个好处是为了防止宏的嵌套调用，比如有下面一个宏定义:
#define f(x) x
如果有如下调用 f(f(1))，假设第一步不将参数 f(1) 完全展开，就会出现 f(f(1)) 被展开为 f(1)，由于间接的自引用，宏不再继续展开，此时得到的结果就为 f(1)。而有了2步扩展，第一步参数 f(1) 被扩展成 1，然后替换后继续扩展，可以得到结果就是1。
自引用宏
一个宏在定义时，如果宏名出现在了宏定义中，那么就是一个自引用宏，比如:
#define foo (4 + foo)
如果调用这个宏 foo，按照上面两步展开的过程，那么将会是一个无限循环的过程。首先 foo 展开为 (4 + foo)，然后 （4 + foo) 中的 foo 继续展开成 (4 + foo) 成为 （4 + （4 + foo))，如此继续下去。但是实际上，对于自引用宏，只扩展1次，后面不会再做扩展，也就是说调用宏 foo，最终的扩展结果就是 (4 + foo)。
对于自引用宏的一种特殊情况就是间接自引用，比如有如下宏定义:
#define x (4 + y) #define y (2 * x)
当调用宏 x 时，首先扩展为 (4 + y)，然后对 y 进行扩展，结果为 (4 + (2 * x))，如果此时继续对 x 进行扩展，那么就会无限递归，为了处理这种情况，扩展会在这一步终止，也就是最终结果是 (4 + (2 * x))。
当调用宏 y 时一样，首先扩展为 (2 * x)，然后对 x 进行扩展，结果为 (2 * (4 + y))，扩展到这一步也会停止。
参数 Arguments 有字符串化(#)和连接(##)操作
在宏扩展过程当中，当参数 Arguments 有字符串化(#)和连接操作(##)时，参数的扩展就没有第1步。比如有下面宏定义:
#define AFTERX(x) X_ ## x
#define XAFTERX(x) AFTERX(x)
#define TABLESIZE 1024
#define BUFSIZE TABLESIZE
当调用 AFTERX(BUFSIZE) 时，由于参数 BUFSIZE 有连接操作(##)，那么它就不会继续扩展成 TABLESIZE，TABLESIZE 继续扩展成1024，而是直接使用，也就是最终的扩展结果是 X_BUFSIZE，而不是 X_10。如果想要得到 X_10 的结果，需要做1次间接宏调用，重新定一个宏 XAFTERX 来调用宏 AFTERX，当调用宏 XAFTERX(BUFSIZE) 时，就会得到结果 X_10。