虫虫首页| 资源下载| 资源专辑| 精品软件
登录| 注册

您现在的位置是:首页 > 技术阅读 >  【为宏正名】for的妙用你想不到

【为宏正名】for的妙用你想不到

时间:2024-02-13


【说在前面的话】


通过本系列前面两篇文章的学习,我们掌握了宏的基本语法和使用规则,讽刺的是这些所谓的“基本语法和规则”却恰恰是正规C语言教育中所缺失的。本文的内容将建立在前面构筑的基础之上,以for功能的挖掘和封装为契机,手把手的教会你如何正确使用宏来简化日常开发增强C语言的可读性降低应用开发的难度、同时还尽可能避免宏对日常代码调试带来的负面影响
在开始本文的内容之前,如果你还没有阅读过前面两篇文章,可以单击下面的链接:

基础必修1【为宏正名】本应写入教科书的“世界设定”
基础必修2:【为宏正名】什么?我忘了去上“数学必修课”!
应用范例1:【为宏正名】99%人都不知道的"##"里用法

【被低估的价值】


想必大家对C语言中的 for 循环结构并不陌生。根据C/C++语法网站cppreference.com 的介绍,for 的语法结构如下:
for ( init_clause ; cond_expression ; iteration_expression )     loop_statement
这里,我并不想假设大家对 for 结构一无所知,并介绍一堆教科书上已有的内容。然而,在 for 的语法结构中有几个大家容易忽视的地方,而它们恰恰是本文后续各种“展开”的基础:

  • for 循环中的 cond_expression 和 interation_expression 都必须是表达式,而不能是直接的语句。

  • for 循环中第一个部分 init_clause 一开始是用来放置给变量赋值的表达式;但从ANSI-C99开始,init_clause 可以被用来建立局部变量;而局部变量的生命周期覆盖且仅覆盖整个for循环——这一点非常有利用价值,也是大家容易忽略的地方。



为了说明这一点,我们不妨举几个例子。首先在C99标准之前,如果你要在 for 循环中使用一个循环变量,你只能在进入 for 之前将其定义好:
int i = 0;...for (i = 0; i < 100; i++) {    ...}
如你所见,虽然我们可以在 init_clause 的位置对变量赋值,但它并不是必须的——多少一点鸡肋是不是?也许更鸡肋的是,你可以在 init_clause 这里完成更多的赋值操作,比如:
int i = 0, j,k;...for (i = 0, j = 100, k = 1; i < 100; i++) {    ...}
实际上,明眼人都可以看出,init_clause 中所作的事情完全可以放置到 for 循环之前去完成,还可以避免“使用逗号进行分隔” 这样让人不那么习惯的使用方式。也许是意识到这一点,C99允许在 init_clause 里定义局部变量,而正是这一点,完全改变了 for 的命运(关于这一点,我们将在随后的内容中详细介绍)。现在,上述代码可以等效的改写为:
for (int i = 0, j = 100, k = 1; i < 100; i++) {    ...}
需要强调的是,这里仍然有一个小小的限制,即:init_clause 里虽然可以定义局部变量,但这些变量只能是同一类型的,或者是指向这一类型的指针。因此下面的写法是非法的:
for (int i = 0, short j = 100; i < 100; i++) {     ...}
而这样的写法是合法的:
for (int i = 0, *p = NULL; i < 100; i++) {     ...}
请大家务必留意这里的语法细节,我们将在后面的封装中大规模使用


  • 另外一个值得注意的是 for 的执行顺序,它可以用下面的流程图来表示:

容易发现,经过必要的“构造”,我们可以恰好实现一个如同 do { } while(0) 一样的效果:


图中灰色的部分为原本实际的执行流程,而纯黑色的线条以及最下方的虚线箭头则为等效的运行流程。与do {} while(0) 相比,在我们眼中 for 循环的几个关键部分就有了新的意义:


  • 在执行用户代码之前(灰色部分),有能力进行一定的“准备工作”(Before部分);

  • 在执行用户代码之后,有能力执行一定的“收尾工作”(After部分)

  • 在init_clause阶段有能力定义一个“仅仅只覆盖” for 循环的,并且只对 User Code可见的局部变量——换句话说,这些局部变量是不会污染 for 循环以外的地方的。


【构造using结构】


上面所提到的结构,在C#中有一个类似的语法,叫做 using(),其典型的用法如下:
using (StreamReader tReader = File.OpenText(m_InputTextFilePath)){    while (!tReader.EndOfStream)    {        ...    }}

以上述代码为例进行讲解:

  • 在 using 圆括号内定义的变量,其生命周期仅覆盖 using 紧随其后的花括号内部;

  • 当用于代码离开 using 结构的时候,using 会自动执行一个“扫尾工作”,而这个扫尾工作是对应的类事先定义好的。在上述例子中,所谓的扫尾工作就是关闭 与 类StreamReader的实例tReader 所关联的文件——简单说就是using会自动把文件关闭,而不必用户亲自动手


是不是闻到了熟悉的味道?不要搞错因果关系——我们正是对C#中的using结构“甚是眼馋”才决定自己动手,用 for 来创造一个——现有C#的using结构才有我们后面的尝试。下图是using所等校流程图,可以看到他比我们此前的结构还少了一个“Before”部分:

要实现类似using的结构,首先要考虑如何构造一个"至执行一次"的for循环结构。要做到这一点,毫无难度:
for (int i = 1; i > 0; i++) {    ...}

以此为起点,对比我们的“蓝图”,发现至少有以下几个问题:


  • 如何实现 before和after的部分?

  • 现在用的变量 i 固定是 int 类型的,如何允许用户在 init_clause 定义自己的局部变量,并允许使用自己的类型?


问题一:如何实现 before 和 after 部分

对比前面的图例,我们知道 before 和 after 的部分实际上分别对应 for 循环的 cond_expression 和 iteration_expression;同时,这两个部分都必须是表达式——由于表达式的限制,能插入在 before 和 after 部分的内容实际上就只能是“普通表达式”或者是“函数”。
由于我们还必须至少借助 cond_expression 来实现 “只运行一次” 的功能,如何见缝插针的实现 before 的功能呢?不绕弯子,看代码:
//! 假设用户要插入的内容我们都放在叫做 before 和after的函数里extern void before(void);extern void after(void);
for (int i = 1;           //!< init_clause     i--?(before(),1):0;  //!< cond_expression     after())             //!< iteration_expression{ ...}
我们知道,cond_expression 只在乎用户表达式的返回值是0还是非0,因此,这里其实真正起作用的本体是 "i--"——第一次判断的时候返回值是1,由于自减操作,第二次判断的时候就是0了——这就完成了让 for 运行且只运行一次的功能。
接下来,我们借助一个问好表达式,尝试给 i-- 的结果做一个等效“解释”,即:
(i--) ? 1 : 0
用人话说就是,如果 (i--)值是非0的,我们就返回1,反之返回0。这么做的意义是为了进一步通过逗号表达式对 "1" 所在的部分进行扩展:
(i--) ?       (before(), 1)       //!< 使用逗哈表达式进行扩展:     0

由于逗号表达式只管 最右边的结果,忽略所有左边的返回值,因此,哪怕before()函数没有实际返回值对C编译器来说都是无所谓的。同理,由于我们在cond_expression部分已经完成了所有功能,因此 iteration_expression 就任由我们宰割了——编译器原本就对此处表达式所产生的数值并不感兴——我们直接放下 after() 函数即可。

至此,插入 before() 和 after() 的问题圆满解决。

问题二:如何允许用户定义自己的局部变量,并且拥有自己的类型
要解决这个问题,首先必须打破定势思维,即:for循环只能用整型变量。实际并非如此,对for来说真正起作用的只有  cond_expression 的返回值,而它只关心用户的表达式返回的 布尔量 是什么——换句话说,有无数种方法来产生 cond_expression,而使用普通的整形计数器,并对其进行判断只是众多方法中的一种。
打破了这一定势思维后,我们就从问题本身出发考虑:允许用户用自己的类型定义自己的变量——虽然看似我们并不能知道用户会用什么类型来定义变量,因而就无法写出通用的 cond_expression 来实现“让for执行且执行一次”的功能,然而,你们也许忘记了 init_clause 的一个特点:它还可以定义指针——换句话说,无论用户定义了什么类型,我们都可以在最后定义一个指向该类型的指针
#define using(__declare, __on_enter_expr, __on_leave_expr)   \            for (__declare, *_ptr = NULL;                    \                 _ptr++ == NULL ?                            \                    ((__on_enter_expr),1) : 0;               \                 __on_leave_expr                             \                )
为了验证我们的结果,不妨写一个简单的代码:
using(int a = 0,printf("========= On Enter =======\r\n"),                 printf("========= On Leave =======\r\n")) {    printf("\t In Body a=%d \r\n", ++a);

这是对应的执行效果:


我们不妨将上述的宏进行展开,一个可能的结果是:

for (int a = 0, *_ptr = NULL;      _ptr++ == NULL ? ((printf("========= On Enter =======\r\n")),1) : 0;      printf("========= On Leave =======\r\n") ) {    printf("\t In Body a=%d \r\n", ++a);}

从 init_clause 的展开结果来看,完全符合要求:

int a = 0, *_ptr = NULL;


接下来,为了提高宏的鲁棒性,我们可以继续做一些改良,比如给指针一个唯一的名字:
#define using(__declare, __on_enter_expr, __on_leave_expr)                   \            for (__declare, *CONNECT3(__using_, __LINE__,_ptr) = NULL;          \                 CONNECT3(__using_, __LINE__,_ptr)++ == NULL ?                  \                    ((__on_enter_expr),1) : 0;                                  \                 __on_leave_expr                                                \                )

这里,实际上是使用了前面文章中介绍的宏 CONNECT3() 将 “__using_”,__LINE__所表示的当前行号,以及 "_ptr" 粘连在一起,形成一个唯一的局部变量名:

CONNECT3(__using_, __LINE__,_ptr)

如果你对 CONNECT() 宏的来龙去脉感兴趣,可以单击这里


更进一步,如果用户有不同的需求:比如想定义两个以上的局部变量,或是想省确 __on_enter_expr 或者是 __on_leave_expr ——我们完全可以定义多个不同版本的 using:
#define __using1(__declare)                                                     \            for (__declare, *CONNECT3(__using_, __LINE__,_ptr) = NULL;          \                 CONNECT3(__using_, __LINE__,_ptr)++ == NULL;                   \                )

#define __using2(__declare, __on_leave_expr) \ for (__declare, *CONNECT3(__using_, __LINE__,_ptr) = NULL; \ CONNECT3(__using_, __LINE__,_ptr)++ == NULL; \ __on_leave_expr \ )

#define __using3(__declare, __on_enter_expr, __on_leave_expr) \ for (__declare, *CONNECT3(__using_, __LINE__,_ptr) = NULL; \ CONNECT3(__using_, __LINE__,_ptr)++ == NULL ? \ ((__on_enter_expr),1) : 0; \ __on_leave_expr \ )
#define __using4(__dcl1, __dcl2, __on_enter_expr, __on_leave_expr) \ for (__dcl1, __dcl2, *CONNECT3(__using_, __LINE__,_ptr) = NULL; \ CONNECT3(__using_, __LINE__,_ptr)++ == NULL ? \ ((__on_enter_expr),1) : 0; \ __on_leave_expr \ )

借助宏的重载技术,我们可以根据用户输入的参数数量自动选择正确的版本:

#define using(...)  \    CONNECT2(__using, VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__)


至此,我们完成了对 for 的改造,并提出了__using1, __using2, __using3 和 __using4 四个版本变体。那么问题来了,他们分别有什么用处呢?


【提供不阻碍调试的代码封装】


前面的文章中,我们曾有意无意的提供过一个实现原子操作的封装:即在代码的开始阶段关闭全局中断并记录此前的中断状态;执行用户代码后,恢复关闭中断前的状态。其代码如下:
#define SAFE_ATOM_CODE(...)                               \{                                                         \    uint32_t CONNECT2(temp, __LINE__) = __disable_irq();  \    __VA_ARGS__                                           \    __set_PRIMASK((CONNECT2(temp, __LINE__)));            \}

因此可以很容易的通过如下的代码来保护关键的寄存器操作:

/**  \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);    )}

唯一的问题是,这样的写法,在调试时完全没法在用户代码处添加断点(编译器会认为宏内所有的内容都写在了同一行),这是大多数人不喜欢使用宏来封装代码结构的最大原因。借助 __using2,我们可以轻松的解决这个问题:

#define SAFE_ATOM_CODE()                                                        \            __using2(  uint32_t CONNECT2(temp,__LINE__) = __disable_irq(),      \                    __set_PRIMASK(CONNECT2(temp,__LINE__)))

修改上述的代码为:

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

由于using的本质是 for 循环,因为我们可以通过花括号的形式来包裹用户代码,因此,可以很方便的在用户代码中添加断点,单步执行。至于原子保护的功能,我们不妨将上述代码进行宏展开:

static __inline void wr_dat (uint_fast16_t dat){    for (uint32_t temp154 = __disable_irq(), *__using_154_ptr = NULL;          __using_154_ptr++ == NULL ? ((temp154 = temp154),1) : 0;          __set_PRIMASK(temp154) )     {        LCD_CS(0);        GLCD_PORT->DAT = (dat >> 8);        GLCD_PORT->DAT = (dat & 0xFF);        LCD_CS(1);    }}

通过观察,容易发现,这里巧妙使用 init_clause 给 temp154 变量进行赋值——在关闭中断的同时保存了此前的状态;并在原本 after 的位置放置了 恢复中断的语句 __set_PRIMASK(temp154)。


举一反三,此类方法除了用来开关中断以外,还可以用在以下的场合:
  • 在OOPC中自动创建类,并使用 before 部分来执行构造函数;在 after 部分完成 类的析构。

  • 在外设操作中,在 init_clause 部分定义指向外设的指针;在 before部分 Enable或者Open外设;在after部分Disable或者Close外设。

  • 在RTOS中,在 before 部分尝试进入临界区;在 after 部分释放临界区

  • 在文件操作中,在 init_clause 部分尝试打开文件,并获得句柄;在 after 部分自动 close 文件句柄。

  • 在有MPU进行内存保护的场合,在 before 部分,重新配置MPU获取目标地址的访问权限;在 after部分再次配置MPU,关闭对目标地址范围的访问权限。

  • ……



【构造with块】


不知道你们在实际应用中有没有遇到一连串指针访问的情形——说起来就好比是:
你邻居的->朋友的->亲戚家的->一个狗的->保姆的->手机
如果我们要操作这里的“手机”,实在是不想每次都写这么一长串“恶心”的东西,为了应对这一问题,Visual Basic(其实最早是Quick Basic)引入了一个叫做 WITH 块的概念,它的用法如下:
WITH 你邻居的->朋友的->亲戚家的->一个狗的->保姆的->手机     # 这里可以直接访问手机的各项属性,用 “.” 开头就行    . 手机壳颜色 = xxxxx    . 贴膜 = 玻璃膜END WITH

不光是Visual Basic,我们使用C语言进行大规模的应用开发时,或多或少也会遇到同样的情况,比如,配置 STM32 外设时,填写外设配置结构体的时候,每一行都要重新写一遍结构体变量的名字,也是在是很繁琐:

 static UART_HandleTypeDef s_UARTHandle = UART_HandleTypeDef(); s_UARTHandle.Instance        = USART2; s_UARTHandle.Init.BaudRate   = 115200; s_UARTHandle.Init.WordLength = UART_WORDLENGTH_8B; s_UARTHandle.Init.StopBits   = UART_STOPBITS_1; s_UARTHandle.Init.Parity     = UART_PARITY_NONE; s_UARTHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE; s_UARTHandle.Init.Mode       = UART_MODE_TX_RX;

入股有了with块的帮助,上述代码可能就会变得更加清爽,比如:

static UART_HandleTypeDef s_UARTHandle = UART_HandleTypeDef();with(s_UARTHandle) {    .Instance        = USART2;    .Init.BaudRate   = 115200;    .Init.WordLength = UART_WORDLENGTH_8B;    .Init.StopBits   = UART_STOPBITS_1;    .Init.Parity     = UART_PARITY_NONE;    .Init.HwFlowCtl  = UART_HWCONTROL_NONE;    .Init.Mode       = UART_MODE_TX_RX;}

遗憾的是,如果要完全实现上述的结构,在C语言中是不可能的,但借助我们的 using() 结构,我们可以做到一定程度的模拟:

#define with(__type, __addr)  using(__type *_p=(__addr))#define _ (*_p)

在这里,我们要至少提供目标对象的类型,以及目标对象的地址:

static UART_HandleTypeDef s_UARTHandle = UART_HandleTypeDef();with(UART_HandleTypeDef &s_UARTHandle) {    _.Instance        = USART2;    _.Init.BaudRate   = 115200;    _.Init.WordLength = UART_WORDLENGTH_8B;    _.Init.StopBits   = UART_STOPBITS_1;    _.Init.Parity     = UART_PARITY_NONE;    _.Init.HwFlowCtl  = UART_HWCONTROL_NONE;    _.Init.Mode       = UART_MODE_TX_RX;}

注意到,这里“_”实际上被用来替代 s_UARTHandle——虽然感觉有点不够完美,但考虑到脚本语言 perl 有长期使用 "_" 表示本地对象的传统,这样一看,似乎"_" 就是一个对 "perl" 的完美致敬了。


【回归本职 foreach】


很多高级语言都有专门的 foreach 语句,用来实现对数组(或是链表)中的元素进行逐一访问。原生态C语言并没有这种奢侈,即便如此,Linux也定义了一个“野生”的 foreach 来实现类似的功能。为了演示如何使用 using 结构来构造 foreach,我们不妨来看一个例子:

typedef struct example_lv0_t {    uint32_t    wA;    uint16_t    hwB;    uint8_t     chC;    uint8_t     chID;} example_lv0_t;
example_lv0_t s_tItem[8] = { {.chID = 0}, {.chID = 1}, {.chID = 2}, {.chID = 3}, {.chID = 4}, {.chID = 5}, {.chID = 6}, {.chID = 7},};

我们希望实现一个函数,能通过 foreach 自动的访问数组 s_tItem 的所有成员,比如:

foreach(example_lv0_t, s_tItem) {    printf("Processing item with ID = %d\r\n", _.chID);}

跟With块一样,这里我们仍然“致敬” perl——使用 "_" 表示当前循环下的元素。在这个例子中,为了使用 foreach,我们需要提供至少两个信息:目标数组元素的类型(example_lv0_t)和目标数组(s_tItem)。


这里的难点在于,如何定义一个局部的指针,并且它的作用范围仅仅只覆盖 foreach 的循环体。此时,坐在角落里的 __with1() 按耐不住了,高高的举起了双手——是的,它仅有的功能就是允许用户定义一个局部变量,并覆盖由第三方所编写的、由 {} 包裹的区域:
#define dimof(__array)          (sizeof(__array)/sizeof(__array[0]))
#define foreach(__type, __array)                                               \ __using1(__type *_p = __array) \ for ( uint_fast32_t CONNECT2(count,__LINE__) = dimof(__array); \ CONNECT2(count,__LINE__) > 0; \ _p++, CONNECT2(count,__LINE__)-- \ )

上述的宏并不复杂,大家完全可以自己看懂,唯一需要强调的是,using() 的本质是一个for,因此__using1() 下方的for 实际上是位于由 __using1() 所提供的循环体内的,也就是说,这里的局部变量_p其作用域也覆盖 下面的for 循环,这就是为什么我们可以借助:

#define _    (*_p)

的巧妙代换,通过 “_” 来完成对指针“_p”的使用。为了方便大家理解,我们不妨将前面的例子代码进行宏展开:

for (example_lv0_t *_p = s_tItem, *__using_177_ptr = NULL;      __using_177_ptr++ == NULL ? ((_p = _p),1) : 0;     )      for ( uint_fast32_t count177 = (sizeof(s_tItem)/sizeof(s_tItem[0]));            count177 > 0;            _p = _p+1, count177-- )      {        printf("Processing item with ID = %d\r\n", (*_p).chID);     }

其执行结果为:


foreach目前的用法看起来“岁月静好”,似乎没有什么问题,可惜的是,一旦进行实际的代码编写,我们会发现,假如我们要在 foreach 结构中再用一个foreach,或是在foreach中使用 with 块,就会出现 “_” 被覆盖的问题——也就是在里层的 foreach或是 with 无法通过 “_” 来访问外层"_" 所代表的对象。为了应对这一问题,我们可以对 foreach 进行一个小小的改造——允许用户再指定一个专门的局部变量,用于替代"_" 表示当前循环下的对象:
#define foreach2(__type, __array)                                               \            using(__type *_p = __array)                                         \            for (   uint_fast32_t CONNECT2(count,__LINE__) = dimof(__array);    \                    CONNECT2(count,__LINE__) > 0;                               \                    _p++, CONNECT2(count,__LINE__)--                            \                )
#define foreach3(__type, __array, __item) \ using(__type *_p = __array, *__item = _p, _p = _p, ) \ for ( uint_fast32_t CONNECT2(count,__LINE__) = dimof(__array); \ CONNECT2(count,__LINE__) > 0; \ _p++, __item = _p, CONNECT2(count,__LINE__)-- \                )

这里的 foreach3 提供了3个参数,其中最后一个参数就是用来由用户“额外”指定新的指针的;与之相对,老版本的foreach我们称之为 foreach2,因为它只需要两个参数,只能使用"_"作为对象的指代。进一步的,我们可以使用宏的重载来简化用户的使用:

#define foreach(...)        \    CONNECT2(foreach, VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__)

经过这样的改造,我们可以用下面的方法来为我们的循环指定一个叫做"ptItem"的指针:   

foreach(example_lv0_t, s_tItem, ptItem) {    printf("Processing item with ID = %d\r\n", ptItem->chID);}

展开后的形式如下:

for (example_lv0_t *_p = s_tItem, ptItem = _p, *__using_177_ptr = NULL;      __using_177_ptr++ == NULL ? ((_p = _p),1) : 0;     )     for ( uint_fast32_t count177 = (sizeof(s_tItem)/sizeof(s_tItem[0]));            count177 > 0;            _p = _p+1, ptItem = _p, count177-- )      {           printf("Processing item with ID = %d\r\n", ptItem->chID);     }

代码已经做了适当的展开和缩进,这里就不作进一步的分析了。

【后记】


本文的目的,算是对【为宏正名】系列所介绍的知识进行一次示范——告诉大家如何正确的使用宏,配合已有的老的语法结构来“固化”一个新的模板,并以这个模板为起点,理解它的语法意义和用户,简化我们的日常开发。在这篇文章中,老的语法结构就是 for,它是由C语言原生支持的,借助宏,我们封装了一个新的语法结构 using(), 借助它的4种不同形式、理解它们各自的特点,我们又分别封装了非常实用的SAFE_ATOM_CODE(),With块和foreach语法结构——他们的存在至少证明了以下几点:

  • 宏不是奇技淫巧

  • 宏可以封装出其它高级语言所提供的“基础设施”

  • 设计良好的宏可以提升代码的可读性,而不是破坏它

  • 设计良好的宏并不会影响调试

  • 宏可以用来固化某些模板,避免每次都重新编写复杂的语法结构,在这里,using() 模板的出现,避免了我们每次都重复通过原始的 for 语句来构造所需的语法结构,极大的避免了重复劳动,以及由重复劳动所带来的出错风险


往期推荐


1、深度好文|面试官:进程和线程,我只问这19个问题

2、他来了,他来了,C++17新特性精华都在这了

3、一文让你搞懂设计模式

4、C++11新特性,所有知识点都在这了!




如果喜欢这篇文章,请点赞、在看,支持一下哦~谢谢!