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


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

  1. #define def_u32_array(__name, __size) \
  2. uint32_t array_##__name[__size];

复制代码

实际中,我们可以这样使用:

  1. def_u32_array(sample_buffer, 64)

复制代码

宏展开的效果是:

  1. uint32_t array_sample_buffer[64];

复制代码

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

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


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

  1. #define safe_atom_code(…)\
  2. {\
  3. uint32_t int_flag = __disable_irq(); \
  4. __VA_ARGS__\
  5. __set_PRIMASK(int_flag); \
  6. }

复制代码

  • 这里定义了一个宏”safe_atom_code()”,在括号内,无论你填写任何内容,都会被无条件的放置到“__VA_ARGS__”所在
    的位置,你可以认为括号里的“…”实际上就是对应”__VA_ARGS__”。比如,我们可以写下这样的代码:
    1. /**\fnvoid wr_dat (uint16_t dat)
    2. \brief Write data to the LCD controller
    3. \param[in] datData to write
    4. */
    5. static __inline void wr_dat (uint_fast16_t dat) {
    6. safe_atom_code(
    7. LCD_CS(0);
    8. GLCD_PORT->DAT = (dat >> 8);
    9. /* Write D8..D15 */
    10. GLCD_PORT->DAT = (dat & 0xFF);
    11. /* Write D0..D7 */
    12. LCD_CS(1);
    13. )
    14. }

    复制代码这个代码确保在向寄存器GCLD_PORT->DAT写入数据时不会被其它中断打断。
    聪明的你也许很快就会提出这样的问题,上述宏跟下面的写法有什么区别呢?

    1. #define safe_atom_code(__CODE) \
    2. {\
    3. uint32_t int_flag = __disable_irq(); \
    4. __CODE \
    5. __set_PRIMASK(int_flag); \
    6. }

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

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

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

  • “…”只能放在参数宏形参列表的最后;
  • 当用户的参数个数超过了规定的参数个数时,所有多出来的内容会一股脑的由“__VA_ARGS__”所背负;
  • 当用户的参数个数正好等于形参的个数时,”__VA_ARGS__”就等效于一个空字符串

回头再来看前面的问题,

  1. #define safe_atom_code(…)

复制代码

  1. #define safe_atom_code(__CODE)

复制代码

的差别在于,前者括号里可以放包括”,”在内的几乎任意内容;而后者则完全不
能容忍逗号的存在——比如你调用了一个函数,函数的参数要用到都好隔开吧?再比如,你用到了逗号表达式……——想想都很
酸爽。
其实,可变参数列表最初诞生的原因之一是为了解决与C函数的可变参数(va_args)配合使用的问题,例如:

  1. #define log_info(__STRING, …)printf(__STRING, __VA_ARGS__)

复制代码

因此,使用的时候,我们可以这样写:

  1. log_info(“————————————\r\n”);
  2. log_info(” Cycle Count : %d”, total_cycle_cnt);

复制代码

宏展开后实际上对应于:

  1. printf(“————————————\r\n”,);
  2. printf(” Cycle Count : %d”, total_cycle_cnt);

复制代码

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

  1. #define log_info(__STRING, …)printf(__STRING,##__VA_ARGS__)

复制代码

此时,前面的代码会被展开为:

  1. printf(“————————————\r\n”);
  2. printf(” Cycle Count : %d”, total_cycle_cnt);

复制代码

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

如果说这就是99%的C程序员都不知道的”##”隐藏用法,未免太对不起观众了,实际上本文的正片才刚刚开始。

【正文:”##”的骚操作】


逗号表达式,一直关注公众号的朋友们想必都很熟悉——之前转载的文章《【C进阶】听说用 “ 逗号表达式 ” 仅仅为了秀技?》已经说的非常详细了,
这里就不再赘述。简单说,就是逗号表达式中,逗号的最右边将作为表达式真正的返回值。
结合前面关于”,##__VA_ARGS__”用法的介绍,你们有没有意识到,其实这里的逗号不光可以是参数列表的分隔符,还可以是逗号
表达式的运算符。结合__VA_ARGS__的特性,我们可以写出类似这样的宏:

  1. #define EXAMPLE(…) ( 默认值 ,##__VA_ARGS__)

复制代码

它有两种使用情况情况:
当我们使用参数宏的时候在括号里不填写任何内容,最终会展开为仅有默认值的情况:

  1. EXAMPLE();

复制代码

被展开为:

  1. ( 默认值 )

复制代码

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

  1. EXAMPLE(我们提供的值);

复制代码

被展开为:

  1. ( 默认值, 我们提供的值 )

复制代码

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

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

  • 为函数提供默认的参数

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

  1. typedef struct xxxx_cfg_t {
  2. } xxxx_cfg_t;
  3. int xxxx_init(xxxx_cfg_t *cfg_ptr);

复制代码

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

  1. #define XXXX_INIT(…)xxxx_init((NULL,##__VA_ARGS__))

复制代码

  • 为消息处理提供默认的掩码配置

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

  1. typedef struct msg_t msg_t;
  2. struct msg_t {
  3. uint16_t msg;
  4. uint16_t msk;
  5. int (*handler)(msg_t *msg_ptr);
  6. };

复制代码

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

  1. #define def_msg_map(__name, …)\
  2. const msg_t __name[] = {__VA_ARGS__};
  3. #define add_msg(__msg, __handler, …)\
  4. { \
  5. .msg = (__msg), \
  6. .handler = &(__handler),\
  7. .msk = (0xFFFF, ##__VA_ARGS__), \
  8. }

复制代码

通过宏 add_msg 我们注意到,当用户刻意省略设置msk时,我们就给出默认值 0xFFFF——这很可能表示,在进
行消息处理的时候,消息必须严格匹配才能交给对应的处理函数;当用户指定 msk 时,则可能表示某一类消息都交给同一
个消息处理函数来处理。例如:

  1. /*! \note 高字节表示操作的类别:
  2. 比如0x00表示控制类,0x01表示WRITE,0x02表示READ
  3. */
  4. enum {
  5. SIGN_UP= 0x0001,
  6. WRITE_MEM= 0x0100,
  7. WRITE_SRAM = 0x0101,
  8. WRITE_FLASH= 0x0102,
  9. WRITE_EEPROM = 0x0103,
  10. READ_MEM = 0x0200,
  11. READ_SRAM= 0x0201,
  12. READ_FLASH = 0x0202,
  13. READ_EEPROM= 0x0203,
  14. };
  15. extern int iap_sign_up_handler(msg_t *msg_ptr);
  16. extern int iap_write_mem(msg_t *msg_ptr);
  17. extern int iap_read_mem(msg_t *msg_ptr);
  18. def_msg_map( iap_message_map,
  19. /* 严格的将 SIGN_UP 映射到 对应的处理函数中 */
  20. add_msg( SIGN_UP, iap_sign_up_handler ),
  21. /* 批量处理所有的WRITE操作,使用掩码进行过滤*/
  22. add_msg( WRITE_MEM, iap_write_mem, 0xFF00 ),
  23. /* 批量处理所有的READ操作,使用掩码进行过滤 */
  24. add_msg( READ_MEM,iap_read_mem,0xFF00 ),
  25. )

复制代码