你好，歡迎來到IOS教程網
設為首頁加入收藏

首頁
IOS基礎知識
IOS使用技巧
IOS編程開發
IOS教程
IOS訊息
 Ios教程網 >> IOS編程開發 >> IOS開發基礎 >> ReactiveCocoa 中 奇妙無比的“宏”魔法

ReactiveCocoa 中 奇妙無比的“宏”魔法

編輯：IOS開發基礎

前言

在ReactiveCocoa 中，開源庫作者為我們提供了很多種魔法，“黑”魔法，“紅”魔法……今天就讓先來看看“紅”魔法。

在ReactiveCocoa 中，封裝了很多非常實用的“宏”，使用這些“宏”為我們開發帶來了很多的便利。

今天就來盤點一下RAC中的宏是如何實現的。

目錄

1.關於宏

2.ReactiveCocoa 中的元宏

3.ReactiveCocoa 中常用的宏

一. 關於宏

宏（Macro），是一種批量處理的稱謂。

在編程領域裡的宏是一種抽象（Abstraction），它根據一系列預定義的規則替換一定的文本模式。解釋器或編譯器在遇到宏時會自動進行這一模式替換。絕大多數情況下，“宏”這個詞的使用暗示著將小命令或動作轉化為一系列指令。

宏的用途在於自動化頻繁使用的序列或者是獲得一種更強大的抽象能力。

計算機語言如C語言或匯編語言有簡單的宏系統，由編譯器或匯編器的預處理器實現。C語言的宏預處理器的工作只是簡單的文本搜索和替換，使用附加的文本處理語言如M4，C程序員可以獲得更精巧的宏。

Lisp類語言如Common Lisp和Scheme有更精巧的宏系統：宏的行為如同是函數對自身程序文本的變形，並且可以應用全部語言來表達這種變形。一個C宏可以定義一段語法的替換，然而一個Lisp的宏卻可以控制一節代碼的計算。

對於編譯語言來說，所有的宏都是在預編譯的時候被展開的，所以在lex進行詞法掃描生成Token，詞法分析過程之前，所有的宏都已經被展開完成了。

對於Xcode，預處理或者預編譯階段是可以直接查看的。

01.png

隨便寫一個宏，然後打開Xcode右上方的Assistant，選擇“Preprocess”就可以看到該文件預處理之後的樣子了。可以看到左邊的@weakify(self) 被轉換成了右邊的兩行代碼了。

關於這個Xcode的這個功能還有2點補充說明：

1.不同階段的Preprocessed可能不同，要根據你的目標去選擇預處理的條件。

02.jpg

比如這裡就有5種預編譯的種類可以選擇。

2.宏經過預編譯之後出來的代碼，是可以用來檢測宏寫的是否正確的，但是無法看到宏被展開的具體過程。這意味著我們可以通過Xcode這個功能來查看宏的作用，但是無法知道宏的具體實現。具體實現還是需要通過查看源碼來分析。

ReactiveCocoa中的宏，如果不查看源碼分析，會覺得那些宏都像魔法一樣奇妙無比，接下來就來解開“宏”魔法的神秘面紗。

二. ReactiveCocoa 中的元宏

QQ截圖20170214110232.png

在ReactiveCocoa的宏中，作者定義了這麼一些基礎的宏，作為“元宏”，它們是構成之後復雜宏的基礎。在分析常用宏之前，必須要先分析清楚這些元宏的具體實現。

1. metamacro_stringify(VALUE)

#define metamacro_stringify(VALUE) \
        metamacro_stringify_(VALUE)
        
#define metamacro_stringify_(VALUE) # VALUE

metamacro_stringify( )這個宏用到了#的用法。#在宏中代表把宏的參數變為一個字符串。這個宏的目的和它的名字一樣明顯，把入參VALUE轉換成一個字符串返回。

這裡可能就有人有疑問，為啥要包裝一層，不能直接寫成下面這樣：

#define metamacro_stringify(VALUE)  # VALUE

語意確實也沒有變，但是有種特殊情況下就會出現問題。

舉個例子：

#define NUMBER   10
#define ADD(a,b) (a+b)
NSLog(@"%d+%d=%d",NUMBER, NUMBER, ADD(NUMBER,NUMBER));

輸出如下：

10+10=20

這樣子確實是沒有問題，但是稍作修改就會有問題。

#define STRINGIFY(S) #S
#define CALCULATE(A,B)  (A##10##B)

NSLog(@"int max: %s",STRINGIFY(INT_MAX));
NSLog(@"%d", CALCULATE(NUMBER,NUMBER));

如果是這種情況下，第二個NSLog打印是會編譯錯誤的。上面兩句經過預編譯之後，宏會被展開成下面這個樣子：

NSLog(@"int max: %s","INT_MAX");
NSLog(@"%d", (NUMBER10NUMBER));

可以發現，宏並沒有再次被展開。解決辦法也很簡單，就是把宏包裝一層，寫一個轉接宏出來。

#define CALCULATE(A,B)   _CALCULATE(A,B)   // 轉換宏
#define _CALCULATE(A,B)  A##10##B

再次測試一下，這裡我們使用官方的metamacro_stringify

NSLog(@"int max: %s",metamacro_stringify(INT_MAX));
NSLog(@"%d", CALCULATE(NUMBER,NUMBER));

這樣最終打印出來的結果和我們想要的一致，沒有問題。

2147483647
101010

CALCULATE(NUMBER,NUMBER) 第一層轉換成 _CALCULATE(10,10)，接著第二次轉換成10##10##10，也就是101010。

當然這裡是2層轉換，如果有多層轉換就需要更多個轉換宏了。

NSLog(@"%d", CALCULATE(STRINGIFY(NUMBER),STRINGIFY(NUMBER)));

上面這個例子就是3層了，按照之前我們的寫法還是編譯報錯。如果是超過2，3層的多層的情況，就該考慮考慮宏設計的語意的問題，盡量不讓使用者產生錯誤的用法。

2. metamacro_concat(A, B)

#define metamacro_concat(A, B) \
        metamacro_concat_(A, B)
#define metamacro_concat_(A, B) A ## B

這個宏就是用來合並入參A，B到一起。在RAC裡面主要用這個方法來合成另外一個宏的名字。

3. metamacro_argcount(...) 和 metamacro_at(N, ...)

metamacro_argcount(...)這個宏設計的也非常巧妙，它是用來獲取參數個數的。由於宏展開是在預編譯時期的，所以它在預編譯時期獲取參數個數的，其他非宏的方法都是在運行時獲取參數個數的。

#define metamacro_argcount(...) \
        metamacro_at(20, __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

這裡會調用metamacro_at(N, ...)宏。

#define metamacro_at(N, ...) \
        metamacro_concat(metamacro_at, N)(__VA_ARGS__)

把這個宏展開，於是得到：

#define metamacro_at(N, ...) \
        metamacro_atN(__VA_ARGS__)

於是通過metamacro_concat合成命令，就得到了一連串的metamacro_atN宏命令：

#define metamacro_at0(...) metamacro_head(__VA_ARGS__)
#define metamacro_at1(_0, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at2(_0, _1, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at3(_0, _1, _2, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at4(_0, _1, _2, _3, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at5(_0, _1, _2, _3, _4, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at6(_0, _1, _2, _3, _4, _5, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at7(_0, _1, _2, _3, _4, _5, _6, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at8(_0, _1, _2, _3, _4, _5, _6, _7, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at9(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at11(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at12(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at13(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at14(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at15(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at17(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at19(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) metamacro_head(__VA_ARGS__)
#define metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) metamacro_head(__VA_ARGS__)

可見N的取值只能從0到20。

#define metamacro_head(...) \
        metamacro_head_(__VA_ARGS__, 0)
#define metamacro_head_(FIRST, ...) FIRST

metamacro_head展開之後變成：

#define metamacro_head(FIRST,..., 0)  FIRST

metamacro_head的意圖就很明顯，是用來獲取後面可變入參的第一個參數。

回到metamacro_atN宏上面來，那麼把它展開就是下面這樣：

#define metamacro_atN(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ... , _N, ...) metamacro_head(__VA_ARGS__)

當然，N的取值還是從0到20，那麼metamacro_atN宏獲取到的值就是可變參數列表裡面的第N個參數值。參數從0開始。

再回到最初的metamacro_argcount(...)宏，目前展開到這一步：

#define metamacro_argcount(...) \
        metamacro_at20(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

由於__VA_ARGS__個數不能超過20個，所以必定是在0-19之間。

metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ..., 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) metamacro_head(__VA_ARGS__)

假設入參是有5個：

metamacro_argcount(@"1",@"2",@"3",@"4",@"5");

先把5個參數放入metamacro_at20的前五個位置。然後從第6個位置開始倒序插入20-1的數字。如下圖：

QQ截圖20170214110605.png

我們可以把倒序的數字想象成一把尺子，是用來衡量或者指示當前有多少個參數的。尺子的最左邊對齊上面20個空位的第一位，尺子後面多出來的部分，取出來，然後進行metamacro_head操作，取出第一位參數，這個數字就是整個參數的個數了。這把虛擬的“尺子”是會左右對齊的，具體的位置就要根據填入參數的個數來決定的。

這個宏的原理也很簡單，20 - （ 20 - n ）= n。metamacro_argcount(...) 宏就是這樣在預編譯時期獲取到參數個數的。

作者也標明了，這個宏的設計靈感來自於P99神庫，有興趣的同學可以去看看這個庫。

4. metamacro_foreach(MACRO, SEP, ...) 和 metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)

先來分析分析metamacro_foreach(MACRO, SEP, ...) 宏：

#define metamacro_foreach(MACRO, SEP, ...) \
        metamacro_foreach_cxt(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)

看到定義就知道metamacro_foreach(MACRO, SEP, ...) 和 metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) 是一樣的作用。前者只不過比後者少了一個foreach的迭代子。

1. metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏

再來看看metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的定義。

#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) \
        metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)

那麼之前的metamacro_foreach(MACRO, SEP, ...)宏就可以等價於

metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)

回到metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的展開表達式上面來，假設__VA_ARGS__的參數個數為N。

metamacro_concat 宏 和 metamacro_argcount 宏上面介紹過了，那麼可以繼續把宏展開成下面的樣子：

metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, __VA_ARGS__)

這裡又是利用metamacro_concat 宏動態的合並成了另一個宏的例子。

#define metamacro_foreach_cxt0(MACRO, SEP, CONTEXT)
#define metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0)

#define metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \
    metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) \
    SEP \
    MACRO(1, CONTEXT, _1)

#define metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \
    metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \
    SEP \
    MACRO(2, CONTEXT, _2)
    
#define metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
    metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \
    SEP \
    MACRO(3, CONTEXT, _3)
    
#define metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
    metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
    SEP \
    MACRO(4, CONTEXT, _4)
    
#define metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
    metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
    SEP \
    MACRO(5, CONTEXT, _5)
    
#define metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
    metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
    SEP \
    MACRO(6, CONTEXT, _6)
    
#define metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
    metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
    SEP \
    MACRO(7, CONTEXT, _7)
    
#define metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
    metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
    SEP \
    MACRO(8, CONTEXT, _8)
    
#define metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
    metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
    SEP \
    MACRO(9, CONTEXT, _9)
    
#define metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
    metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
    SEP \
    MACRO(10, CONTEXT, _10)
    
#define metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
    metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
    SEP \
    MACRO(11, CONTEXT, _11)
    
#define metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
    metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
    SEP \
    MACRO(12, CONTEXT, _12)
    
#define metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
    metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
    SEP \
    MACRO(13, CONTEXT, _13)
    
#define metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
    metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
    SEP \
    MACRO(14, CONTEXT, _14)
    
#define metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
    metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
    SEP \
    MACRO(15, CONTEXT, _15)
    
#define metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
    metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
    SEP \
    MACRO(16, CONTEXT, _16)
    
#define metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
    metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
    SEP \
    MACRO(17, CONTEXT, _17)
    
#define metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
    metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
    SEP \
    MACRO(18, CONTEXT, _18)
    
#define metamacro_foreach_cxt20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \
    metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
    SEP \
    MACRO(19, CONTEXT, _19)

把上述的metamacro_foreach_cxtN的定義抽象一下：

#define metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, … ,_N - 1) \
    metamacro_foreach_cxtN - 1(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, … ,_N - 2) \
    SEP \
    MACRO(N - 1, CONTEXT, _N - 1)

當然，在RAC中N的取值范圍是[0,20]。我們還是假設N的定義域是全體非負整數組成的集合N(數學中的非負整數集合的標志) 。那麼我們把metamacro_foreach_cxtN完全展開到不能展開為止：

    MACRO(0, CONTEXT, _0) \
    SEP \
    MACRO(1, CONTEXT, _1) \
    SEP \
    MACRO(2, CONTEXT, _2) \
    SEP \
    MACRO(3, CONTEXT, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    MACRO(N - 4, CONTEXT, _N - 4) \
     SEP \
    MACRO(N - 3, CONTEXT, _N - 3) \
     SEP \
    MACRO(N - 2, CONTEXT, _N - 2) \
     SEP \
    MACRO(N - 1, CONTEXT, _N - 1)

metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, ...)，這個宏的意圖也就很明顯了，從可變參數列表裡面讀取出個數，然後把每個參數都進行一次MACRO(N - 1, CONTEXT, _N - 1)操作，每個操作直接用SEP作為分隔符進行分隔。

metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)這個宏的設計靈感也來自於P99庫。

00.png

用到這個宏最著名的的宏就是weakify(...)了，下面來簡要的看看是如何利用metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, ...)巧妙的實現weakify(...)的。

#define weakify(...) \
    rac_keywordify \
    metamacro_foreach_cxt(rac_weakify_,, __weak, __VA_ARGS__)

使用weakify和平時我們自己寫的weakSelf最大的區別就是，weakify後面是可以跟多個參數的，最多多達20個。weakify可以一口氣把參數列表裡面所有的參數都進行weak操作。

weakify(...)的重點之一就在metamacro_foreach_cxt操作上。假設傳入2個參數，self和str，進行展開之後得到：

    MACRO(0, CONTEXT, _0) \
    SEP \
    MACRO(1, CONTEXT, _1)

MACRO = rac_weakify_，CONTEXT = __weak，SEP 為 空格 ，代入參數：

 rac_weakify_(0,__weak,self) \
 rac_weakify_(1,__weak,str)

注意，替換完成之後，兩個宏是連在一起的，中間沒有分號！分隔符SEP目前是空格。最後一步就是替換掉rac_weakify_：

#define rac_weakify_(INDEX, CONTEXT, VAR) \
    CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);

注意這裡的INDEX是廢參數，並沒有被用到。

展開上面的宏：

__weak __typeof__(self) self_weak_ = (self)；__weak __typeof__(str) str_weak_ = (str)；

注意，rac_weakify_是自帶分號的，如果此處沒有分號，這裡會出現編譯錯誤。

最終@weakify(self，str) 就會在預編譯期間被替換成

@autoreleasepool {} __weak __typeof__(self) self_weak_ = (self)；__weak __typeof__(str) str_weak_ = (str)；

注意中間是沒有換行的，此處宏展開之後就是一行。

metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)分析完畢之後再回過來看看metamacro_foreach(MACRO, SEP, ...)

2. metamacro_foreach(MACRO, SEP, ...)

metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)

此時同樣可以假設參數個數為N，那麼上述宏展開可以變成下面的樣子：

metamacro_foreach_cxtN(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)

這裡的MACRO = metamacro_foreach_iter，SEP = SEP ， CONTEXT = MACRO。

    metamacro_foreach_iter(0, MACRO, _0) \
    SEP \
    metamacro_foreach_iter(1, MACRO, _1) \
    SEP \
    metamacro_foreach_iter(2, MACRO, _2) \
    SEP \
    metamacro_foreach_iter(3, MACRO, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    metamacro_foreach_iter(N - 4, MACRO, _N - 4) \
     SEP \
    metamacro_foreach_iter(N - 3, MACRO, _N - 3) \
     SEP \
    metamacro_foreach_iter(N - 2, MACRO, _N - 2) \
     SEP \
    metamacro_foreach_iter(N - 1, MACRO, _N - 1)

metamacro_foreach_iter 定義如下：

#define metamacro_foreach_iter(INDEX, MACRO, ARG) MACRO(INDEX, ARG)

繼續展開得到下面的式子：

  MACRO(0, _0) \
    SEP \
    MACRO(1, _1) \
    SEP \
    MACRO(2, _2) \
    SEP \
    MACRO(3, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    MACRO(N - 4, _N - 4) \
     SEP \
    MACRO(N - 3, _N - 3) \
     SEP \
    MACRO(N - 2, _N - 2) \
     SEP \
    MACRO(N - 1, _N - 1)

12.png

從最終的展開式子上來看，metamacro_foreach(MACRO, SEP, ...) 就比 metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) 少了一個CONTEXT。

metamacro_foreach(MACRO, SEP, ...)這個宏的典型例子就是熟知的strongify(...)的實現。

#define strongify(...) \
    rac_keywordify \
    _Pragma("clang diagnostic push") \
    _Pragma("clang diagnostic ignored \"-Wshadow\"") \
    metamacro_foreach(rac_strongify_,, __VA_ARGS__) \
    _Pragma("clang diagnostic pop")

通過上面的分析，我們直接替換結果，MACRO = rac_strongify_ ，SEP = 空格。

    rac_strongify_(0, _0) \
    rac_strongify_(1, _1) \
    rac_strongify_(2, _2) \
    rac_strongify_(3, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
    rac_strongify_(N - 4, _N - 4) \
    rac_strongify_(N - 3, _N - 3) \
    rac_strongify_(N - 2, _N - 2) \
    rac_strongify_(N - 1, _N - 1)

接下來替換掉rac_strongify_

#define rac_strongify_(INDEX, VAR) \
    __strong __typeof__(VAR) VAR = metamacro_concat(VAR, _weak_);

同樣的，這裡的INDEX也是一個廢參數，也沒有用到。rac_strongify_同樣的自帶分號，如果此處沒有分號，SEP此時也是空格，編譯就直接報錯。

最終就轉換成如下的樣子：

__strong __typeof__(self) self = self_weak_;

5. metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...)

先來看看定義：

#define metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...) \
        metamacro_concat(metamacro_foreach_cxt_recursive, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)

假設可變參數個數為N，將上面式子展開：

#define metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...) \
        metamacro_foreach_cxt_recursiveN(MACRO, SEP, CONTEXT, __VA_ARGS__)

於是就轉換成了metamacro_foreach_cxt_recursiveN 宏：

#define metamacro_foreach_cxt_recursive0(MACRO, SEP, CONTEXT)
#define metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0)

#define metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \
    metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) \
    SEP \
    MACRO(1, CONTEXT, _1)
    
#define metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \
    metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \
    SEP \
    MACRO(2, CONTEXT, _2)
    
#define metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
    metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \
    SEP \
    MACRO(3, CONTEXT, _3)
    
#define metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
    metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \
    SEP \
    MACRO(4, CONTEXT, _4)
    
#define metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
    metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \
    SEP \
    MACRO(5, CONTEXT, _5)
    
#define metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
    metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \
    SEP \
    MACRO(6, CONTEXT, _6)
    
#define metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
    metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \
    SEP \
    MACRO(7, CONTEXT, _7)
    
#define metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
    metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \
    SEP \
    MACRO(8, CONTEXT, _8)
    
#define metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
    metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \
    SEP \
    MACRO(9, CONTEXT, _9)
    
#define metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
    metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \
    SEP \
    MACRO(10, CONTEXT, _10)
    
#define metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
    metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
    SEP \
    MACRO(11, CONTEXT, _11)
    
#define metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
    metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \
    SEP \
    MACRO(12, CONTEXT, _12)
    
#define metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
    metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \
    SEP \
    MACRO(13, CONTEXT, _13)
    
#define metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
    metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \
    SEP \
    MACRO(14, CONTEXT, _14)
    
#define metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
    metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \
    SEP \
    MACRO(15, CONTEXT, _15)
    
#define metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
    metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \
    SEP \
    MACRO(16, CONTEXT, _16)
    
#define metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
    metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \
    SEP \
    MACRO(17, CONTEXT, _17)
    
#define metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
    metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \
    SEP \
    MACRO(18, CONTEXT, _18)
    
#define metamacro_foreach_cxt_recursive20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \
    metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \
    SEP \
    MACRO(19, CONTEXT, _19)

提取一下metamacro_foreach_cxt_recursiveN的定義：

#define metamacro_foreach_cxt_recursiveN(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, … ，_( N - 1)) \
        metamacro_foreach_cxt_recursive(N - 1)(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _( N - 2)) \
        SEP \
        MACRO(N -1, CONTEXT, _N -1)

還是按照之前分析的，同理完全展開：

    MACRO(0, CONTEXT, _0) \
    SEP \
    MACRO(1, CONTEXT, _1) \
    SEP \
    MACRO(2, CONTEXT, _2) \
    SEP \
    MACRO(3, CONTEXT, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    MACRO(N - 4, CONTEXT, _N - 4) \
     SEP \
    MACRO(N - 3, CONTEXT, _N - 3) \
     SEP \
    MACRO(N - 2, CONTEXT, _N - 2) \
     SEP \
    MACRO(N - 1, CONTEXT, _N - 1)

至此，展開式與metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏完全相同。

這個遞歸的宏從來沒有在RAC的其他宏中使用，作者在這裡標注說明了這個宏的用處。

This can be used when the former would fail due to recursive macro expansion

由於宏在遞歸展開中可能會導致遞歸前置條件失敗，在這種情況下，應該使用這個遞歸宏。當然，它的效果和metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏是完全一樣的。

6. metamacro_foreach_concat(BASE, SEP, ...)

這個宏定義是套用了metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的實現，只是多傳入了一些參數。由此可見，metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏在RAC中的重要性。

#define metamacro_foreach_concat(BASE, SEP, ...) \
        metamacro_foreach_cxt(metamacro_foreach_concat_iter, SEP, BASE, __VA_ARGS__)

由於在上面詳細分析過了metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的實現，那麼這裡就直接完全展開到最後一步。MACRO = metamacro_foreach_concat_iter，SEP = SEP，CONTEXT = BASE。

    metamacro_foreach_concat_iter(0, BASE, _0) \
    SEP \
    metamacro_foreach_concat_iter(1, BASE, _1) \
    SEP \
    metamacro_foreach_concat_iter(2, BASE, _2) \
    SEP \
    metamacro_foreach_concat_iter(3, BASE, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    metamacro_foreach_concat_iter(N - 4, BASE, _N - 4) \
     SEP \
    metamacro_foreach_concat_iter(N - 3, BASE, _N - 3) \
     SEP \
    metamacro_foreach_concat_iter(N - 2, BASE, _N - 2) \
     SEP \
    metamacro_foreach_concat_iter(N - 1, BASE, _N - 1)

到了這一步，就需要繼續展開metamacro_foreach_concat_iter

#define metamacro_foreach_concat_iter(INDEX, BASE, ARG) metamacro_foreach_concat_iter_(BASE, ARG)

#define metamacro_foreach_concat_iter_(BASE, ARG) BASE ## ARG

這裡的2個宏，就用到了之前說道的轉接宏的概念，因為需要把第一個參數剔除，所以需要寫一個轉接宏，轉換一次踢掉第一個參數。

最終完全展開就是下面的樣子：

    BASE_0 \
    SEP \
    BASE_1 \
    SEP \
    BASE_2 \
    SEP \
    BASE_3 \
     ……
     ……
     ……
     ……
     ……
     ……
     
    SEP \
    BASE_N - 4 \
    SEP \
    BASE_N - 3 \
    SEP \
    BASE_N - 2 \
    SEP \
    BASE_N - 1

metamacro_foreach_concat(BASE, SEP, ...)宏如同它的名字一樣，把可變參數裡面每個參數都拼接到BASE後面，每個參數拼接完成之間都用SEP分隔。

試想一種場景：

如果有一連串的方法，方法名都有一個相同的前綴，後面是不同的。這種場景下，利用metamacro_foreach_concat(BASE, SEP, ...)宏是非常爽的，它會一口氣組合出相關的一列表的不同的宏。

7. metamacro_for_cxt(COUNT, MACRO, SEP, CONTEXT)

定義如下：

#define metamacro_for_cxt(COUNT, MACRO, SEP, CONTEXT) \
        metamacro_concat(metamacro_for_cxt, COUNT)(MACRO, SEP, CONTEXT)

metamacro_concat 之前分析過，展開這一層：

metamacro_for_cxtN(MACRO, SEP, CONTEXT)

metamacro_for_cxtN的定義如下：

#define metamacro_for_cxt0(MACRO, SEP, CONTEXT)
#define metamacro_for_cxt1(MACRO, SEP, CONTEXT) MACRO(0, CONTEXT)

#define metamacro_for_cxt2(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt1(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(1, CONTEXT)
    
#define metamacro_for_cxt3(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt2(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(2, CONTEXT)
    
#define metamacro_for_cxt4(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt3(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(3, CONTEXT)
    
#define metamacro_for_cxt5(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt4(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(4, CONTEXT)
    
#define metamacro_for_cxt6(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt5(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(5, CONTEXT)
    
#define metamacro_for_cxt7(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt6(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(6, CONTEXT)
    
#define metamacro_for_cxt8(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt7(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(7, CONTEXT)
    
#define metamacro_for_cxt9(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt8(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(8, CONTEXT)
    
#define metamacro_for_cxt10(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt9(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(9, CONTEXT)
    
#define metamacro_for_cxt11(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt10(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(10, CONTEXT)
    
#define metamacro_for_cxt12(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt11(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(11, CONTEXT)
    
#define metamacro_for_cxt13(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt12(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(12, CONTEXT)
    
#define metamacro_for_cxt14(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt13(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(13, CONTEXT)
    
#define metamacro_for_cxt15(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt14(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(14, CONTEXT)
    
#define metamacro_for_cxt16(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt15(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(15, CONTEXT)
    
#define metamacro_for_cxt17(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt16(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(16, CONTEXT)
    
#define metamacro_for_cxt18(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt17(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(17, CONTEXT)
    
#define metamacro_for_cxt19(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt18(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(18, CONTEXT)
    
#define metamacro_for_cxt20(MACRO, SEP, CONTEXT) \
    metamacro_for_cxt19(MACRO, SEP, CONTEXT) \
    SEP \
    MACRO(19, CONTEXT)

提取一下metamacro_for_cxtN的定義：

#define metamacro_for_cxtN(MACRO, SEP, CONTEXT) \
        metamacro_for_cxtN - 1(MACRO, SEP, CONTEXT) \
        SEP \
        MACRO(N - 1, CONTEXT)

把metamacro_for_cxtN完全展開如下：

    MACRO(0, CONTEXT) \
    SEP \
    MACRO(1, CONTEXT) \
    SEP \
    MACRO(2, CONTEXT) \
    SEP \
    MACRO(3, CONTEXT) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    MACRO(N - 4, CONTEXT) \
     SEP \
    MACRO(N - 3, CONTEXT) \
     SEP \
    MACRO(N - 2, CONTEXT) \
     SEP \
    MACRO(N - 1, CONTEXT)

這個宏的用途是執行COUNT次MACRO宏命令，每次MACRO宏命令的第一個參數都會從COUNT開始遞減到0。

8. metamacro_head(...)

這個宏要求它的可變參數至少為1個。

#define metamacro_head(...) \
        metamacro_head_(__VA_ARGS__, 0)

把宏展開，如下：

#define metamacro_head_(FIRST, ...) FIRST

metamacro_head(...) 的作用就是取出可變參數列表的第一個參數。

9. metamacro_tail(...)

這個宏要求它的可變參數至少為2個。

#define metamacro_tail(...) \
        metamacro_tail_(__VA_ARGS__)

把宏展開，如下：

#define metamacro_tail_(FIRST, ...) __VA_ARGS__

metamacro_tail(...) 的作用就是取出可變參數列表除去第一個參數以外的所有參數。

10. metamacro_take(N, ...)

這個宏要求它的可變參數至少有N個。

#define metamacro_take(N, ...) \
        metamacro_concat(metamacro_take, N)(__VA_ARGS__)

展開成如下的樣子：

metamacro_takeN(__VA_ARGS__)

繼續展開metamacro_takeN：

#define metamacro_take0(...)
#define metamacro_take1(...) metamacro_head(__VA_ARGS__)
#define metamacro_take2(...) metamacro_head(__VA_ARGS__), metamacro_take1(metamacro_tail(__VA_ARGS__))
#define metamacro_take3(...) metamacro_head(__VA_ARGS__), metamacro_take2(metamacro_tail(__VA_ARGS__))
#define metamacro_take4(...) metamacro_head(__VA_ARGS__), metamacro_take3(metamacro_tail(__VA_ARGS__))
#define metamacro_take5(...) metamacro_head(__VA_ARGS__), metamacro_take4(metamacro_tail(__VA_ARGS__))
#define metamacro_take6(...) metamacro_head(__VA_ARGS__), metamacro_take5(metamacro_tail(__VA_ARGS__))
#define metamacro_take7(...) metamacro_head(__VA_ARGS__), metamacro_take6(metamacro_tail(__VA_ARGS__))
#define metamacro_take8(...) metamacro_head(__VA_ARGS__), metamacro_take7(metamacro_tail(__VA_ARGS__))
#define metamacro_take9(...) metamacro_head(__VA_ARGS__), metamacro_take8(metamacro_tail(__VA_ARGS__))
#define metamacro_take10(...) metamacro_head(__VA_ARGS__), metamacro_take9(metamacro_tail(__VA_ARGS__))
#define metamacro_take11(...) metamacro_head(__VA_ARGS__), metamacro_take10(metamacro_tail(__VA_ARGS__))
#define metamacro_take12(...) metamacro_head(__VA_ARGS__), metamacro_take11(metamacro_tail(__VA_ARGS__))
#define metamacro_take13(...) metamacro_head(__VA_ARGS__), metamacro_take12(metamacro_tail(__VA_ARGS__))
#define metamacro_take14(...) metamacro_head(__VA_ARGS__), metamacro_take13(metamacro_tail(__VA_ARGS__))
#define metamacro_take15(...) metamacro_head(__VA_ARGS__), metamacro_take14(metamacro_tail(__VA_ARGS__))
#define metamacro_take16(...) metamacro_head(__VA_ARGS__), metamacro_take15(metamacro_tail(__VA_ARGS__))
#define metamacro_take17(...) metamacro_head(__VA_ARGS__), metamacro_take16(metamacro_tail(__VA_ARGS__))
#define metamacro_take18(...) metamacro_head(__VA_ARGS__), metamacro_take17(metamacro_tail(__VA_ARGS__))
#define metamacro_take19(...) metamacro_head(__VA_ARGS__), metamacro_take18(metamacro_tail(__VA_ARGS__))
#define metamacro_take20(...) metamacro_head(__VA_ARGS__), metamacro_take19(metamacro_tail(__VA_ARGS__))

QQ截圖20170214111650.png

這裡也用到了遞歸的思想，每次取完頭以後，剩下的隊列針對於此次是tail，對於下次是head。所以每次都取head，之後再遞歸的取剩下部分的head，直到取出前N個數為止。

metamacro_take(N, ...)的作用就是取出可變參數的前N個數，並把它們組合成新的參數列表。

11. metamacro_drop(N, ...)

這個宏要求它的可變參數至少為N個。

#define metamacro_drop(N, ...) \
        metamacro_concat(metamacro_drop, N)(__VA_ARGS__)

展開成如下的樣子：

metamacro_dropN(__VA_ARGS__)

繼續展開metamacro_dropN：

#define metamacro_drop0(...) __VA_ARGS__
#define metamacro_drop1(...) metamacro_tail(__VA_ARGS__)
#define metamacro_drop2(...) metamacro_drop1(metamacro_tail(__VA_ARGS__))
#define metamacro_drop3(...) metamacro_drop2(metamacro_tail(__VA_ARGS__))
#define metamacro_drop4(...) metamacro_drop3(metamacro_tail(__VA_ARGS__))
#define metamacro_drop5(...) metamacro_drop4(metamacro_tail(__VA_ARGS__))
#define metamacro_drop6(...) metamacro_drop5(metamacro_tail(__VA_ARGS__))
#define metamacro_drop7(...) metamacro_drop6(metamacro_tail(__VA_ARGS__))
#define metamacro_drop8(...) metamacro_drop7(metamacro_tail(__VA_ARGS__))
#define metamacro_drop9(...) metamacro_drop8(metamacro_tail(__VA_ARGS__))
#define metamacro_drop10(...) metamacro_drop9(metamacro_tail(__VA_ARGS__))
#define metamacro_drop11(...) metamacro_drop10(metamacro_tail(__VA_ARGS__))
#define metamacro_drop12(...) metamacro_drop11(metamacro_tail(__VA_ARGS__))
#define metamacro_drop13(...) metamacro_drop12(metamacro_tail(__VA_ARGS__))
#define metamacro_drop14(...) metamacro_drop13(metamacro_tail(__VA_ARGS__))
#define metamacro_drop15(...) metamacro_drop14(metamacro_tail(__VA_ARGS__))
#define metamacro_drop16(...) metamacro_drop15(metamacro_tail(__VA_ARGS__))
#define metamacro_drop17(...) metamacro_drop16(metamacro_tail(__VA_ARGS__))
#define metamacro_drop18(...) metamacro_drop17(metamacro_tail(__VA_ARGS__))
#define metamacro_drop19(...) metamacro_drop18(metamacro_tail(__VA_ARGS__))
#define metamacro_drop20(...) metamacro_drop19(metamacro_tail(__VA_ARGS__))

QQ截圖20170214111727.png

這裡也用到了遞歸的思想，每次都取當前隊列的tail，每次都丟掉當前隊列的head。這樣遞歸N次就丟掉了前N位參數。

metamacro_drop(N, ...)的作用是丟掉當前參數列表裡面的前N位參數。

12. metamacro_dec(VAL) 和 metamacro_inc(VAL)

這兩個宏是一對。它們在元編程中，處理計數和index方面及其有用。VAL的值域都是[0,20]。

#define metamacro_dec(VAL) \
        metamacro_at(VAL, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

metamacro_dec(VAL) 提供了一個被左移一位的[0,20]的序列。那麼通過metamacro_at計算出來的結果就比原來的結果小1。從而達到了減一的目的。

#define metamacro_inc(VAL) \
        metamacro_at(VAL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)

metamacro_inc(VAL) 提供了一個被右移一位的[0,20]的序列。那麼通過metamacro_at計算出來的結果就比原來的結果大1。從而達到了加一的目的。

13. metamacro_if_eq(A, B)

首先A 和 B的值域都為[0,20]，並且B要大於等於A，即0<=A<=B<=20。

#define metamacro_if_eq(A, B) \
        metamacro_concat(metamacro_if_eq, A)(B)

如果當A不等於0的時候，將上面的式子展開：

#define metamacro_if_eq(A, B) \
        metamacro_if_eqA(B)

再繼續把metamacro_if_eqA展開：

#define metamacro_if_eq1(VALUE) metamacro_if_eq0(metamacro_dec(VALUE))
#define metamacro_if_eq2(VALUE) metamacro_if_eq1(metamacro_dec(VALUE))
#define metamacro_if_eq3(VALUE) metamacro_if_eq2(metamacro_dec(VALUE))
#define metamacro_if_eq4(VALUE) metamacro_if_eq3(metamacro_dec(VALUE))
#define metamacro_if_eq5(VALUE) metamacro_if_eq4(metamacro_dec(VALUE))
#define metamacro_if_eq6(VALUE) metamacro_if_eq5(metamacro_dec(VALUE))
#define metamacro_if_eq7(VALUE) metamacro_if_eq6(metamacro_dec(VALUE))
#define metamacro_if_eq8(VALUE) metamacro_if_eq7(metamacro_dec(VALUE))
#define metamacro_if_eq9(VALUE) metamacro_if_eq8(metamacro_dec(VALUE))
#define metamacro_if_eq10(VALUE) metamacro_if_eq9(metamacro_dec(VALUE))
#define metamacro_if_eq11(VALUE) metamacro_if_eq10(metamacro_dec(VALUE))
#define metamacro_if_eq12(VALUE) metamacro_if_eq11(metamacro_dec(VALUE))
#define metamacro_if_eq13(VALUE) metamacro_if_eq12(metamacro_dec(VALUE))
#define metamacro_if_eq14(VALUE) metamacro_if_eq13(metamacro_dec(VALUE))
#define metamacro_if_eq15(VALUE) metamacro_if_eq14(metamacro_dec(VALUE))
#define metamacro_if_eq16(VALUE) metamacro_if_eq15(metamacro_dec(VALUE))
#define metamacro_if_eq17(VALUE) metamacro_if_eq16(metamacro_dec(VALUE))
#define metamacro_if_eq18(VALUE) metamacro_if_eq17(metamacro_dec(VALUE))
#define metamacro_if_eq19(VALUE) metamacro_if_eq18(metamacro_dec(VALUE))
#define metamacro_if_eq20(VALUE) metamacro_if_eq19(metamacro_dec(VALUE))

上面是一個遞推的式子，最終肯定會得到metamacro_if_eq0，最終的結果就是：

metamacro_if_eq0(B - A)

再把metamacro_if_eq0展開：

#define metamacro_if_eq0(VALUE) \
        metamacro_concat(metamacro_if_eq0_, VALUE)

得到最終的展開式子：

metamacro_if_eq0_(B - A)

再查表得到最終結果：

#define metamacro_if_eq0_0(...) __VA_ARGS__ metamacro_consume_
#define metamacro_if_eq0_1(...) metamacro_expand_
#define metamacro_if_eq0_2(...) metamacro_expand_
#define metamacro_if_eq0_3(...) metamacro_expand_
#define metamacro_if_eq0_4(...) metamacro_expand_
#define metamacro_if_eq0_5(...) metamacro_expand_
#define metamacro_if_eq0_6(...) metamacro_expand_
#define metamacro_if_eq0_7(...) metamacro_expand_
#define metamacro_if_eq0_8(...) metamacro_expand_
#define metamacro_if_eq0_9(...) metamacro_expand_
#define metamacro_if_eq0_10(...) metamacro_expand_
#define metamacro_if_eq0_11(...) metamacro_expand_
#define metamacro_if_eq0_12(...) metamacro_expand_
#define metamacro_if_eq0_13(...) metamacro_expand_
#define metamacro_if_eq0_14(...) metamacro_expand_
#define metamacro_if_eq0_15(...) metamacro_expand_
#define metamacro_if_eq0_16(...) metamacro_expand_
#define metamacro_if_eq0_17(...) metamacro_expand_
#define metamacro_if_eq0_18(...) metamacro_expand_
#define metamacro_if_eq0_19(...) metamacro_expand_
#define metamacro_if_eq0_20(...) metamacro_expand_

上面這張表有兩點注意點：

除了0_0，其他的都是metamacro_expand_。

#define metamacro_consume_(...)
#define metamacro_expand_(...) __VA_ARGS__

除了0_0以外，其他所有操作都是直接透傳參數，什麼也不處理。metamacro_consume_(...)就是直接吞掉後續的參數。expand就是指的是可以繼續展開宏，consume就是指的是終止展開宏，並吃掉後面的參數。

舉2個例子：

// 第一個例子
metamacro_if_eq(0, 0)(true)(false)

// 第二個例子
metamacro_if_eq(0, 1)(true)(false)

直接套用最終展開式：

// 第一個例子
metamacro_if_eq0_0(true)(false)

// 第二個例子
metamacro_if_eq0_1(true)(false)

繼續展開：

// 第一個例子
true metamacro_consume_(false) => true

// 第二個例子
metamacro_expand_(false) => false

這個如果 B < A，那麼(B - A) < 0，那麼最終展開的式子就變成下面的樣子：

metamacro_if_eq0_(負數)

這個宏展開到這個程度就沒法繼續下去了，就會出現編譯錯誤。

14. metamacro_if_eq_recursive(A, B)

A 和 B的值域都為[0,20]，並且B要大於等於A，即0<=A<=B<=20。

定義如下：

#define metamacro_if_eq_recursive(A, B) \
        metamacro_concat(metamacro_if_eq_recursive, A)(B)

展開之後：

metamacro_if_eq_recursiveA(B)

繼續展開：

#define metamacro_if_eq_recursive1(VALUE) metamacro_if_eq_recursive0(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive2(VALUE) metamacro_if_eq_recursive1(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive3(VALUE) metamacro_if_eq_recursive2(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive4(VALUE) metamacro_if_eq_recursive3(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive5(VALUE) metamacro_if_eq_recursive4(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive6(VALUE) metamacro_if_eq_recursive5(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive7(VALUE) metamacro_if_eq_recursive6(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive8(VALUE) metamacro_if_eq_recursive7(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive9(VALUE) metamacro_if_eq_recursive8(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive10(VALUE) metamacro_if_eq_recursive9(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive11(VALUE) metamacro_if_eq_recursive10(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive12(VALUE) metamacro_if_eq_recursive11(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive13(VALUE) metamacro_if_eq_recursive12(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive14(VALUE) metamacro_if_eq_recursive13(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive15(VALUE) metamacro_if_eq_recursive14(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive16(VALUE) metamacro_if_eq_recursive15(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive17(VALUE) metamacro_if_eq_recursive16(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive18(VALUE) metamacro_if_eq_recursive17(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive19(VALUE) metamacro_if_eq_recursive18(metamacro_dec(VALUE))
#define metamacro_if_eq_recursive20(VALUE) metamacro_if_eq_recursive19(metamacro_dec(VALUE))

最終肯定會得到metamacro_if_eq_recursive0_，最終的結果就是：

metamacro_if_eq_recursive0_(B - A)

再把metamacro_if_eq_recursive0_展開：

#define metamacro_if_eq_recursive0(VALUE) \
    metamacro_concat(metamacro_if_eq_recursive0_, VALUE)

得到最終的式子：

metamacro_if_eq_recursive0_(B - A)

最終再比對下表：

#define metamacro_if_eq_recursive0_0(...) __VA_ARGS__ metamacro_consume_
#define metamacro_if_eq_recursive0_1(...) metamacro_expand_
#define metamacro_if_eq_recursive0_2(...) metamacro_expand_
#define metamacro_if_eq_recursive0_3(...) metamacro_expand_
#define metamacro_if_eq_recursive0_4(...) metamacro_expand_
#define metamacro_if_eq_recursive0_5(...) metamacro_expand_
#define metamacro_if_eq_recursive0_6(...) metamacro_expand_
#define metamacro_if_eq_recursive0_7(...) metamacro_expand_
#define metamacro_if_eq_recursive0_8(...) metamacro_expand_
#define metamacro_if_eq_recursive0_9(...) metamacro_expand_
#define metamacro_if_eq_recursive0_10(...) metamacro_expand_
#define metamacro_if_eq_recursive0_11(...) metamacro_expand_
#define metamacro_if_eq_recursive0_12(...) metamacro_expand_
#define metamacro_if_eq_recursive0_13(...) metamacro_expand_
#define metamacro_if_eq_recursive0_14(...) metamacro_expand_
#define metamacro_if_eq_recursive0_15(...) metamacro_expand_
#define metamacro_if_eq_recursive0_16(...) metamacro_expand_
#define metamacro_if_eq_recursive0_17(...) metamacro_expand_
#define metamacro_if_eq_recursive0_18(...) metamacro_expand_
#define metamacro_if_eq_recursive0_19(...) metamacro_expand_
#define metamacro_if_eq_recursive0_20(...) metamacro_expand_

接下來就和metamacro_if_eq(A, B)宏完全一樣了。

這個遞歸的宏也從來沒有在RAC的其他宏中使用，作者在這裡標注說明了這個宏的用處。

This can be used when the former would fail due to recursive macro expansion

由於宏在遞歸展開中可能會導致遞歸前置條件失敗，在這種情況下，應該使用這個遞歸宏。當然，它的效果和metamacro_if_eq(A, B)宏是完全一樣的。

15. metamacro_is_even(N)

定義如下：

N的值域在[0,20]之間。

#define metamacro_is_even(N) \
        metamacro_at(N, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1)

這個宏比較簡單，就是判斷N是不是偶數，下面metamacro_at把所有從0-20的自然數是偶數的都標志成了1，是奇數的都標志成了0。0在這裡默認是偶數。

16. metamacro_not(B)

這裡B的取值只能是0或者1。

#define metamacro_not(B) \
        metamacro_at(B, 1, 0)

這個宏很簡單，就是對參數邏輯取非運算。

三. ReactiveCocoa 中常用的宏

QQ截圖20170214112152.png

上一章節我們分析完了ReactiveCocoa中所有的元宏，這一章節將會把元宏以外的宏的實現都分析一遍。包括我們日常使用的常見的所有宏，它們看似神秘，但是他們都是由這些元宏來組成的。

1. weakify(...)、unsafeify(...)、strongify(...)

這三個在ReactiveCocoa一定是使用最多的，那麼就先來分析這三個。這三個宏的定義在RACEXTScope.h中。

關於weakify(...)和strongify(...)，這兩個宏的實現分析在之前的文章裡面詳細分析過了，詳情可以看這篇文章《深入研究Block用weakSelf、strongSelf、@weakify、@strongify解決循環引用》。

這裡需要再次強調的一點是，在使用weakify(...)、unsafeify(...)、strongify(...)這三個宏的前面需要額外添加@符號。原因是在這三個宏的實現裡面都有rac_keywordify，它的實現如下：

#if DEBUG
#define rac_keywordify autoreleasepool {}
#else
#define rac_keywordify try {} @catch (...) {}
#endif

不管是在什麼環境下，autoreleasepool {} 和 try {} @catch (...) {} 前面都要添加@符號，變成@autoreleasepool {} 和 @try {} @catch (...) {} 才可以繼續使用。

既然@weakify(...)，@strongify(...)都分析過了，那麼這裡就分析一下@unsafeify(...)的實現。

#define unsafeify(...) \
        rac_keywordify \
        metamacro_foreach_cxt(rac_weakify_,, __unsafe_unretained, __VA_ARGS__)

rac_keywordify上面說過了，這裡就直接展開metamacro_foreach_cxt宏。這裡就套用之前元宏的分析，直接拿到最終展開表達式：

    MACRO(0, CONTEXT, _0) \
    SEP \
    MACRO(1, CONTEXT, _1) \
    SEP \
    MACRO(2, CONTEXT, _2) \
    SEP \
    MACRO(3, CONTEXT, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    MACRO(N - 4, CONTEXT, _N - 4) \
     SEP \
    MACRO(N - 3, CONTEXT, _N - 3) \
     SEP \
    MACRO(N - 2, CONTEXT, _N - 2) \
     SEP \
    MACRO(N - 1, CONTEXT, _N - 1)

MACRO = rac_weakify_，SEP = 空格，CONTEXT = __unsafe_unretained。代入得到最終的展開式：

    rac_weakify_(0,  __unsafe_unretained, _0) \
    rac_weakify_(1,  __unsafe_unretained, _1) \
    rac_weakify_(2,  __unsafe_unretained, _2) \
    rac_weakify_(3,  __unsafe_unretained, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
    rac_weakify_(N - 4,  __unsafe_unretained, _N - 4) \
    rac_weakify_(N - 3,  __unsafe_unretained, _N - 3) \
    rac_weakify_(N - 2,  __unsafe_unretained, _N - 2) \
    rac_weakify_(N - 1,  __unsafe_unretained, _N - 1)

把rac_weakify_再替換掉：

#define rac_weakify_(INDEX, CONTEXT, VAR) \
    CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);

得到最終的展開表達式：

__unsafe_unretained  __typeof__(_0) _0_weak_ = _0；
__unsafe_unretained  __typeof__(_1) _1_weak_ = _1；
__unsafe_unretained  __typeof__(_2) _2_weak_ = _2；
     ……
     ……
     ……
     ……
     ……
     ……
__unsafe_unretained  __typeof__(_N - 3) _N - 3_weak_ = _N - 3；
__unsafe_unretained  __typeof__(_N - 2) _N - 2_weak_ = _N - 2；
__unsafe_unretained  __typeof__(_N - 1) _N - 1_weak_ = _N - 1；

其中 _0， _1， _2 …… _N - 3， _N - 2， _N - 1是 __VA_ARGS__裡面對應的是0 - N的參數值。

2. RACTuplePack(...) 和 RACTupleUnpack(...)

這兩個在ReactiveCocoa中也是非常常見的宏，專門用在RACTuple中。

先看RACTuplePack(...)

#define RACTuplePack(...) \
        RACTuplePack_(__VA_ARGS__)

再展開一步：

#define RACTuplePack_(...) \
        ([RACTuple tupleWithObjectsFromArray:@[ metamacro_foreach(RACTuplePack_object_or_ractuplenil,, __VA_ARGS__) ]])

這裡調用了RACTuple的tupleWithObjectsFromArray:方法。主要需要展開的是：

metamacro_foreach(RACTuplePack_object_or_ractuplenil,, __VA_ARGS__)

直接調用上一章節中metamacro_foreach的最終表達式：

    MACRO(0, _0) \
    SEP \
    MACRO(1, _1) \
    SEP \
    MACRO(2, _2) \
    SEP \
    MACRO(3, _3) \
     ……
     ……
     ……
     ……
     ……
     ……
     
     SEP \
    MACRO(N - 4, _N - 4) \
     SEP \
    MACRO(N - 3, _N - 3) \
     SEP \
    MACRO(N - 2, _N - 2) \
     SEP \
    MACRO(N - 1, _N - 1)

MACRO = RACTuplePack_object_or_ractuplenil ， SEP = 空格，替換之後如下：

RACTuplePack_object_or_ractuplenil(0, _0) \
RACTuplePack_object_or_ractuplenil(1, _1) \
RACTuplePack_object_or_ractuplenil(2, _2) \
     ……
     ……
     ……
     ……
     ……
     ……
RACTuplePack_object_or_ractuplenil( N - 3, _N - 3) \
RACTuplePack_object_or_ractuplenil( N - 2, _N - 2) \
RACTuplePack_object_or_ractuplenil( N - 1, _N - 1)

最後一步就是替換掉RACTuplePack_object_or_ractuplenil：

#define RACTuplePack_object_or_ractuplenil(INDEX, ARG) \
    (ARG) ?: RACTupleNil.tupleNil,

注意這裡宏結尾是“，”逗號，而不是“；”分號，原因是因為tupleWithObjectsFromArray:方法裡面是各個元素，所以這裡用“；”分號就會出錯，反而應該用“，”逗號，可見設計宏的時候需要考慮清楚使用場景，不能亂寫。

展開上面最後一層宏之後，原可變參數列表裡面的所有非nil的值就都排列到了tupleWithObjectsFromArray:方法裡面了，如果是nil的，就會變成RACTupleNil.tupleNil放進Array裡面。

再來看看RACTupleUnpack(...)

#define RACTupleUnpack(...) \
        RACTupleUnpack_(__VA_ARGS__)

再展開一步：

#define RACTupleUnpack_(...) \
    metamacro_foreach(RACTupleUnpack_decl,, __VA_ARGS__) \
    \
    int RACTupleUnpack_state = 0; \
    \
    RACTupleUnpack_after: \
        ; \
        metamacro_foreach(RACTupleUnpack_assign,, __VA_ARGS__) \
        if (RACTupleUnpack_state != 0) RACTupleUnpack_state = 2; \
        \
        while (RACTupleUnpack_state != 2) \
            if (RACTupleUnpack_state == 1) { \
                goto RACTupleUnpack_after; \
            } else \
                for (; RACTupleUnpack_state != 1; RACTupleUnpack_state = 1) \
                    [RACTupleUnpackingTrampoline trampoline][ @[ metamacro_foreach(RACTupleUnpack_value,, __VA_ARGS__) ] ]

乍一看這個宏像一段程序，仔細分析一下也不難。RACTupleUnpack_state 就是一個局部變量，代表狀態的。RACTupleUnpack_after: 這是一個標號，用來給goto跳轉使用的。

// 1
metamacro_foreach(RACTupleUnpack_decl,, __VA_ARGS__) 
// 2
metamacro_foreach(RACTupleUnpack_assign,, __VA_ARGS__)
// 3
metamacro_foreach(RACTupleUnpack_value,, __VA_ARGS__)

這裡面需要展開的就是這3個宏了。

套用上一章節中metamacro_foreach的最終表達式，直接把MACRO分別為 RACTupleUnpack_decl，RACTupleUnpack_assign，RACTupleUnpack_value 代入表達式。

// 1
RACTupleUnpack_decl(0, _0) \
     ……
     ……
     ……
RACTupleUnpack_decl( N - 1, _N - 1)
// 2
RACTupleUnpack_assign(0, _0) \
     ……
     ……
     ……
RACTupleUnpack_assign( N - 1, _N - 1)
// 3
RACTupleUnpack_value(0, _0) \
     ……
     ……
     ……
RACTupleUnpack_value( N - 1, _N - 1)

分別替換掉這3個宏：

#define RACTupleUnpack_decl(INDEX, ARG) \
    __strong id RACTupleUnpack_decl_name(INDEX);
    
#define RACTupleUnpack_assign(INDEX, ARG) \
    __strong ARG = RACTupleUnpack_decl_name(INDEX);
    
#define RACTupleUnpack_value(INDEX, ARG) \
    [NSValue valueWithPointer:&RACTupleUnpack_decl_name(INDEX)],

發現這3個宏都是用RACTupleUnpack_decl_name實現的。

#define RACTupleUnpack_decl_name(INDEX) \
        metamacro_concat(metamacro_concat(RACTupleUnpack, __LINE__), metamacro_concat(_var, INDEX))

這個展開就是一個名字：

RACTupleUnpack __LINE__ _varINDEX

之後的實現，請看《ReactiveCocoa 中 集合類RACSequence 和 RACTuple底層實現分析》這篇文章的詳細分析。

3. RACObserve(TARGET, KEYPATH)

定義如下：

#define RACObserve(TARGET, KEYPATH) \
    ({ \
        _Pragma("clang diagnostic push") \
        _Pragma("clang diagnostic ignored \"-Wreceiver-is-weak\"") \
        __weak id target_ = (TARGET); \
        [target_ rac_valuesForKeyPath:@keypath(TARGET, KEYPATH) observer:self]; \
        _Pragma("clang diagnostic pop") \
    })

看完定義，RACObserve(TARGET, KEYPATH) 實質其實就是調用了rac_valuesForKeyPath:方法。這個方法是NSObject的一個category，所以只要是NSObject就可以調用這個方法。所以這裡的關鍵就是要分析清楚@keypath(TARGET, KEYPATH) 這個宏的實現。

以下重點分析一下keypath(...)的實現

#define keypath(...) \
    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__))(keypath1(__VA_ARGS__))(keypath2(__VA_ARGS__))
    
#define keypath1(PATH) \
    (((void)(NO && ((void)PATH, NO)), strchr(# PATH, '.') + 1))
    
#define keypath2(OBJ, PATH) \
    (((void)(NO && ((void)OBJ.PATH, NO)), # PATH))

metamacro_argcount這個宏在元宏裡面分析過，是取出可變參數個數的。metamacro_if_eq也詳細分析過，是判斷裡面2個參數是否相當的。所以keypath(...)總體展開的意思是說，可變參數的個數是否等於1，如果等於1，就執行(keypath1(__VA_ARGS__))，如果不等於1，就執行(keypath2(__VA_ARGS__))。

這裡有幾點需要說明的：

1.加void是為了防止逗號表達式的warning。例如：

int a=0; int b = 1;
int c = (a,b);

由於a沒有被用到，所以會有警告。但是寫成如下的樣子就不會出現警告了：

int c = ((void)a,b);

所以上面keypath1和keypath2加了幾個void就是為了防止出現warning。

2.加NO是C語言判斷條件短路表達式。增加NO && 以後，預編譯的時候看見了NO，就會很快的跳過判斷條件。

3.strchr函數原型如下：

extern char *strchr(const char *s,char c);

查找字符串s中首次出現字符c的位置。返回首次出現字符c的位置的指針，返回的地址是被查找字符串指針開始的第一個與字符c相同字符的指針，如果字符串中不存在字符c則返回NULL。

4.當輸入self.的時候，會出現編譯器的語法提示，原因是OBJ.PATH，因為這裡的點，所以輸入第二個參數時編輯器會給出正確的代碼提示。

5.使用keypath(...)的時候前面會加上@符號，原因是經過keypath1(PATH)和keypath2(OBJ, PATH)之後出現的結果是一個C的字符串，前面加上@以後，就變成了OC的字符串了。

舉3個例子

// 例子1，一個參數的情況，會調用keypath1(PATH)
NSString *UTF8StringPath = @keypath(str.lowercaseString.UTF8String);
// 輸出=> @"lowercaseString.UTF8String"

// 例子2，2個參數的情況，支持自省
NSString *versionPath = @keypath(NSObject, version);
//  輸出=> @"version"

// 例子3，2個參數的情況
NSString *lowercaseStringPath = @keypath(NSString.new, lowercaseString);
// 輸出=> @"lowercaseString"

相應的也有集合類的keypath

#define collectionKeypath(...) \
    metamacro_if_eq(3, metamacro_argcount(__VA_ARGS__))(collectionKeypath3(__VA_ARGS__))(collectionKeypath4(__VA_ARGS__))
    
#define collectionKeypath3(PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String])

#define collectionKeypath4(OBJ, PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(OBJ, PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String])

原理也是調用了keypath(PATH)，原理這裡就不再贅述了。

4. RAC(TARGET, ...)

宏定義如下：

#define RAC(TARGET, ...) \
        metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
        (RAC_(TARGET, __VA_ARGS__, nil)) \
        (RAC_(TARGET, __VA_ARGS__))
RAC(TARGET, ...) 和上一個RACObserve(TARGET, KEYPATH)原理類似。如果只有一個參數就調用(RAC_(TARGET, __VA_ARGS__, nil))，如果是多個參數就調用(RAC_(TARGET, __VA_ARGS__))。

#define RAC_(TARGET, KEYPATH, NILVALUE) \
        [[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:(TARGET) nilValue:(NILVALUE)][@keypath(TARGET, KEYPATH)]

到這裡就很明了了，其實內部就是調用RACSubscriptingAssignmentTrampoline類的initWithTarget: nilValue:方法。

我們都知道RAC(TARGET, ...)宏是用來把一個信號綁定給一個對象的屬性，綁定之後，每次信號發送出一個新的值，就會自動設定到執行的keypath中。當信號完成之後，這次綁定也會自動的解除。

RAC_(TARGET, KEYPATH, NILVALUE) 會把信號綁定到TARGET指定的KEYPATH上。如果信號發送了nil的值，那麼會替換成NILVALUE賦值給對應的屬性值上。

RAC_(TARGET, __VA_ARGS__)只不過是RAC_(TARGET, KEYPATH, NILVALUE)第三個參數為nil。

5. RACChannelTo(TARGET, ...)

RACChannelTo(TARGET, ...)這個宏完全可以類比RAC(TARGET, ...)，兩個幾乎完全一樣。

#define RACChannelTo(TARGET, ...) \
    metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \
        (RACChannelTo_(TARGET, __VA_ARGS__, nil)) \
        (RACChannelTo_(TARGET, __VA_ARGS__))

如果只有一個參數就調用(RACChannelTo_(TARGET, __VA_ARGS__, nil)) ，如果是多個參數就調用(RACChannelTo_(TARGET, __VA_ARGS__))。(RACChannelTo_(TARGET, __VA_ARGS__))相當於是(RACChannelTo_(TARGET, __VA_ARGS__, nil)) 第三個參數傳了nil。

#define RACChannelTo_(TARGET, KEYPATH, NILVALUE) \
    [[RACKVOChannel alloc] initWithTarget:(TARGET) keyPath:@keypath(TARGET, KEYPATH) nilValue:(NILVALUE)][@keypath(RACKVOChannel.new, followingTerminal)]

最終內部是調用了RACKVOChannel的initWithTarget: keyPath: nilValue:方法。具體原理可以完全類比RAC(TARGET, ...)宏展開，這裡不再贅述。

平時我們都是這樣用：

   RACChannelTo(view, objectProperty) = RACChannelTo(model, objectProperty);
   RACChannelTo(view, integerProperty, @2) = RACChannelTo(model, integerProperty, @10);

6. onExit

宏定義如下：

#define onExit \
    rac_keywordify \
    __strong rac_cleanupBlock_t metamacro_concat(rac_exitBlock_, __LINE__) __attribute__((cleanup(rac_executeCleanupBlock), unused)) = ^

由於rac_keywordify的存在，所以在使用onExit的時候，前面也要加上@符號。

這個宏比較特殊，最後是跟著一個閉包，比如這樣：

        @onExit {
              free(attributes);
        };
        
        @onExit {
                [objectLock unlock];
            };

@onExit定義當前代碼段退出時要執行的一些代碼。代碼必須用大括號括起來並以分號結尾，無論是何種情況（包括出現異常，goto語句，return語句，break語句，continue語句）下跳出代碼段，都會執行onExit後面的代碼。

@onExit提供的代碼被放進一個block塊中，之後才會執行。因為在閉包中，所以它也必須遵循內存管理方面的規則。@onExit是以一種合理的方式提前退出清理塊。

在相同代碼段中如果有多個@onExit語句，那麼他們是按照反字典序的順序執行的。

@onExit語句不能在沒有大括號的范圍內使用。在實際使用過程中，這不是一個問題，因為@onExit後面如果沒有大括號，那麼它是一個無用的結構，不會有任何事情發生。

最後

QQ截圖20170214132151.png

關於ReactiveCocoa裡面所有宏的實現分析都已經分析完成。我覺得宏是對一段邏輯的高度抽象，當一個宏被思維完備的開發人員設計出來以後，就是一個充滿神奇色彩的魔法！如果能把一些簡單實用的功能或者邏輯抽象成宏，把這些時間都節約到預編譯中，節約運行時的時間，單從編碼的程度來說，都是極有樂趣的一件事情！如果以後有機會，希望還能和大家交流交流Lisp裡面的相關宏魔法的知識。

  1. 上一頁:
  2. 下一頁:
IOS開發基礎
iOS之友盟錯誤統計解決 作者：@__wea
ScrollView 與 Autolayout 學 Autolay
一個收集了502款開源iOS應用的開源項目 由dkhamsin
IOS編程開發
相關文章
+
IOS開發基礎IOS編程技術IOS開發綜合
用RxSwift實現一個UITableView
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © Ios教程網 All Rights Reserved