【说在前面的话】

---

有人说C语言中最臭名昭著的两兄弟就是指针和宏了。对于前者，很多有经验的老鸟会告诉你：用好了指针你就掌握了C语言的内功心法——如同原力一样，无论是追随光明还是堕入黑暗都离不开它。宏就没这么幸运了，不光年年受到邪恶的混乱C语言大赛的肆意霸凌（http://www.ioccc.org/），更是让“让代码爹妈都不认识”的身份标签贴到了骨头上——怎一个惨字了得。
5 F5 v2 O& h  M( `  n9 @2 H$ G7 b

: r9 z! W% c+ ~6 q; J8 [$ S7 j) N

这个系列将本着实用的原则介绍一些宏在模块封装中“点石成金”的用法，让大家正确认识到宏真实的作用和使用规则——真真正正还“宏”一个公道。
% [6 R8 r) r* i) ]

% I  `' W) W$ _  A: T

【"##"的“表”用法】

---

想必很多人都知道"##"的用法——它本质上是一个“胶水运算”，用于把参数宏中的“形参”与其它没有天然分割的内容粘连在一起，例如：

• #define def_u32_array(__name, __size)     uint32_t array_##__name[__size];
  6 s( i" q3 x; L: Y" R2 x4 D

实际中，我们可以这样使用：

• def_u32_array(sample_buffer, 64)
  

宏展开的效果是：
  |- F7 B# e% ~3 s! C' m' a: {

• uint32_t array_sample_buffer[64];
  9 l# w' a* w" R5 C; d) f

可以看到，"array__"与形参“__name”是没有天然分割的，因此要想将"array_"与"__name"所代表的内容（而不是__name本身）粘连在一起，就需要“##”运算的帮助。另一方面，"__name"与"["是具有天然分隔的——编译器不会认为"__name"与"["是连接在一起的，因此这里并不需要画蛇添足的使用"##"运算——如果你这么做了，预编译器会毫不犹豫的告诉你语法错误。——这是"##"运算的普通用法，在过去转载的文章《C语言#和##连接符在项目中的应用(漂亮)》中也有详细介绍，这里就不再赘述。

【"##"的官方“里”用法】

---

“##”还有一个很少为人所知的“里”用法，在介绍它之前，不得不首先说说由ANSI-C99标准引入的另外一个参数宏扩展——可变参数宏。举个例子：

1. 
   
2. #define safe_atom_code(...)                          \
   5 E1 I  A: R# a% b' c! o
3.         {                                            \
   & d& x7 u6 U- @+ u7 i. g
4.             uint32_t int_flag = __disable_irq();     \
   
5.             __VA_ARGS__                              \
   
6.             __set_PRIMASK(int_flag);                 \
   + ?' T1 s/ v" D* f+ e! [! _4 J
7.         }

复制代码

7 D$ Q( ?  r& x; [

这里定义了一个宏"safe_atom_code()"，在括号内，无论你填写任何内容，都会被无条件的放置到“__VA_ARGS__”所在的位置，你可以认为括号里的“...”实际上就是对应"__VA_ARGS__"。比如，我们可以写下这样的代码：

1. 
   ) F- I/ ?7 v& z* ^9 ^
2. /**
   
3.   \fn          void wr_dat (uint16_t dat)
   
4.   \brief       Write data to the LCD controller
   
5.   \param[in]   dat  Data to write
   " z* z% i" q; U# g, F. ]* J" v9 Y
6. */
   
7. static __inline void wr_dat (uint_fast16_t dat)
   5 ^2 \9 _8 F; @3 r/ l% }( d0 _
8. {
   
9.     safe_atom_code(
   9 _3 P; q2 n( g# V, h7 J
10.         LCD_CS(0);
    $ B- q( [+ F  F9 r  c# G. F
11.         GLCD_PORT->DAT = (dat >>   8);   /* Write D8..D15 */
    
12.         GLCD_PORT->DAT = (dat & 0xFF);   /* Write D0..D7 */
    5 f* n. |7 R, X( T+ L
13.         LCD_CS(1);
    9 i5 F/ v6 ~- c" ~7 D
14.     )
    0 F% m* t# q2 w- @1 p
15. }

复制代码

3 ?% P* m% C8 ?0 ?& H6 s  E$ O% Z; Y

这个代码确保在向寄存器GCLD_PORT->DAT写入数据时不会被其它中断打断。

聪明的你也许很快就会提出这样的问题，上述宏跟下面的写法有什么区别呢？
6 V& R8 }# W0 ?6 \$ @1 D$ ^

1. 
   $ J4 M. m3 t, d% y
2. #define safe_atom_code(__CODE)                       \
   $ P# G4 ]9 e6 T: Z8 C
3.         {                                            \
   
4.             uint32_t int_flag = __disable_irq();     \
   
5.             __CODE                                   \
   
6.             __set_PRIMASK(int_flag);                 \
   
7.         }

复制代码

( f! @+ U4 K: _% [/ ^( Y1 y2 s/ N3 v2 S

你不仅提出了问题，甚至还实际测试了下，似乎完全等效，“根本没差别嘛！”——你惊呼道。然而，事实上并没有那么简单：

• 参数宏是通过“,”来作为分隔符来计算用户实际产传入了几个参数的，或者换句话说，在使用参数宏的时候，预编译器是看不懂C语法的——在它眼中，除了它所认识的少数符号外，其它东西都是无意义的字符串——由于在处理括号内部的内容时，它只认识","和"..."，因此当括号中的内容每增加一个","，与编译器就认为多了一个参数。
• 当你使用参数宏的时候，传入参数的个数（已“,”分开）必须与定义参数宏时候形参的数量完全一致；当不一致的时候，预编译器可能不会报错，而是直接无视了你的参数宏——把它传递到编译的下一阶段，因而往往会被认作是一个函数——事实上这个函数是不存在的，因此在链接阶段会报告某某函数未定义的错误。这时候你就会纳闷了，为啥我明明定义的是一个宏，编译器却把它当作函数呢？
  
  

1 q1 F2 b" s. F

可变参数宏的引入就解决了这个问题：

• "..."只能放在参数宏形参列表的最后；
• 当用户的参数个数超过了规定的参数个数时，所有多出来的内容会一股脑的由“__VA_ARGS__”所背负；
• 当用户的参数个数正好等于形参的个数时，"__VA_ARGS__"就等效于一个空字符串
  
  % Q) b6 J6 c" }; t- e( K

回头再来看前面的问题，

• #define safe_atom_code(...)
  9 ]+ Z8 R' ~  f4 P  D# K5 v

与
0 \7 o5 n$ H# o9 c" f! ~" r

• #define safe_atom_code(__CODE)
  ) c) ]; a: K+ l5 ]  `

的差别在于，前者括号里可以放包括","在内的几乎任意内容；而后者则完全不能容忍逗号的存在——比如你调用了一个函数，函数的参数要用到都好隔开吧？再比如，你用到了逗号表达式……——想想都很酸爽。

其实，可变参数列表最初诞生的原因之一是为了解决与C函数的可变参数（va_args）配合使用的问题，例如：
5 p5 |; t% m; n9 K

• #define log_info(__STRING, ...)    printf(__STRING, __VA_ARGS__)
  5 B1 \8 D% G3 d- J& Q7 M; E

因此，使用的时候，我们可以这样写：

1. 
   
2. log_info("------------------------------------\r\n");
     p- n5 h) l+ |% V) S# f. B
3. log_info(" Cycle Count : %d", total_cycle_cnt);

复制代码

宏展开后实际上对应于：

1. 
   $ I9 q' h8 t; r% w* }$ L) |
2. printf("------------------------------------\r\n",);
   7 P& K0 B' y& b$ t! a; ^! s. X4 T
3. printf(" Cycle Count : %d", total_cycle_cnt);

复制代码

看似没有问题，注意到一个细节没有？在第一个printf()的最后多了一个","。虽然有些编译器，例如GCC并不会计较（也许就是一个warning），但对于广大洁癖严重的处女座程序员来说，这怎么能忍，于是在ANSI-C99标准引入可变参数宏的时候，又贴心了加了一个不那么起眼的语法：当下面的组合出现时 ",##__VA_ARGS__"，如果__VA_ARGS__是一个空字符串，则前面的","会一并被删除掉。因此，上面的宏可以改写为：
* L# E5 M0 i0 d) O2 r

• #define log_info(__STRING, ...)    printf(__STRING,##__VA_ARGS__)
  " k: j  E% B; p1 p9 M! e

此时，前面的代码会被展开为：

1. 
   
2. printf("------------------------------------\r\n");
   
3. printf(" Cycle Count : %d", total_cycle_cnt);

复制代码

处女座表示，这次可以安心睡觉了。

如果说这就是99%的C程序员都不知道的"##"隐藏用法，未免太对不起观众了，实际上本文的正片才刚刚开始。
( S" b. n/ B1 ?3 ~4 r  \* D

【正文："##"的骚操作】

---

逗号表达式，一直关注公众号的朋友们想必都很熟悉——之前转载的文章《

【C进阶】听说用 “ 逗号表达式 ” 仅仅为了秀技？

》已经说的非常详细了，这里就不再赘述。简单说，就是逗号表达式中，逗号的最右边将作为表达式真正的返回值。
结合前面关于",##__VA_ARGS__"用法的介绍，你们有没有意识到，其实这里的逗号不光可以是参数列表的分隔符，还可以是逗号表达式的运算符。结合__VA_ARGS__的特性，我们可以写出类似这样的宏：

• #define EXAMPLE(...)     ( 默认值 ,##__VA_ARGS__)它有两种使用情况情况：
  

• 当我们使用参数宏的时候在括号里不填写任何内容，最终会展开为仅有默认值的情况：
  
  3 c. `8 q/ }7 c! [) M

• EXAMPLE();
  ( _" ~9 o+ p7 V- `0 _0 J

被展开为：

• ( 默认值 )
  

• 当我们提供了任意的有效值时，则会被展开成逗号表达式：
  
  

• EXAMPLE(我们提供的值);
  ; F% I1 B* c3 C  D* a, j, S

被展开为：

• ( 默认值, 我们提供的值 )
  " l5 W: ^/ b+ y2 z3 A

根据逗号表达式的特性，此时，默认值会被丢弃掉（有些编译器会报告表达式无效的warning，这是正常的，因为编译器注意到“默认值”所代表的表达式实际上被丢弃了，它觉得我们写了一个无用的表达式）。

这个技巧其实对API的封装特别有效：它允许我们简化函数API的使用，比如在用户忽略的情况下，自动给函数填充某些默认值，而在用户主动提供参数的情况下，替代那些默认值。这里我举两个现实中的例子：

• 为函数提供默认的参数
  . D1 Q% F+ R5 U3 B

假设我们有一个初始化函数，初始化函数允许用户通过结构体来配置一些参数：

1. 
   + ?) n6 X3 Y3 z, [
2. typedef struct xxxx_cfg_t {
   
3.     ...
   5 I1 ~" D% A5 N' W
4. } xxxx_cfg_t;
   , j5 f1 w- K- y4 d& n( @+ S% M6 T' ?
5. 
   : M' [9 J0 L1 i
6. int xxxx_init(xxxx_cfg_t *cfg_ptr);

复制代码

+ i  ?$ r4 X5 w- n, t8 t

为了简化用户的配置过程，初始化函数会检查指针cfg_ptr是否为NULL，如果为NULL则自动使用默认配置，反之将使用用户定义的配置。此时，我们可以通过宏来提供默认值NULL：

• #define XXXX_INIT(...)    xxxx_init((NULL,##__VA_ARGS__))
  

• 为消息处理提供默认的掩码配置
  
  9 D/ S& \8 D% f+ J; [

有些消息处理函数可以批量的处理某一类消息，而具体选中了哪些消息类别，则通常由二进制掩码来表示，例如：

1. 
   " n7 h/ Z$ f6 z0 |7 Z6 ^, E
2. typedef struct msg_t msg_t;
   * Y4 ~$ K+ O7 y% B+ B
3. struct {
   
4.     uint16_t msg;
   - Z! q" e$ Y2 z0 o) x$ b
5.     uint16_t mask;
   ; l0 Q0 T5 E: b. b% J5 X, w) c2 [
6.     int (*handler)(msg_t *msg_ptr);
   - {8 D% [3 R( k
7. } msg_t;

复制代码

) |1 `- @5 U9 U

此时我们完全可以借助宏来构建一套语法糖：

1. 
   
2. #define def_msg_map(__name, ...)                            \
   & x1 j+ W6 T  e9 p8 @( \( x  a- |) c0 w
3.     const msg_t __name[] = {__VA_ARGS__};
   
4.    
   % z7 A2 ?+ l0 k$ H2 Y0 U% e  J
5. #define add_msg(__msg, __handler, ...)                      \
   
6.     {                                                       \
   * p; k; ?0 S( S
7.         .msg = (__msg),                                     \
   
8.         .handler = &(__handler),                            \
   
9.         .msk = (0xFFFF, ##__VA_ARGS__),                     \
   
10.     }

复制代码

  b( Z) h: H$ O  m" ^1 q$ r
* [$ L: q: o- t; [# ~通过宏 add_msg 我们注意到，当用户刻意省略设置msk时，我们就给出默认值 0xFFFF——这很可能表示，在进行消息处理的时候，消息必须严格匹配才能交给对应的处理函数；当用户指定 msk 时，则可能表示某一类消息都交给同一个消息处理函数来处理。例如：

1. 
   - k0 ~: B. i  c* j3 j* `8 f
2. /*! \note 高字节表示操作的类别:
   ; r6 }- _& I' s8 L( O* P! H
3.           比如0x00表示控制类，0x01表示WRITE，0x02表示READ
   
4. */
   
5. enum {
   
6.     SIGN_UP      = 0x0001,
   
7.     WRITE_MEM    = 0x0100,
   
8.     WRITE_SRAM   = 0x0101,
   
9.     WRITE_FLASH  = 0x0102,
   
10.     WRITE_EEPROM = 0x0103,
    
11.    
    # |3 h% j7 \1 g  d6 C
12.     READ_MEM     = 0x0200,
    : x& v& \1 `4 M1 i. {' A' q" A4 z
13.     READ_SRAM    = 0x0201,
    ; A1 Z  j6 G  D& w& E0 J
14.     READ_FLASH   = 0x0202,
    - M* ?3 A7 G/ k1 @
15.     READ_EEPROM  = 0x0203,
    
16. };
    : G( x! x# m) }+ J4 C
17. 
    
18. extern int iap_sign_up_handler(msg_t *msg_ptr);
    0 v$ o6 Y- V& w8 V, ]$ c+ F
19. extern int iap_write_mem(msg_t *msg_ptr);
    
20. extern int iap_read_mem(msg_t *msg_ptr);
    + S9 P  W; U1 K, N: @1 z+ `; {
21. 
    5 v5 K9 c" |. O0 e+ m
22. def_msg_map( iap_message_map
    - ?+ t$ `" Y  l* B8 h
23.     /* 严格的将 SIGN_UP 映射到 对应的处理函数中 */
    
24.     add_msg( SIGN_UP,   iap_sign_up_handler ),
    
25.     /* 批量处理所有的WRITE操作，使用掩码进行过滤*/
    8 p# \: X- _! `% J4 A( Z
26.     add_msg( WRITE_MEM, iap_write_mem,       0xFF00 ),
    
27.     /* 批量处理所有的READ操作，使用掩码进行过滤 */
    
28.     add_msg( READ_MEM,  iap_read_mem,        0xFF00 ),
    . s' p; o2 ~3 \) G2 h* ]
29. )

复制代码

, a  m% a/ D  g. Y9 Y7 B

. X0 x* N% f5 x( l2 v9 q* ]6 J

【结语】

---

宏不是阻碍代码开发和可读性的魔鬼，对自己不熟悉知识的傲慢才是。

我只知道是用来连接字符用的