【说在前面的话】javascript
经过本系列前面两篇文章的学习，咱们掌握了宏的基本语法和使用规则，讽刺的是这些所谓的“基本语法和规则”却偏偏是正规C语言教育中所缺失的。本文的内容将创建在前面构筑的基础之上，以for功能的挖掘和封装为契机，手把手的教会你如何正确使用宏来简化平常开发，加强C语言的可读性、下降应用开发的难度、同时还尽量避免宏对平常代码调试带来的负面影响。
php
在开始本文的内容以前，若是你尚未阅读过前面两篇文章，能够单击下面的连接：
java
基础必修1：【为宏正名】本应写入教科书的“世界设定”nginx
基础必修2：【为宏正名】什么？我忘了去上“数学必修课”！sql
应用范例1：【为宏正名】99%人都不知道的"##"里用法express
【被低估的价值】编程
想必你们对C语言中的 for 循环结构并不陌生。根据C/C++语法网站cppreference.com 的介绍，for 的语法结构以下：swift
for ( init_clause ; cond_expression ; iteration_expression )
loop_statement
这里，我并不想假设你们对 for 结构一无所知，并介绍一堆教科书上已有的内容。然而，在 for 的语法结构中有几个你们容易忽视的地方，而它们偏偏是本文后续各类“展开”的基础：
c#
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 语句来构造所需的语法结构，极大的避免了重复劳动，以及由重复劳动所带来的出错风险
免责声明：本文系网络转载，版权归原做者全部。如涉及做品版权问题，请与咱们联系，咱们将根据您提供的版权证明材料确认版权并支付稿酬或者删除内容。