此文轉載自：https://my.oschina.net/u/2340880/blog/3357392

LiteOS Studio圖形化調測能力，物聯網打工人必備！>>>

玩轉iOS“宏定義”

       宏定義在C類語言中非常重要，因為宏是一種預編譯時的功能，因此其可以比運行時更高層面的對程序流程進行控制。在初學宏定義的時候，大家可能都會有這樣一種感覺：就是完全替換么，太簡單了。但如果你真這么想，那你就太天真了，不說自己編寫宏，在Foundation框架中內置定義的許多宏要看明白也要費一番腦筋。本篇博客，總結了前輩的經驗，同時收集了一些編寫非常巧妙的宏進行分析，希望可以幫助大家對宏定義有更加深刻的理解，並且可以將心得應用於實際開發中。

一、准備

      宏的本質是預編譯時的替換，在開始正文之前，我們需要先介紹一種觀察宏替換后結果的方法，這樣幫助我們更方便的對宏最終的結果進行驗證與測試。Xcode開發工具自帶查看預編譯結果的功能，首先需要對工程編譯一遍，之后選擇工具欄中的Assistant選項，打開助手窗口，如下圖所示：

之后選擇窗口的Preprocess選項，即可打開預編譯結果窗口，可以看到，宏被替換后的最終結果，如下圖所示：

后面，我們將使用這種方式來對編寫的宏進行驗證。

二、關於“宏定義”

      宏使用#define來進行定義，宏定義分為兩種，一種是對象式宏，一種是函數式宏。對象式宏通常對來定義量值，在預編譯時，直接將宏名替換成對應的量值，函數式宏在定義時可以設置參數，其作用與函數很類似。

例如，我們可以將π的值定義成一個對象式宏，在使用的時候，用有意義的宏名要比直接使用π的字面值方便很多，例如：

#import <Foundation/Foundation.h>
#define PI 3.1415926
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        CGFloat res = PI * 3;
        NSLog(@"%f", res);
    }
    return 0;
}

函數式宏要更加靈活一些，例如對圓面積計算的方法，我們就可以將其定義成一個宏：

#define PI 3.1415926
#define CircleArea(r) PI * r * r
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        CGFloat res = CircleArea(1);
        NSLog(@"%f", res);
    }
    return 0;
}

現在，有了這個面積計算宏我們可以更加方便的計算圓的面積了，看上去很完美，后面我們就使用這個函數式宏為例，來深入理解宏的原理。

三、從一個簡單的函數式宏說起

     再來看下上面我們編寫的計算面積的宏，正常情況下好像沒什么問題，但是需要注意，歸根結底宏並不是函數，如果完全把其作為函數使用，我們就可能會陷入一系列的陷阱中，比如這樣使用：

#define PI 3.1415926
#define CircleArea(r) PI * r * r
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        CGFloat res = CircleArea(1 + 1);
        NSLog(@"%f", res);
    }
    return 0;
}

運行代碼，運算的結果並不是半徑為2個圓的面積，哪里出了問題呢，我們還是先看下宏預編譯后的結果：

CGFloat res = 3.1415926 * 1 + 1 * 1 + 1;

一目了然了，由於運算符的優先級問題導致了運算順序錯誤，在編程中，所有運算符優先級產生的問題都可以使用一種方式解決：用小括號。對CircleArea宏進行一下改造，如下：

#define CircleArea(r) (PI * (r) * (r))

對執行順序進行了強制的控制，代碼執行又恢復了正常，看上去好像是沒有問題了，現在就滿意了還為時過早，例如下面這樣使用這個宏：

#import <Foundation/Foundation.h>
#define PI 3.1415926
#define CircleArea(r) PI * (r) * (r)
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        int r = 1;
        CGFloat res = CircleArea(r++);
        NSLog(@"%f, %d", res, r);
    }
    return 0;
}

運行，發現結果又錯了，不僅計算結果與我們的預期不符，變量自加的的結果也不對了，我們檢查其展開的結果：

CGFloat res = 3.1415926 * (r++) * (r++);

原來問題出在這里，宏在展開的時候，將參數替換了兩次，由於參數本身是一個自加表達式，所以被自加了兩次，產生了問題，那么這個問題怎么解決呢，C語言中有一種很有用的語法，即使用大括號定義代碼塊，代碼塊會將最后一條語句的執行結果返回，修改上面宏定義如下：

#import <Foundation/Foundation.h>
#define PI 3.1415926
#define CircleArea(r)   \
({                      \
    typeof(r) _r = r;   \
    (PI * (_r) * (_r)); \
})
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int r = 1;
        CGFloat res = CircleArea(r++);
        NSLog(@"%f, %d", res, r);
    }
    return 0;
}

這次程序又恢復的了正常。但是，如果如果在調用宏是變量的名字與宏內的臨時變量產生了重名，災難就又發生了，例如：

#import <Foundation/Foundation.h>
#define PI 3.1415926
#define CircleArea(r)   \
({                      \
    typeof(r) _r = r;   \
    (PI * (_r) * (_r)); \
})
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        int _r = 1;
        CGFloat res = CircleArea(_r);
        NSLog(@"%f, %d", res, _r);
    }
    return 0;
}

運行上面代碼，會發現宏內的臨時變量沒有被初始化成功。這確實難受，我們在進一步，比如對臨時變量的名字做一些手腳，將其命名為極其不容易重復的名字，其實系統內置的一個宏就是專門用來構造唯一性變量名的：__COUNTER__，這個宏是一個計數器，在編譯的時候會自動進行累加，再次對我們編寫的宏進行改造，如下：

#import <Foundation/Foundation.h>
#define PI 3.1415926
#define PAST(A, B) A##B
#define CircleArea(r)   __CircleArea(r, __COUNTER__)
#define __CircleArea(r, v)      \
({                              \
    typeof(r) PAST(_r, v) = r;         \
    (PI * PAST(_r, v) * PAST(_r, v));     \
})
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int _r = 1;
        CGFloat res = CircleArea(_r);
        CGFloat res2 = CircleArea(_r);
        NSLog(@"%f, %f", res, res2);
    }
    return 0;
}

這里改造后，我們的宏就沒有那么容易理解了，首先__COUNTER__在每次宏替換時都會進行自增，##是一種宏中專用的特殊符號，用來將參數拼接到一起，但是需要注意，使用##符號拼接的如果是另外一個宏，則其會阻止宏的展開，因此我們定義了一個轉換宏PAST(A, B)來處理拼接。如果你一下子不能理解為什么這樣就可以解決宏展開的問題，你只需要記住這樣一條宏展開的原則：如果形參有使用#或##這種處理符號，則不會進行宏參數的展開，否則先展開宏參數，在展開當前宏。上面代碼最終預編譯的結果如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int _r = 1;
        CGFloat res = ({ typeof(_r) _r0 = _r; (3.1415926 * _r0 * _r0); });
        CGFloat res2 = ({ typeof(_r) _r1 = _r; (3.1415926 * _r1 * _r1); });
        NSLog(@"%f, %f", res, res2);
    }
    return 0;
}

一個簡單的計算圓面積的宏，為了安全，我們就進行了這么多的處理，看來要用好宏，的確不容易。

四、編寫宏時的好習慣

      通過前面的介紹，我們知道，如果隨隨意意的編寫一個宏是非常不負責任的，看上去好像沒問題與在任何場景下使用都沒有問題是完全不同的。在編寫宏時，我們可以刻意的去培養這樣幾個編碼習慣：

• 參數與計算結果要加小括號

      這條原則應該不必多說了，前面的示例中就有演示，完整的添加小括號可以避免很多由於運算符優先級造成的異常問題。

• 多語句功能性宏，要使用do-while包裹

      這條原則看上去有些莫名其妙，但是其非常重要，例如，我們需要編寫一個自定義的LOG宏，在進行打印時添加一些自定義的信息，你或許會這樣寫：

#define LOG(string)     \
NSLog(@"自定義的信息");   \
NSLog(string);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        LOG(@"info")
    }
    return 0;
}

運行代碼，目前貌似沒有問題，但是如果其和if語句進行結合，可能問題就來了：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (NO)
            LOG(@"info")
    }
    return 0;
}

運行代碼，還是有一行LOG信息被輸出了，看下其預編譯后的結果如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (__objc_no)
            NSLog(@"自定義的信息"); NSLog(@"info");
    }
    return 0;
}

找到問題了，由於if結構如果不加大括號進行規范，其默認作用域只有一句代碼，多寫大括號是不會出問題，因此編寫多語句宏時，加上大括號是一個好習慣，如下：

#define LOG(string)     \
{NSLog(@"自定義的信息");   \
NSLog(string);}

這樣解決了問題，但是並不完美，假設在使用時這樣寫：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (NO)
            LOG(@"NO");
        else
            LOG(@"YES");
    }
    return 0;
}

結果發現還是會報錯，是由於分號搗的鬼，預編譯結果如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (__objc_no)
            {NSLog(@"自定義的信息"); NSLog(@"NO");};
        else
            {NSLog(@"自定義的信息"); NSLog(@"YES");};
    }
    return 0;
}

我們知道，像if，while，for這種語法結構塊的大括號后是不需要分號的，我們為了兼容單行if語句由於宏的原因被展開成多行的問題強行加了一個大括號上去，就產生這樣的問題了，解決它的一個好方法是真的將多行的宏轉化成單語句，do-whlie結構就可以實現這種效果，修改宏如下：

#define LOG(string)     \
do {NSLog(@"自定義的信息");   \
NSLog(string);} while(0);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (NO)
            LOG(@"NO")
        else
            LOG(@"YES");
    }
    return 0;
}

預編譯后：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (__objc_no)
            do {NSLog(@"自定義的信息"); NSLog(@"NO");} while(0);
        else
            do {NSLog(@"自定義的信息"); NSLog(@"YES");} while(0);;
    }
    return 0;
}

現在，無論外面怎么使用，這個宏都可以正常工作了。

• 對於不定參數的宏，借助##符號來拼接參數

      在定義函數時，我們可以定義函數的參數為不定個數參數，定義函數式宏時也類似，使用符號"..."可以指定不定個數參數，例如對LOG宏進行調整，如下：

#define LOG(format, ...)     \
do {NSLog(@"自定義的信息");   \
NSLog(format, __VA_ARGS__);} while(0);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (NO)
            LOG(@"%d", NO)
        else
            LOG(@"%d", YES);
    }
    return 0;
}

__VA_ARGS__也是一個內置的宏符號，則作用是代表宏定義中的可變參數“...”，需要注意，如果按照上面的寫法，如果我們傳入的可變參數為0個，會產生問題，其原因也是由於多了一個逗號，例如：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        if (NO)
            LOG(@"%d") // 這里會被預編譯成NSLog(@"%d", )
        else
            LOG(@"%d", YES);
    }
    return 0;
}

解決方案是對可變參數進行一次##拼接，宏在使用##符號進行參數拼接時，如果后面的參數為空，其會自動將前面的逗號去掉，如下：

#define LOG(format, ...)     \
do {NSLog(@"自定義的信息");   \
NSLog(format, ##__VA_ARGS__);} while(0);

五、特殊的宏符號與常用內置宏

      有幾個特殊的符號可以讓宏定義變得非常靈活，常用的特殊符號和特殊宏列舉如下：

• #

      井號的作用是將參數字符串化，例如：

#define Test(p) #p

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Test(abc); // 預編譯后成為  "abc";
    }
    return 0;
}

• ##

      雙井號我們前面有使用過，其作用是對參數進行拼接，例如：

#define Test(a,b) a##b

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Test(1,2); // 預編譯后成為  12;
    }
    return 0;
}

• __VA_ATGS__

      可變參數宏中專用，表示所有傳入的可變參數。

• __COUNTER__

      一個累加計數宏，常用來構造唯一變量名。

• __LINE__

      記錄LOG信息時，常用的一個內置宏，預編譯時會將其替換為當前的行號。

• __FILE__

      記錄LOG信息時，常用的一個內置宏，預編譯時會將其替換為當前文件的全路徑。

• __FILE_NAME__

      記錄LOG信息時，常用的一個內置宏，預編譯時會將其替換為當前的文件名。

• __DATE__

      記錄LOG信息時，常用的一個內置宏，預編譯時會將其替換為當前日期。

• __TIME__

      記錄LOG信息時，常用的一個內置宏，預編譯時會將其替換為當前時間。

六、宏的展開規則

      通過前面的介紹，對於應用宏我們已經沒有太大的問題，並且也了解了很多宏的使用技巧。這一小節將更深入的對宏的替換規則進行討論。宏本身是支持嵌套的，例如：

#define M1(A) M2(A)
#define M2(A) A
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        M1(1);
    }
    return 0;
}

上面代碼中定義的兩個宏基本上是沒有意義的，M1宏替換后的結果是M2宏，M2宏最終被替換為參數本身，從這個例子可以看出，宏是可以嵌套遞歸展開的，但是遞歸展開是有原則，不會出現無限遞歸，例如：

#define M1(A) M2(A)
#define M2(A) M1(A)
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        M1(1); // 最終展開為 M1(1)
    }
    return 0;
}

宏的展開需要符合下面原則：

1. 在展開宏的過程中會先將參數進行展開，如果使用##對參數進行了拼接或使用#進行了處理，則此參數不會被展開。
2. 在宏的展開過程中，如果替換列表中出現了要被展開的宏，則此宏不會被展開。

上面的展開原則提到了替換列表，宏在展開過程中會維護一個替換列表，展開的過程中需要從參數到宏本身，從外層宏到內層宏一層一層的替換，每次替換的時候都會將被替換的宏名放入維護的替換列表中，再下一輪替換中，如果再次出現替換列表中出現過的宏名，則不會被再次替換。以我們上面的代碼為例進行分析：

1. 首先M1宏在第一輪替換后，被替換成了M2，此時替換列表中放入宏名M1。
2. M2依然是一個宏名，第二輪對M2進行替換，將其替換為M1，再次將M2放入替換列表，此時替換列表中有宏名M1和M2。
3. M1依然是宏名，但是替換列表中已經存在M1，此宏名不再展開。

七、宏的妙用

      這一小節，我們要轉身成為鑒賞家，來對很多實用的宏的巧妙案例進行分析與鑒賞。從這些優秀的使用案例中，可以擴寬我們對宏使用的思路。

1. MIN與MAX

      Foundataion內置了一些常用的運算宏，如獲取兩個數的最大值、最小值、絕對值等等。以MAX宏為例，這個宏的編寫基本涵蓋了函數式宏所有要注意的點，如下：

#define __NSX_PASTE__(A,B) A##B
#if !defined(MAX)
    #define __NSMAX_IMPL__(A,B,L) ({ __typeof__(A) __NSX_PASTE__(__a,L) = (A); __typeof__(B) __NSX_PASTE__(__b,L) = (B); (__NSX_PASTE__(__a,L) < __NSX_PASTE__(__b,L)) ? __NSX_PASTE__(__b,L) : __NSX_PASTE__(__a,L); })
    #define MAX(A,B) __NSMAX_IMPL__(A,B,__COUNTER__)
#endif

其中__NSMAX_IMPL__宏借助計數__COUNTER__和拼接__NSX_PASTE__宏來構造唯一的內部變量名，我們前面提供的示例宏的寫法也基本是參照這個系統宏來的。后面大家在編寫函數式宏的時候，都可以參照下這個宏的實現。

2. NSAssert等

      NSAssert是斷言宏，在開發調試中經常會使用斷言來進行安全保障，這個宏的定義如下：

#define NSAssert(condition, desc, ...)	\
    do {				\
	__PRAGMA_PUSH_NO_EXTRA_ARG_WARNINGS \
	if (__builtin_expect(!(condition), 0)) {		\
            NSString *__assert_file__ = [NSString stringWithUTF8String:__FILE__]; \
            __assert_file__ = __assert_file__ ? __assert_file__ : @"<Unknown File>"; \
	    [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd \
		object:self file:__assert_file__ \
	    	lineNumber:__LINE__ description:(desc), ##__VA_ARGS__]; \
	}				\
        __PRAGMA_POP_NO_EXTRA_ARG_WARNINGS \
    } while(0)

NSAssert宏定義中使用到了不定參數拼接消除逗號的技巧，並且是多行宏語句使用do-while進行優化的一個實踐。

3. @weakify與@strongify

        weakify與strongify是ReactCocoa中常用的兩個宏，用來處理循環引用問題。這兩個宏的定義非常巧妙，以weakify宏為例，要看懂這個宏並不是十分簡單，首先與這個宏相關的宏定義列舉如下：

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

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

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

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

#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)
#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__)
#define metamacro_at(N, ...) \
metamacro_concat(metamacro_at, N)(__VA_ARGS__)

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

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

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

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

#define metamacro_head_(FIRST, ...) FIRST

其中rac_keywordify區分DEBUG和RELEASE環境，在DEBUG環境下，其實際上是創建了一個無用的autoreleasepool，消除前面的@符號，在RELEASE環境下，其會創建一個try-catch結構，用來消除參數警告。metamacro_foreach_cxt宏比較復雜，其展開過程如下：

// 第一步： 原始宏
metamacro_foreach_cxt(rac_weakify_,, __weak, obj)
// 第二步： 展開metamacro_foreach_cxt
metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(obj))(rac_weakify_,, __weak, obj)
// 第三步： 展開metamacro_argcount      
metamacro_concat(metamacro_foreach_cxt, metamacro_at(20, obj, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1))(rac_weakify_,, __weak, obj)
// 第四步： 展開metamacro_at       
metamacro_concat(metamacro_foreach_cxt,metamacro_concat(metamacro_at, 20)(obj, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1))(rac_weakify_,, __weak, obj)
// 第五步：展開metamacro_concat       
metamacro_concat(metamacro_foreach_cxt,metamacro_at20(obj, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1))(rac_weakify_,, __weak, obj)
// 第六步：展開metamacro_at20        
metamacro_concat(metamacro_foreach_cxt,metamacro_head(1))(rac_weakify_,, __weak, obj)
// 第七步：展開metamacro_head        
metamacro_concat(metamacro_foreach_cxt,metamacro_head_(1, 0))(rac_weakify_,, __weak, obj)
// 第八步：展開metamacro_head_      
metamacro_concat(metamacro_foreach_cxt,1)(rac_weakify_,, __weak, obj)
// 第九步：展開metamacro_concat        
metamacro_foreach_cxt1(rac_weakify_,, __weak, obj)
// 第十步：展開metamacro_foreach_cxt1
rac_weakify_(0, __weak, obj)
// 第十一步：展開rac_weakify_
__weak __typeof__(obj) metamacro_concat(obj, _weak_) = (obj);
// 第十二步：展開metamacro_concat        
__weak __typeof__(obj) obj_weak_ = (obj);

strongify宏的展開與之類似。

4. ParagraphStyleSet宏

      ParagraphStyleSet宏是YYLabel中提供的一個設置屬性字符串ParagraphStyle相關屬性的快捷方法，其中使用到的一個技巧是直接使用宏的形參作為屬性名進行使用，使得各種屬性的設置都使用同一個宏即可完成，其定義如下：

#define ParagraphStyleSet(_attr_) \
[self enumerateAttribute:NSParagraphStyleAttributeName \
                 inRange:range \
                 options:kNilOptions \
              usingBlock: ^(NSParagraphStyle *value, NSRange subRange, BOOL *stop) { \
                  NSMutableParagraphStyle *style = nil; \
                  if (value) { \
                      if (CFGetTypeID((__bridge CFTypeRef)(value)) == CTParagraphStyleGetTypeID()) { \
                          value = [NSParagraphStyle yy_styleWithCTStyle:(__bridge CTParagraphStyleRef)(value)]; \
                      } \
                      if (value. _attr_ == _attr_) return; \
                      if ([value isKindOfClass:[NSMutableParagraphStyle class]]) { \
                          style = (id)value; \
                      } else { \
                          style = value.mutableCopy; \
                      } \
                  } else { \
                      if ([NSParagraphStyle defaultParagraphStyle]. _attr_ == _attr_) return; \
                      style = [NSParagraphStyle defaultParagraphStyle].mutableCopy; \
                  } \
                  style. _attr_ = _attr_; \
                  [self yy_setParagraphStyle:style range:subRange]; \
              }];

八、結語

      宏看上去簡單，但是真的用好用巧卻並不容易，我想，最好的學習方式就是在實際應用中不斷的使用，不斷的琢磨與優化。如果能將宏的使用駕輕就熟，一定會為你的代碼能力帶來質的提升。

專注技術，熱愛生活，交流技術，也做朋友。

——琿少 QQ群：805263726