【說在前面的話】

通過本系列前面兩篇文章的學(xué)習(xí)，我們掌握了宏的基本語法和使用規(guī)則，諷刺的是這些所謂的“基本語法和規(guī)則”卻恰恰是正規(guī)C語言教育中所缺失的。本文的內(nèi)容將建立在前面構(gòu)筑的基礎(chǔ)之上，以for功能的挖掘和封裝為契機(jī)，手把手的教會你如何正確使用宏來簡化日常開發(fā)，增強(qiáng)C語言的可讀性、降低應(yīng)用開發(fā)的難度、同時(shí)還盡可能避免宏對日常代碼調(diào)試帶來的負(fù)面影響。

【被低估的價(jià)值】

想必大家對C語言中的 for 循環(huán)結(jié)構(gòu)并不陌生。根據(jù)C/C++語法網(wǎng)站cppreference.com 的介紹，for 的語法結(jié)構(gòu)如下：

for （ init_clause ; cond_expression ; iteration_expression ） loop_statement

這里，我并不想假設(shè)大家對 for 結(jié)構(gòu)一無所知，并介紹一堆教科書上已有的內(nèi)容。然而，在 for 的語法結(jié)構(gòu)中有幾個(gè)大家容易忽視的地方，而它們恰恰是本文后續(xù)各種“展開”的基礎(chǔ)：

for 循環(huán)中的 cond_expression 和 interation_expression 都必須是表達(dá)式，而不能是直接的語句。

for 循環(huán)中第一個(gè)部分 init_clause 一開始是用來放置給變量賦值的表達(dá)式；但從ANSI-C99開始，init_clause 可以被用來建立局部變量；而局部變量的生命周期覆蓋且僅覆蓋整個(gè)for循環(huán)——這一點(diǎn)非常有利用價(jià)值，也是大家容易忽略的地方。

為了說明這一點(diǎn)，我們不妨舉幾個(gè)例子。首先在C99標(biāo)準(zhǔn)之前，如果你要在 for 循環(huán)中使用一個(gè)循環(huán)變量，你只能在進(jìn)入 for 之前將其定義好：

int i = 0;。..for （i = 0; i 《 100; i++） { 。..}

如你所見，雖然我們可以在 init_clause 的位置對變量賦值，但它并不是必須的——多少一點(diǎn)雞肋是不是？也許更雞肋的是，你可以在 init_clause 這里完成更多的賦值操作，比如：

int i = 0， j，k;。..for （i = 0， j = 100， k = 1; i 《 100; i++） { 。..}

實(shí)際上，明眼人都可以看出，init_clause 中所作的事情完全可以放置到 for 循環(huán)之前去完成，還可以避免“使用逗號進(jìn)行分隔” 這樣讓人不那么習(xí)慣的使用方式。也許是意識到這一點(diǎn)，C99允許在 init_clause 里定義局部變量，而正是這一點(diǎn)，完全改變了 for 的命運(yùn)（關(guān)于這一點(diǎn)，我們將在隨后的內(nèi)容中詳細(xì)介紹）?，F(xiàn)在，上述代碼可以等效的改寫為：

for （int i = 0， j = 100， k = 1; i 《 100; i++） { 。..}

需要強(qiáng)調(diào)的是，這里仍然有一個(gè)小小的限制，即：init_clause 里雖然可以定義局部變量，但這些變量只能是同一類型的，或者是指向這一類型的指針。因此下面的寫法是非法的：

for （int i = 0， short j = 100; i 《 100; i++） { 。..}

而這樣的寫法是合法的：

for （int i = 0， *p = NULL; i 《 100; i++） { 。..}

請大家務(wù)必留意這里的語法細(xì)節(jié)，我們將在后面的封裝中大規(guī)模使用。

另外一個(gè)值得注意的是 for 的執(zhí)行順序，它可以用下面的流程圖來表示：

容易發(fā)現(xiàn)，經(jīng)過必要的“構(gòu)造”，我們可以恰好實(shí)現(xiàn)一個(gè)如同 do { } while（0） 一樣的效果：

圖中灰色的部分為原本實(shí)際的執(zhí)行流程，而純黑色的線條以及最下方的虛線箭頭則為等效的運(yùn)行流程。與do {} while（0） 相比，在我們眼中 for 循環(huán)的幾個(gè)關(guān)鍵部分就有了新的意義：

在執(zhí)行用戶代碼之前（灰色部分），有能力進(jìn)行一定的“準(zhǔn)備工作”（Before部分）；

在執(zhí)行用戶代碼之后，有能力執(zhí)行一定的“收尾工作”（After部分）

在init_clause階段有能力定義一個(gè)“僅僅只覆蓋” for 循環(huán)的，并且只對 User Code可見的局部變量——換句話說，這些局部變量是不會污染 for 循環(huán)以外的地方的。

【構(gòu)造using結(jié)構(gòu)】

上面所提到的結(jié)構(gòu)，在C#中有一個(gè)類似的語法，叫做 using（），其典型的用法如下：

using （StreamReader tReader = File.OpenText（m_InputTextFilePath））{ while （！tReader.EndOfStream） { 。.. }}

以上述代碼為例進(jìn)行講解：

在 using 圓括號內(nèi)定義的變量，其生命周期僅覆蓋 using 緊隨其后的花括號內(nèi)部；

當(dāng)用于代碼離開 using 結(jié)構(gòu)的時(shí)候，using 會自動執(zhí)行一個(gè)“掃尾工作”，而這個(gè)掃尾工作是對應(yīng)的類事先定義好的。在上述例子中，所謂的掃尾工作就是關(guān)閉 與 類StreamReader的實(shí)例tReader 所關(guān)聯(lián)的文件——簡單說就是using會自動把文件關(guān)閉，而不必用戶親自動手。

是不是聞到了熟悉的味道？不要搞錯因果關(guān)系——我們正是對C#中的using結(jié)構(gòu)“甚是眼饞”才決定自己動手，用 for 來創(chuàng)造一個(gè)——現(xiàn)有C#的using結(jié)構(gòu)才有我們后面的嘗試。下圖是using所等校流程圖，可以看到他比我們此前的結(jié)構(gòu)還少了一個(gè)“Before”部分：

要實(shí)現(xiàn)類似using的結(jié)構(gòu)，首先要考慮如何構(gòu)造一個(gè)“至執(zhí)行一次”的for循環(huán)結(jié)構(gòu)。要做到這一點(diǎn)，毫無難度：

for （int i = 1; i 》 0; i++） { 。..}

以此為起點(diǎn)，對比我們的“藍(lán)圖”，發(fā)現(xiàn)至少有以下幾個(gè)問題：

如何實(shí)現(xiàn) before和after的部分？

現(xiàn)在用的變量 i 固定是 int 類型的，如何允許用戶在 init_clause 定義自己的局部變量，并允許使用自己的類型？

問題一：如何實(shí)現(xiàn) before 和 after 部分

對比前面的圖例，我們知道 before 和 after 的部分實(shí)際上分別對應(yīng) for 循環(huán)的 cond_expression 和 iteration_expression；同時(shí)，這兩個(gè)部分都必須是表達(dá)式——由于表達(dá)式的限制，能插入在 before 和 after 部分的內(nèi)容實(shí)際上就只能是“普通表達(dá)式”或者是“函數(shù)”。

由于我們還必須至少借助 cond_expression 來實(shí)現(xiàn) “只運(yùn)行一次” 的功能，如何見縫插針的實(shí)現(xiàn) before 的功能呢？不繞彎子，看代碼：

//！ 假設(shè)用戶要插入的內(nèi)容我們都放在叫做 before 和after的函數(shù)里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 只在乎用戶表達(dá)式的返回值是0還是非0，因此，這里其實(shí)真正起作用的本體是 “i--”——第一次判斷的時(shí)候返回值是1，由于自減操作，第二次判斷的時(shí)候就是0了——這就完成了讓 for 運(yùn)行且只運(yùn)行一次的功能。

接下來，我們借助一個(gè)問好表達(dá)式，嘗試給 i-- 的結(jié)果做一個(gè)等效“解釋”，即：

（i--） ？ 1 ： 0

用人話說就是，如果 （i--）值是非0的，我們就返回1，反之返回0。這么做的意義是為了進(jìn)一步通過逗號表達(dá)式對 “1” 所在的部分進(jìn)行擴(kuò)展：

（i--） ？ （before（）， 1） //！《 使用逗哈表達(dá)式進(jìn)行擴(kuò)展： 0

由于逗號表達(dá)式只管 最右邊的結(jié)果，忽略所有左邊的返回值，因此，哪怕before（）函數(shù)沒有實(shí)際返回值對C編譯器來說都是無所謂的。同理，由于我們在cond_expression部分已經(jīng)完成了所有功能，因此 iteration_expression 就任由我們宰割了——編譯器原本就對此處表達(dá)式所產(chǎn)生的數(shù)值并不感興——我們直接放下 after（） 函數(shù)即可。

至此，插入 before（） 和 after（） 的問題圓滿解決。

問題二：如何允許用戶定義自己的局部變量，并且擁有自己的類型

要解決這個(gè)問題，首先必須打破定勢思維，即：for循環(huán)只能用整型變量。實(shí)際并非如此，對for來說真正起作用的只有 cond_expression 的返回值，而它只關(guān)心用戶的表達(dá)式返回的 布爾量 是什么——換句話說，有無數(shù)種方法來產(chǎn)生 cond_expression，而使用普通的整形計(jì)數(shù)器，并對其進(jìn)行判斷只是眾多方法中的一種。

打破了這一定勢思維后，我們就從問題本身出發(fā)考慮：允許用戶用自己的類型定義自己的變量——雖然看似我們并不能知道用戶會用什么類型來定義變量，因而就無法寫出通用的 cond_expression 來實(shí)現(xiàn)“讓for執(zhí)行且執(zhí)行一次”的功能，然而，你們也許忘記了 init_clause 的一個(gè)特點(diǎn)：它還可以定義指針——換句話說，無論用戶定義了什么類型，我們都可以在最后定義一個(gè)指向該類型的指針：

#define using（__declare， __on_enter_expr， __on_leave_expr） \ for （__declare， *_ptr = NULL; \ _ptr++ == NULL ？ \ （（__on_enter_expr），1） ： 0; \ __on_leave_expr \ ）

為了驗(yàn)證我們的結(jié)果，不妨寫一個(gè)簡單的代碼：

using（int a = 0，printf（“========= On Enter =======\r\n”）， printf（“========= On Leave =======\r\n”）） { printf（“\t In Body a=%d \r\n”， ++a）;}

這是對應(yīng)的執(zhí)行效果：

我們不妨將上述的宏進(jìn)行展開，一個(gè)可能的結(jié)果是：

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 的展開結(jié)果來看，完全符合要求：

int a = 0， *_ptr = NULL;

接下來，為了提高宏的魯棒性，我們可以繼續(xù)做一些改良，比如給指針一個(gè)唯一的名字：

#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 \ ）

這里，實(shí)際上是使用了前面文章中介紹的宏 CONNECT3（） 將 “__using_”，__LINE__所表示的當(dāng)前行號，以及 “_ptr” 粘連在一起，形成一個(gè)唯一的局部變量名：

CONNECT3（__using_， __LINE__，_ptr）

如果你對 CONNECT（） 宏的來龍去脈感興趣，可以單擊這里。

更進(jìn)一步，如果用戶有不同的需求：比如想定義兩個(gè)以上的局部變量，或是想省確 __on_enter_expr 或者是 __on_leave_expr ——我們完全可以定義多個(gè)不同版本的 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 \ ）

借助宏的重載技術(shù)，我們可以根據(jù)用戶輸入的參數(shù)數(shù)量自動選擇正確的版本：

#define using（。..） \ CONNECT2（__using， VA_NUM_ARGS（__VA_ARGS__））（__VA_ARGS__）

至此，我們完成了對 for 的改造，并提出了__using1， __using2， __using3 和 __using4 四個(gè)版本變體。那么問題來了，他們分別有什么用處呢？

【提供不阻礙調(diào)試的代碼封裝】

前面的文章中，我們曾有意無意的提供過一個(gè)實(shí)現(xiàn)原子操作的封裝：即在代碼的開始階段關(guān)閉全局中斷并記錄此前的中斷狀態(tài)；執(zhí)行用戶代碼后，恢復(fù)關(guān)閉中斷前的狀態(tài)。其代碼如下：

#define SAFE_ATOM_CODE（。..） \{ \ uint32_t CONNECT2（temp， __LINE__） = __disable_irq（）; \ __VA_ARGS__ \ __set_PRIMASK（（CONNECT2（temp， __LINE__）））; \}

因此可以很容易的通過如下的代碼來保護(hù)關(guān)鍵的寄存器操作：

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

唯一的問題是，這樣的寫法，在調(diào)試時(shí)完全沒法在用戶代碼處添加斷點(diǎn)（編譯器會認(rèn)為宏內(nèi)所有的內(nèi)容都寫在了同一行），這是大多數(shù)人不喜歡使用宏來封裝代碼結(jié)構(gòu)的最大原因。借助 __using2，我們可以輕松的解決這個(gè)問題：

#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的本質(zhì)是 for 循環(huán)，因?yàn)槲覀兛梢酝ㄟ^花括號的形式來包裹用戶代碼，因此，可以很方便的在用戶代碼中添加斷點(diǎn)，單步執(zhí)行。至于原子保護(hù)的功能，我們不妨將上述代碼進(jìn)行宏展開：

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

通過觀察，容易發(fā)現(xiàn)，這里巧妙使用 init_clause 給 temp154 變量進(jìn)行賦值——在關(guān)閉中斷的同時(shí)保存了此前的狀態(tài)；并在原本 after 的位置放置了 恢復(fù)中斷的語句 __set_PRIMASK（temp154）。

舉一反三，此類方法除了用來開關(guān)中斷以外，還可以用在以下的場合：

在OOPC中自動創(chuàng)建類，并使用 before 部分來執(zhí)行構(gòu)造函數(shù)；在 after 部分完成 類的析構(gòu)。

在外設(shè)操作中，在 init_clause 部分定義指向外設(shè)的指針；在 before部分 Enable或者Open外設(shè)；在after部分Disable或者Close外設(shè)。

在RTOS中，在 before 部分嘗試進(jìn)入臨界區(qū)；在 after 部分釋放臨界區(qū)

在文件操作中，在 init_clause 部分嘗試打開文件，并獲得句柄；在 after 部分自動 close 文件句柄。

在有MPU進(jìn)行內(nèi)存保護(hù)的場合，在 before 部分，重新配置MPU獲取目標(biāo)地址的訪問權(quán)限；在 after部分再次配置MPU，關(guān)閉對目標(biāo)地址范圍的訪問權(quán)限。

……

【構(gòu)造with塊】

不知道你們在實(shí)際應(yīng)用中有沒有遇到一連串指針訪問的情形——說起來就好比是：

你鄰居的-》朋友的-》親戚家的-》一個(gè)狗的-》保姆的-》手機(jī)

如果我們要操作這里的“手機(jī)”，實(shí)在是不想每次都寫這么一長串“惡心”的東西，為了應(yīng)對這一問題，Visual Basic（其實(shí)最早是Quick Basic）引入了一個(gè)叫做 WITH 塊的概念，它的用法如下：

WITH 你鄰居的-》朋友的-》親戚家的-》一個(gè)狗的-》保姆的-》手機(jī) # 這里可以直接訪問手機(jī)的各項(xiàng)屬性，用 “?！?開頭就行 。 手機(jī)殼顏色 = xxxxx 。 貼膜 = 玻璃膜END WITH

不光是Visual Basic，我們使用C語言進(jìn)行大規(guī)模的應(yīng)用開發(fā)時(shí)，或多或少也會遇到同樣的情況，比如，配置 STM32 外設(shè)時(shí)，填寫外設(shè)配置結(jié)構(gòu)體的時(shí)候，每一行都要重新寫一遍結(jié)構(gòu)體變量的名字，也是在是很繁瑣：

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

遺憾的是，如果要完全實(shí)現(xiàn)上述的結(jié)構(gòu)，在C語言中是不可能的，但借助我們的 using（） 結(jié)構(gòu)，我們可以做到一定程度的模擬：

#define with（__type， __addr） using（__type *_p=（__addr））#define _ （*_p）

在這里，我們要至少提供目標(biāo)對象的類型，以及目標(biāo)對象的地址：

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

注意到，這里“_”實(shí)際上被用來替代 s_UARTHandle——雖然感覺有點(diǎn)不夠完美，但考慮到腳本語言 perl 有長期使用 “_” 表示本地對象的傳統(tǒng)，這樣一看，似乎“_” 就是一個(gè)對 “perl” 的完美致敬了。

【回歸本職 foreach】

很多高級語言都有專門的 foreach 語句，用來實(shí)現(xiàn)對數(shù)組（或是鏈表）中的元素進(jìn)行逐一訪問。原生態(tài)C語言并沒有這種奢侈，即便如此，Linux也定義了一個(gè)“野生”的 foreach 來實(shí)現(xiàn)類似的功能。為了演示如何使用 using 結(jié)構(gòu)來構(gòu)造 foreach，我們不妨來看一個(gè)例子：

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

我們希望實(shí)現(xiàn)一個(gè)函數(shù)，能通過 foreach 自動的訪問數(shù)組 s_tItem 的所有成員，比如：

foreach（example_lv0_t， s_tItem） { printf（“Processing item with ID = %d\r\n”， _.chID）;}

跟With塊一樣，這里我們?nèi)匀弧爸戮础?perl——使用 “_” 表示當(dāng)前循環(huán)下的元素。在這個(gè)例子中，為了使用 foreach，我們需要提供至少兩個(gè)信息：目標(biāo)數(shù)組元素的類型（example_lv0_t）和目標(biāo)數(shù)組（s_tItem）。

這里的難點(diǎn)在于，如何定義一個(gè)局部的指針，并且它的作用范圍僅僅只覆蓋 foreach 的循環(huán)體。此時(shí)，坐在角落里的 __with1（） 按耐不住了，高高的舉起了雙手——是的，它僅有的功能就是允許用戶定義一個(gè)局部變量，并覆蓋由第三方所編寫的、由 {} 包裹的區(qū)域：

#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__）-- \ ）

上述的宏并不復(fù)雜，大家完全可以自己看懂，唯一需要強(qiáng)調(diào)的是，using（） 的本質(zhì)是一個(gè)for，因此__using1（） 下方的for 實(shí)際上是位于由 __using1（） 所提供的循環(huán)體內(nèi)的，也就是說，這里的局部變量_p其作用域也覆蓋 下面的for 循環(huán)，這就是為什么我們可以借助：

#define _ （*_p）

的巧妙代換，通過 “_” 來完成對指針“_p”的使用。為了方便大家理解，我們不妨將前面的例子代碼進(jìn)行宏展開：

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

其執(zhí)行結(jié)果為：

foreach目前的用法看起來“歲月靜好”，似乎沒有什么問題，可惜的是，一旦進(jìn)行實(shí)際的代碼編寫，我們會發(fā)現(xiàn)，假如我們要在 foreach 結(jié)構(gòu)中再用一個(gè)foreach，或是在foreach中使用 with 塊，就會出現(xiàn) “_” 被覆蓋的問題——也就是在里層的 foreach或是 with 無法通過 “_” 來訪問外層“_” 所代表的對象。為了應(yīng)對這一問題，我們可以對 foreach 進(jìn)行一個(gè)小小的改造——允許用戶再指定一個(gè)專門的局部變量，用于替代“_” 表示當(dāng)前循環(huán)下的對象：

#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個(gè)參數(shù)，其中最后一個(gè)參數(shù)就是用來由用戶“額外”指定新的指針的；與之相對，老版本的foreach我們稱之為 foreach2，因?yàn)樗恍枰獌蓚€(gè)參數(shù)，只能使用“_”作為對象的指代。進(jìn)一步的，我們可以使用宏的重載來簡化用戶的使用：

#define foreach（。..） \ CONNECT2（foreach， VA_NUM_ARGS（__VA_ARGS__））（__VA_ARGS__）

經(jīng)過這樣的改造，我們可以用下面的方法來為我們的循環(huán)指定一個(gè)叫做“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）; }

代碼已經(jīng)做了適當(dāng)?shù)恼归_和縮進(jìn)，這里就不作進(jìn)一步的分析了。

【后記】

本文的目的，算是對【為宏正名】系列所介紹的知識進(jìn)行一次示范——告訴大家如何正確的使用宏，配合已有的老的語法結(jié)構(gòu)來“固化”一個(gè)新的模板，并以這個(gè)模板為起點(diǎn)，理解它的語法意義和用戶，簡化我們的日常開發(fā)。在這篇文章中，老的語法結(jié)構(gòu)就是 for，它是由C語言原生支持的，借助宏，我們封裝了一個(gè)新的語法結(jié)構(gòu) using（）， 借助它的4種不同形式、理解它們各自的特點(diǎn)，我們又分別封裝了非常實(shí)用的SAFE_ATOM_CODE（），With塊和foreach語法結(jié)構(gòu)——他們的存在至少證明了以下幾點(diǎn)：

宏不是奇技淫巧

宏可以封裝出其它高級語言所提供的“基礎(chǔ)設(shè)施”

設(shè)計(jì)良好的宏可以提升代碼的可讀性，而不是破壞它

設(shè)計(jì)良好的宏并不會影響調(diào)試

宏可以用來固化某些模板，避免每次都重新編寫復(fù)雜的語法結(jié)構(gòu)，在這里，using（） 模板的出現(xiàn)，避免了我們每次都重復(fù)通過原始的 for 語句來構(gòu)造所需的語法結(jié)構(gòu)，極大的避免了重復(fù)勞動，以及由重復(fù)勞動所帶來的出錯風(fēng)險(xiǎn)