C语言中“##“的用法

刺骨的言语ヽ痛彻心扉 2024-03-27 14:19 60阅读 0赞

市面上有很多比较火的编程语言，比如Python、 JAVA、 Go等，你可能觉得C语言很古老、很落后。如果你有这种想法，那可能你只是一个初学的菜鸟。之前给大家分享《C语言中几种特殊标准定义和用法》忘记了C语言中一个重要的内容，就是 \#\# 的用法，可能绝大部分 C 程序员都不知道"\#\#"隐藏用法，下面就来给大家讲讲。

**一、\#\#的“表”用法**

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

\#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); \\

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

/\*\*

\\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);

)

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

聪明的你也许很快就会提出这样的问题，上述宏跟下面的写法有什么区别呢？

\#define safe\_atom\_code(\_\_CODE) \\

\{ \\

uint32\_t int\_flag = \_\_disable\_irq(); \\

\_\_CODE \\

\_\_set\_PRIMASK(int\_flag); \\

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

1.参数宏是通过“,”来作为分隔符来计算用户实际产传入了几个参数的，或者换句话说，在使用参数宏的时候，预编译器是看不懂C语法的——在它眼中，除了它所认识的少数符号外，其它东西都是无意义的字符串——由于在处理括号内部的内容时，它只认识","和"..."，因此当括号中的内容每增加一个","，与编译器就认为多了一个参数。

2.当你使用参数宏的时候，传入参数的个数（已“,”分开）必须与定义参数宏时候形参的数量完全一致；当不一致的时候，预编译器可能不会报错，而是直接无视了你的参数宏——把它传递到编译的下一阶段，因而往往会被认作是一个函数——事实上这个函数是不存在的，因此在链接阶段会报告某某函数未定义的错误。这时候你就会纳闷了，为啥我明明定义的是一个宏，编译器却把它当作函数呢？

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

"..."只能放在参数宏形参列表的最后；

当用户的参数个数超过了规定的参数个数时，所有多出来的内容会一股脑的由“\_\_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\_\_)

它有两种使用情况：

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

EXAMPLE();

被展开为：

( 默认值 )

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

EXAMPLE(我们提供的值);

被展开为：

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

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

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

(1)为函数提供默认的参数

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

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\_\_))

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

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

typedef struct msg\_t msg\_t;

struct \{

uint16\_t msg;

uint16\_t mask;

int (\*handler)(msg\_t \*msg\_ptr);

\} msg\_t;

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

\#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 ),

)

**四、结语**

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

————————————————

来源：[https://www.weidianyuedu.com][https_www.weidianyuedu.com]

[https_www.weidianyuedu.com]: https://www.weidianyuedu.com

C语言中“##“的用法

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 C语言中“##“的用法

相关 c语言中delay的用法

相关 C语言中“##“的独特用法

相关 C语言中extern的用法

相关 C语言中extern的用法

相关 C语言中extern的用法

相关 C/C++语言中const的用法

相关 c语言中indexOf（）的用法

相关 c语言中volatile的用法

相关 C语言中的const用法