【为宏正名】99%人都不知道的"##"里用法

Gorgon_Meducer · 发表于 2020-7-22 05:38:48

本帖最后由 Gorgon_Meducer 于 2020-7-22 20:35 编辑

【说在前面的话】

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

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

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

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

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

复制代码

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

def_u32_array(sample_buffer, 64)

复制代码

宏展开的效果是：

uint32_t array_sample_buffer[64];

复制代码

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

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

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

#define safe_atom_code(...) \
{ \
uint32_t int_flag = __disable_irq(); \
__VA_ARGS__ \
__set_PRIMASK(int_flag); \
}

复制代码

/** \fn void wr_dat (uint16_t dat)
\brief Write data to the LCD controller
\param[in] dat Data to write
*/
static __inline void wr_dat (uint_fast16_t dat) {
safe_atom_code(
LCD_CS(0);
GLCD_PORT->DAT = (dat >> 8);
/* Write D8..D15 */
GLCD_PORT->DAT = (dat & 0xFF);
/* Write D0..D7 */
LCD_CS(1);
)
}

复制代码

#define safe_atom_code(__CODE) \
{ \
uint32_t int_flag = __disable_irq(); \
__CODE \
__set_PRIMASK(int_flag); \
}

复制代码

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

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

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

回头再来看前面的问题，

#define safe_atom_code(...)

复制代码

与

#define safe_atom_code(__CODE)

复制代码

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

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

复制代码

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

log_info("------------------------------------\r\n");
log_info(" Cycle Count : %d", total_cycle_cnt);

复制代码

宏展开后实际上对应于：

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

复制代码

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

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

复制代码

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

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

复制代码

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

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

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

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

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

复制代码

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

EXAMPLE();

复制代码

被展开为：

( 默认值 )

复制代码

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

EXAMPLE(我们提供的值);

复制代码

被展开为：

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

复制代码

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

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

为函数提供默认的参数

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

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

复制代码

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

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

复制代码

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

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

typedef struct msg_t msg_t;
struct msg_t {
uint16_t msg;
uint16_t msk;
int (*handler)(msg_t *msg_ptr);
};

复制代码

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

#define def_msg_map(__name, ...) \
const msg_t __name[] = {__VA_ARGS__};
#define add_msg(__msg, __handler, ...) \
{ \
.msg = (__msg), \
.handler = &(__handler), \
.msk = (0xFFFF, ##__VA_ARGS__), \
}

复制代码

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

/*! \note 高字节表示操作的类别:
比如0x00表示控制类，0x01表示WRITE，0x02表示READ
*/
enum {
SIGN_UP = 0x0001,
WRITE_MEM = 0x0100,
WRITE_SRAM = 0x0101,
WRITE_FLASH = 0x0102,
WRITE_EEPROM = 0x0103,
READ_MEM = 0x0200,
READ_SRAM = 0x0201,
READ_FLASH = 0x0202,
READ_EEPROM = 0x0203,
};
extern int iap_sign_up_handler(msg_t *msg_ptr);
extern int iap_write_mem(msg_t *msg_ptr);
extern int iap_read_mem(msg_t *msg_ptr);
def_msg_map( iap_message_map,
/* 严格的将 SIGN_UP 映射到对应的处理函数中 */
add_msg( SIGN_UP, iap_sign_up_handler ),
/* 批量处理所有的WRITE操作，使用掩码进行过滤*/
add_msg( WRITE_MEM, iap_write_mem, 0xFF00 ),
/* 批量处理所有的READ操作，使用掩码进行过滤 */
add_msg( READ_MEM, iap_read_mem, 0xFF00 ),
)

复制代码

【结语】

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

干货创作不易，如果你觉得我的文章对你有所帮助，还请打赏、点赞、收藏和三连。

xiaoergao · 发表于 2020-7-22 05:50:53

学习了，宏的秒用！

eliterxzgxu · 发表于 2020-7-22 06:24:34

学习了，感谢楼主分享

what007 · 发表于 2020-7-22 06:29:26

学习一下。

liyang121316 · 发表于 2020-7-22 06:37:13

好久不见了啊，大侠！

haffman1 · 发表于 2020-7-22 06:44:25

楼主有几个地方错了…

takashiki · 发表于 2020-7-22 07:06:46

受教了，还真没有仔细分析过__VA_ARGS__和##__VA_ARGS__的区别，因为我用的GCC C++容忍度太高了，就算末尾有个,它也不警告还可以正常跑

但是逗号表达式那个很强，然而我是不会用的，这玩意跟编译器相关，被坑过有教训了，不遵守规则的编译器在这里埋坑故放弃。比如STM8的Cosmic编译器，Debug模式逗号表达式工作得很好，Release模式如果前面的语句有副作用就有可能优化掉部分语句干瞪眼了，当然您这个它不可能短路掉，但还是坚守原则好点，不用逗号表达式。
MISRA：规则 12.10 （强制）：不要使用逗号运算符。
还是听编码规范的吧。

PCBBOY1991 · 发表于 2020-7-22 07:52:54

赞！硬硬的干货^_^

yoz · 发表于 2020-7-22 07:55:04

可能是编辑器粘贴的问题，楼主老师第一个代码

#define def_u32_array(__name, __size) \
uint32_t array_##__name
def_u32_array(sample_buffer, 64)

复制代码

改成

#define def_u32_array(__name, __size) \
uint32_t array_##__name[__size]
def_u32_array(sample_buffer, 64);

复制代码

就能正常工作了。

andy2015 · 发表于 2020-7-22 08:01:17

硬硬的干货^_^

VanZ7 · 发表于 2020-7-22 08:21:20

硬核。收藏了。

armok. · 发表于 2020-7-22 08:48:32

打赏50汤圆。

zcllom · 发表于 2020-7-22 09:01:44

打赏20汤圆。总是长篇大论，只好以后再来看

lovelywwei · 发表于 2020-7-22 09:10:09

MARK。收藏学习。

amazing030 · 发表于 2020-7-22 09:36:15

好久不见啊

knight_sh · 发表于 2020-7-22 10:11:26

应该是这样吧：
#define def_u32_array(__name, __size) \
uint32_t array_##__name[__size]

ghostxdy · 发表于 2020-7-22 10:51:26

收藏再看，这个是我不懂的地方

momo_li · 发表于 2020-7-22 10:57:27

写了好多年的代码, 最近才开始真的接触不定参数, 逗号表达, 正则运算, 库函数. 见到了这些才发现, 自己的C语音居然都算不上真正的入门.

momo_li · 发表于 2020-7-22 11:04:59

向大佬咨询下, IAR 中不同结构体的成员名称, 为什么一定要不同, 有办法在不同结构体中定义相同的成员名吗

xflm · 发表于 2020-7-22 11:59:53

本帖最后由 Gorgon_Meducer 于 2020-8-8 00:54 编辑

enum {
LOG_LEVEL_OFF = 0,
LOG_LEVEL_FATAL = 1,
LOG_LEVEL_ERROR = 2,
LOG_LEVEL_WARN = 3,
LOG_LEVEL_INFO = 4,
LOG_LEVEL_DEBUG = 5,
LOG_LEVEL_ALL = 6,
};
#define LOG_LEVEL_GLOBAL LOG_LEVEL_ALL
#define LOG_LEVEL_CUR LOG_LEVEL_WARN
#define LOG_FATAL(IF, CONTENT, ...) \
if((IF) && (LOG_LEVEL_GLOBAL >= LOG_LEVEL_FATAL) && (LOG_LEVEL_CUR >= LOG_LEVEL_FATAL)) { \
printf("[F] "); \
printf(__FUNCTION__); \
printf(": "); \
CONTENT \
puts("."); \
__VA_ARGS__ \
}
int func(const char *p)
{
LOG_FATAL(
p == NULL,
printf("p is null.");
printf(" exit");,
return 1;
);
... ...
}

复制代码

平时喜欢这么用

uindex · 发表于 2020-7-22 12:04:43

考考大家，是否真的读懂了楼主的旷世大作：
#define KK(...) 1,##__VA_ARGS__

1.int a = 1,2;
2.int b = KK();
3.int c = KK(3);
4.int d = (KK(4));

那几个可以编译过

lai_wan · 发表于 2020-7-22 12:15:20

先MARK下，再慢慢看

xy-mcu · 发表于 2020-7-22 12:23:29

向大师致敬！
## 只用过这个功能
-----------------------------------------
它本质上是一个“胶水运算”，用于把参数宏中的“形参”与其它没
有天然分割的内容粘连在一起
-----------------------------------------
您的状态机，一直想用，一直用不起来。

pt2go · 发表于 2020-7-22 12:23:42

不错，虽然不时有用过，但是没有总结出来..............

d314361768 · 发表于 2020-7-22 13:10:47

学习了！！！

rifjft · 发表于 2020-7-22 14:49:37

大师又开讲了，学习中……

ziziy · 发表于 2020-7-22 18:07:39

yoz 发表于 2020-7-22 07:55
可能是编辑器粘贴的问题，楼主老师第一个代码

还有个地方要改：

typedef struct msg_t msg_t;
struct {
uint16_t msg;
uint16_t msk;
int (*handler)(msg_t *msg_ptr);
} msg_t;

改成typedef struct msg_t msg_t;
struct msg_t{
uint16_t msg;
uint16_t msk;
int (*handler)(msg_t *msg_ptr);
};

hcambridge · 发表于 2020-7-22 18:18:34

感谢讲解！学习中。

chouxier99318 · 发表于 2020-7-22 18:51:34

硬核，学习了。

Gorgon_Meducer · 发表于 2020-7-22 20:17:33

takashiki 发表于 2020-7-22 07:06
受教了，还真没有仔细分析过__VA_ARGS__和##__VA_ARGS__的区别，因为我用的GCC C++容忍度太高了，就算末尾 ...

不是所有应用都要遵守 MISRA 规范…… 否则大家都用C90/89好了。
逗号表达式以及__VA_ARGS__只是个工具，根据情况灵活使用就好。我其实不相信大部分人的工作都要遵守MISRA规范，那就真是miserable了。

Gorgon_Meducer · 发表于 2020-7-22 20:23:58

ziziy 发表于 2020-7-22 18:07
还有个地方要改：

typedef struct msg_t msg_t;

没错，是笔误。

Gorgon_Meducer · 发表于 2020-7-22 20:25:48

xy-mcu 发表于 2020-7-22 12:23
向大师致敬！
## 只用过这个功能
-----------------------------------------

你是说那个模板么？

Gorgon_Meducer · 发表于 2020-7-22 20:27:05

momo_li 发表于 2020-7-22 11:04
向大佬咨询下, IAR 中不同结构体的成员名称, 为什么一定要不同, 有办法在不同结构体中定义相同的成员名吗 ...

我没有遇到过这个问题……给个例子？

Gorgon_Meducer · 发表于 2020-7-22 20:36:59

uindex 发表于 2020-7-22 12:04
考考大家，是否真的读懂了楼主的旷世大作：
#define KK(...) 1,##__VA_ARGS__

谢谢你的练习题，这里是参考答案的提示：
定义宏的时候要打括号……

Jerome_V · 发表于 2020-7-22 23:44:09

学习一下。

xiaotaodzgzs · 发表于 2020-7-23 10:38:08

学习一下。

onepower · 发表于 2020-7-23 11:40:41

宏的这种用法好是好, 就是用来连一下名称就好, 用多了可会走火入魔的, 比指针更危险!!!!

bbbbbv · 发表于 2020-7-23 15:45:08

学习一下。

zhq0571 · 发表于 2020-7-23 16:16:12

学习一下。

nade · 发表于 2020-7-23 16:44:10

刚刚阅读##代码，好吧，宏不是阻碍代码开发和可读性的魔鬼。。。。

JJKwong · 发表于 2020-7-23 17:02:15

已阅读，待领会

jjj · 发表于 2020-7-23 19:24:16

本帖最后由 jjj 于 2020-7-23 19:34 编辑

为什么要写这么晦涩难懂的程序，
void
memp_init(void)
{
u16_t i;
/* for every pool: */
for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) {
memp_init_pool(memp_pools);
}
LWIP里的这个内存分配，让我分析了半年也没弄明白

突然明白，把代码写成这样的目的就是不想让我看明白，普通用户也无需明白，会用LWIP不代码里面的每个细节都明白。

如果把LWIP的网卡驱动也这样搞的话，估计就没有人用了，如果把LWIP 的 UDP TCP编程也这样搞的话，估计我们就不会知道LWIP的存在了

astankvai · 发表于 2020-7-23 19:28:41

深度好文，标记。

zhoujta · 发表于 2020-7-23 21:37:42

good,,不错,,,

amdzid · 发表于 2020-7-24 00:27:06

这个用着用着容易上瘾，有问题单步调试就有点恶心了

Gorgon_Meducer · 发表于 2020-8-8 00:28:04

xflm 发表于 2020-7-22 11:59
enum {
LOG_LEVEL_OFF = 0,
LOG_LEVEL_FATAL = 1,

好东西，谢谢分享。

Gorgon_Meducer · 发表于 2020-8-8 00:29:16

onepower 发表于 2020-7-23 11:40
宏的这种用法好是好, 就是用来连一下名称就好, 用多了可会走火入魔的, 比指针更危险!!!! ...

知道规则以后，就是正确的对规则的使用而已，“走火入魔”我觉得是一种挺主观的情绪化描述。

Gorgon_Meducer · 发表于 2020-8-8 00:48:57

amdzid 发表于 2020-7-24 00:27
这个用着用着容易上瘾，有问题单步调试就有点恶心了

目前介绍的东西除了 safe_atom_code() 括号填写代码这个部分以外，都不影响单步。
但其实对于safe_atom_code() 不能单步的问题，我后面有另外一个解决方法，对应的，推荐的写法是

safe_atom_code() {
...
}

复制代码

而不是

safe_atom_code(
...
)

复制代码

这也算一种技巧吧，其实本质上就是用了 for(;;) 的特性做了一个宏封装而已，比如

#define __CONNECT2(a,b) a##b
#define CONNECT2(a,b) __CONNECT2(a,b)
#define safe_atom_code() \
for(uint32_t CONNECT2(int_status,__LINE__) =__disable_irq(), \
CONNECT2(stop_flag,__LINE__) = 1; \
CONNECT2(stop_flag,__LINE__)-- >0; \
__set_PRIMASK(CONNECT2(int_status,__LINE__)))

复制代码

使用的时候这样:

safe_atom_code() {
/* put your code here */
...
}

复制代码

在花括号里的代码就可以下断点了。一种可能的展开结果是这样的:

# 68 "main.c"
for(uint32_t int_status68 =__disable_irq(), stop_flag68 = 1; stop_flag68-- >0; __set_PRIMASK(int_status68)) {
/* put your code here */
}

复制代码

Gorgon_Meducer · 发表于 2020-8-8 00:51:15

本帖最后由 Gorgon_Meducer 于 2020-8-8 00:53 编辑

jjj 发表于 2020-7-23 19:24
为什么要写这么晦涩难懂的程序，
void
memp_init(void)

很正确，代码是给你用的，并不是拿来给你做教育品的——你非要拿一个使用目的的工具来研究怎么制造这个
工具的，然后抨击别人封装的太严实让你不好拆，你让工具的制造商怎么想？哭笑不得吧？

另外，你举例的这个代码，讲真……可读性非常好……我并不觉得他晦涩难懂……

canspider · 发表于 2020-8-8 08:35:09

jjj 发表于 2020-7-23 19:24
为什么要写这么晦涩难懂的程序，
void
memp_init(void)

如果这个都看不明白，这边建议您换个工作

jjj · 发表于 2020-8-8 09:33:54

canspider 发表于 2020-8-8 08:35
如果这个都看不明白，这边建议您换个工作

换不了了，俺是公司的嵌入式专家，俺换工作公司会倒闭的

Gorgon_Meducer · 发表于 2020-8-8 22:24:54

jjj 发表于 2020-8-8 09:33
换不了了，俺是公司的嵌入式专家，俺换工作公司会倒闭的

注意保护身体，保护头发。保重，兄弟。

【为宏正名】99%人都不知道的"##"里用法

本帖子中包含更多资源

阿莫论坛20周年了！感谢大家的支持与爱护！！