當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

makefile使用宏及用法$(宏标识符) $(cc)_宏编程的艺术

發布時間：2025/3/21 编程问答 48 豆豆

生活随笔收集整理的這篇文章主要介紹了 makefile使用宏及用法$(宏标识符) $(cc)_宏编程的艺术小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

微信限制：不能放置鏈接，代碼樣式比較奇怪，發布后不能更新。。。

寫在前面

之前寫過幾篇關于 C/C++?宏?(macro)?和 C++?元編程?(metaprogramming)?的文章：

令人頭疼的宏定義污染?列舉了兩個宏相關的?坑，并從?繞開污染源/阻止污染擴散/縮小污染范圍?的角度嘗試解決
淺談 C++ 元編程?介紹了?模板元編程?的相關問題
簡單的 C++ 結構體字段反射?利用模板元編程(和極少的宏)，實現?非侵入式、聲明式、零開銷?結構體靜態反射

C++?模板元編程?(template metaprogramming)?雖然功能強大，但也有?局限性：

不能通過模板展開生成新的?標識符?(identifier)
- 例如生成新的函數名、類名、名字空間名等
- 使用者只能使用預先定義的標識符
不能通過模板參數獲取?符號/標記?(token)?的?字面量?(literal)
- 例如在反射中獲取實參參數名的字面量，在斷言中獲取表達式的字面量
- 使用者只能通過傳遞字符串參數繞開

所以，在需要直接?操作標識符?的情況下，還需要借助?宏，進行?預處理階段的元編程：

和?編譯時?(compile-time)?的?模板?展開不同，宏?在編譯前的?預處理?(preprocess)?階段全部展開 —— 狹義上，編譯器看不到且不處理宏代碼
通過?#define/TOKEN1##TOKEN2/#TOKEN?定義?宏對象?(object-like macro)?和?宏函數?(function-like macro)，可以實現?替換文本、拼接標識符、獲取字面量?等功能

最近，需要在單元測試中自動生成調用 gmock 的代碼：

由于不便引入其他工具鏈，不能使用?代碼生成器?(code generator)
生成的代碼需要調用 gmock 的宏函數，也不能使用 C++?模板元編程
所以，只能借助?宏編程?的魔法 ?

本文使用的代碼鏈接 https://bot-man-jl.github.io/articles/2020/Macro-Programming-Art/macro-meta.cc(在線演示 https://godbolt.org/z/siE3ea)?

如何調試

介紹宏編程之前，先聊聊調試的問題。

很多人因為 “宏編程” 無法調試，而直接 “從入門到放棄” —— 不經意的?符號拼寫錯誤、參數個數錯誤，導致文本?不能正確替換，從而帶來?滿屏的編譯錯誤，最后?難以定位?問題所在 ——

最壞的情況下，編譯器?只會告訴你?cpp 文件編譯時出現?語法錯誤
最好的情況下，編譯器?可能告訴你?XXX 宏展開結果里包含?語法錯誤
而永遠?不會告訴你?是因為 XXX 宏展開成什么樣，導致 YYY 宏展開失敗
最后?只能看到?ZZZ 宏展開錯誤 ?

由于宏代碼會在編譯前全部展開，我們可以：

讓編譯器?僅輸出預處理結果
- gcc -E?讓編譯器在預處理結束后停止，不進行編譯、鏈接
- gcc -P?屏蔽編譯器輸出預處理結果的?行標記?(linemarker)，減少干擾
- 另外，由于輸出結果沒有格式化，建議先傳給?clang-format?格式化后再輸出
屏蔽?無關的?頭文件
- 臨時刪掉不影響宏展開的?#include?行
- 避免多余的?引用展開，導致實際關注的宏代碼 “被淹沒”

于是，展開錯誤一目了然(很容易發現?_REMOVE_PARENS_IMPL?的展開錯誤)：

特殊符號

和模板元編程不一樣，宏編程?沒有類型?的概念，輸入和輸出都是?符號?—— 不涉及編譯時的 C++ 語法，只進行編譯前的?文本替換：

一個?宏參數?是一個任意的?符號序列?(token sequence)，不同宏參數之間用逗號分隔
每個參數可以是?空序列，且空白字符會被忽略(例如?a + 1?和?a+1?相同)
在一個參數內，不能出現?逗號?(comma)?或不配對的?括號?(parenthesis)(例如?FOO(bool, std::pair)?被認為是?FOO()?有三個參數：bool?/?std::pair?/?int>)

如果需要把?std::pair?作為一個參數，一種方法是使用 C++ 的?類型別名?(type alias)(例如?using IntPair = std::pair;)，避免參數中出現逗號(即?FOO(bool, IntPair)?只有兩個參數)。

更通用的方法是使用?括號對?封裝每個參數(下文稱為?元組)，并在最終展開時移除括號(元組解包)即可：

#define PP_REMOVE_PARENS(T) PP_REMOVE_PARENS_IMPL T
#define PP_REMOVE_PARENS_IMPL(...) __VA_ARGS__

#define FOO(A, B) int foo(A x, B y)
#define BAR(A, B) FOO(PP_REMOVE_PARENS(A), PP_REMOVE_PARENS(B))

FOO(bool, IntPair) // -> int foo(bool x, IntPair y)
BAR((bool), (std::pair<int, int>)) // -> int foo(bool x, std::pair y)

PP_REMOVE_PARENS(T)?展開為?PP_REMOVE_PARENS_IMPL T?的形式
如果參數?T?是一個?括號對，那么展開結果會變成?調用宏函數?PP_REMOVE_PARENS_IMPL (...)?的形式
接著，PP_REMOVE_PARENS_IMPL(...)?再展開為參數本身?__VA_ARGS__(下文提到的?變長參數)，即元組?T?的內容

另外，常用宏函數代替?特殊符號，用于下文提到的?惰性求值：

#define PP_COMMA() ,
#define PP_LPAREN() (
#define PP_RPAREN() )
#define PP_EMPTY()

符號拼接

在宏編程中，拼接標識符?(identifier concatenation / token pasting)?通過?##?將宏函數的參數拼接成其他符號，再進一步展開為目標結果，是宏編程的?實現基礎。

然而，如果一個?宏參數?用于?拼接標識符(或?獲取字面量)，那么它不會被展開(例如?BAR()?在拼接前不會展開為?bar)：

#define FOO(SYMBOL) foo_ ## SYMBOL
#define BAR() bar

FOO(bar) // -> foo_bar
FOO(BAR()) // -> foo_BAR()

一種通用的方法是?延遲拼接操作(或?延遲獲取字面量操作)：

#define PP_CONCAT(A, B) PP_CONCAT_IMPL(A, B)
#define PP_CONCAT_IMPL(A, B) A##B

#define FOO(N) PP_CONCAT(foo_, N)

FOO(bar) // -> foo_bar
FOO(BAR()) // -> foo_bar

在進入宏函數前，所有?宏參數?會先進行一次?預掃描?(prescan)，完全展開?未用于?拼接標識符或獲取字面量的所有參數
在宏函數展開時，用(預掃描展開后的)參數替換展開目標里的?同名符號
在宏函數展開后，替換后的文本會進行?二次掃描?(scan twice)，繼續展開結果里出現的宏
所以，PP_CONCAT()?先展開參數，再傳遞給?PP_CONCAT_IMPL()?進行?實際拼接

延伸閱讀：使用 C++ 宏嵌套實現窄字符轉換為寬字符?by bingoli?提到了?Win32 的?TEXT()?宏?的原理。

另外，在?預掃描前后，宏函數都要求?參數個數必須匹配，否則無法展開：

PP_CONCAT(x PP_COMMA() y) // too few arguments (before prescan)
PP_CONCAT(x, PP_COMMA()) // too many arguments (after prescan)

預掃描前，x PP_COMMA() y?是一個參數
預掃描后，x, PP_COMMA()?是三個參數

自增自減

借助?PP_CONCAT()，我們可以實現?非負整數增減(即?INC(N) = N + 1?/?DEC(N) = N - 1)：

#define PP_INC(N) PP_CONCAT(PP_INC_, N)
#define PP_INC_0 1
#define PP_INC_1 2
// ...
#define PP_INC_254 255
#define PP_INC_255 256

#define PP_DEC(N) PP_CONCAT(PP_DEC_, N)
#define PP_DEC_256 255
#define PP_DEC_255 254
// ...
#define PP_DEC_2 1
#define PP_DEC_1 0

PP_INC(1) // -> 2
PP_DEC(2) // -> 1
PP_INC(256) // -> PP_INC_256 (overflow)
PP_DEC(0) // -> PP_DEC_0 (underflow)

PP_INC(N)/PP_DEC(N)?先展開為?PP_INC_N/PP_DEC_N，再經過?二次掃描?展開為對應數值?N + 1/N - 1?的符號
但上述操作有上限，若超出則無法繼續展開(例如?BOOST_PP 中多數操作的上限是 256)

邏輯運算

借助?PP_CONCAT()，我們可以實現?布爾類型(0?和?1)的?邏輯運算(與/或/非/異或/同或)：

#define PP_NOT(N) PP_CONCAT(PP_NOT_, N)
#define PP_NOT_0 1
#define PP_NOT_1 0

#define PP_AND(A, B) PP_CONCAT(PP_AND_, PP_CONCAT(A, B))
#define PP_AND_00 0
#define PP_AND_01 0
#define PP_AND_10 0
#define PP_AND_11 1

PP_AND(PP_NOT(0), 1) // -> 1
PP_AND(PP_NOT(2), 0) // -> PP_AND_PP_NOT_20

原理和?PP_INC()/PP_DEC()?類似(符號拼接 + 二次展開)
但上述操作不支持?非負整數?的通用邏輯運算(僅支持?0?和?1)
- 如果通過定義?PP_NOT_2?來支持?PP_NOT(2)，宏代碼會急劇膨脹
- 一元運算?PP_NOT()?需要考慮 N 種組合
- 二元運算?PP_AND()?則要考慮 N^2 種組合

布爾轉換

為了支持更通用的?非負整數?的邏輯運算，可以先?將整數轉換成布爾類型，而不是擴展?布爾類型?的邏輯運算：

#define PP_BOOL(N) PP_CONCAT(PP_BOOL_, N)
#define PP_BOOL_0 0
#define PP_BOOL_1 1
#define PP_BOOL_2 1
// ...

PP_AND(PP_NOT(PP_BOOL(2)), PP_BOOL(0)) // -> 0
PP_NOT(PP_BOOL(1000)) // -> PP_NOT_PP_BOOL_1000

原理和?PP_INC()/PP_DEC()?類似(符號拼接 + 二次展開)
同理，上述操作也有上限，若超出則無法繼續展開

條件選擇

借助?PP_CONCAT()?和?PP_BOOL()，我們可以實現通用的?條件選擇?表達式(PRED ? THEN : ELSE，其中?PRED?可以是?任意非負整數)：

#define PP_IF(PRED, THEN, ELSE) PP_CONCAT(PP_IF_, PP_BOOL(PRED))(THEN, ELSE)
#define PP_IF_1(THEN, ELSE) THEN
#define PP_IF_0(THEN, ELSE) ELSE

#define DEC_SAFE(N) PP_IF(N, PP_DEC(N), 0)

DEC_SAFE(2) // -> 1
DEC_SAFE(1) // -> 0
DEC_SAFE(0) // -> 0

PP_IF()?先會根據轉換后的條件?PP_BOOL(PRED)?選擇?PP_IF_1?或?PP_IF_0?符號
PP_IF_1()/PP_IF_0()?接受相同的參數，但分別展開為?THEN?或?ELSE?參數

惰性求值

需要注意?PP_IF()?的參數會在?預掃描?階段被完全展開(例如?PP_COMMA()?會被立即展開為逗號，導致參數個數錯誤)：

#define PP_COMMA_IF(N) PP_IF(N, PP_COMMA(), PP_EMPTY())

PP_COMMA_IF(1) // -> PP_IF(1, , , ) (too many arguments after prescan)

常用的技巧是?惰性求值?(lazy evaluation)，即條件選擇先?返回宏函數，再傳遞參數?延遲調用：

#define PP_COMMA_IF(N) PP_IF(N, PP_COMMA, PP_EMPTY)()

PP_COMMA_IF(0) // (empty)
PP_COMMA_IF(1) // -> ,
PP_COMMA_IF(2) // -> ,

#define SURROUND(N) PP_IF(N, PP_LPAREN, [ PP_EMPTY)() \
N \
PP_IF(N, PP_RPAREN, ] PP_EMPTY)()

SURROUND(0) // -> [0]
SURROUND(1) // -> (1)
SURROUND(2) // -> (2)

PP_COMMA_IF()?先借助?PP_IF()?返回?PP_COMMA?或?PP_EMPTY?符號
PP_COMMA/PP_EMPTY?和后邊的括號對組成?PP_COMMA()/PP_EMPTY()，再繼續展開為?逗號?或?空
如果需要展開為?其他符號?SYMBOL，可以使用?SYMBOL PP_EMPTY?作為參數，和后邊的括號對組成?PP_EMPTY()(例如?SURROUND()?使用的?[?和?])

變長參數

從 C++ 11 開始，宏函數支持了?變長參數?...，接受任意個?宏參數(用逗號分隔)：

傳入的變長參數可以用?__VA_ARGS__?獲取(也可以通過?#__VA_ARGS__?獲取逗號+空格分隔的參數字面量)
另外，允許傳遞?空參數，即?__VA_ARGS__?替換為空

對于空參數，展開時需要處理?多余逗號?的問題：

#define log(format, ...) printf("LOG: " format, __VA_ARGS__)

log("%d%f", 1, .2); // -> printf("LOG: %d%f", 1, .2);
log("hello world"); // -> printf("LOG: hello world", );
log("hello world", ); // -> printf("LOG: hello world", );

后兩種調用分別對應?不傳變長參數、變長參數為空?的情況
展開結果會多出一個逗號，導致 C/C++?編譯錯誤(而不是宏展開錯誤)

為了解決這個問題，一些編譯器(例如 gcc/clang)擴展了?, ## __VA_ARGS__?的用法 —— 如果?不傳變長參數，則省略前面的逗號：

#define log(format, ...) printf("LOG: " format, ## __VA_ARGS__)

log("%d%f", 1, .2); // -> printf("LOG: %d%f", 1, .2);
log("hello world"); // -> printf("LOG: hello world");
log("hello world", ); // -> printf("LOG: hello world", );

為了進一步處理?變長參數為空?的情況，C++ 20 引入了?__VA_OPT__?標識符 —— 如果變長參數是空參數，不展開該符號(不僅限于逗號)：

#define log(format, ...) printf("LOG: " format __VA_OPT__(,) __VA_ARGS__)

log("%d%f", 1, .2); // -> printf("LOG: %d%f", 1, .2);
log("hello world"); // -> printf("LOG: hello world");
log("hello world", ); // -> printf("LOG: hello world");

下文將借助?長度判空?和?遍歷訪問，實現?__VA_OPT__(,)?的功能。

下標訪問

借助?PP_CONCAT()，我們可以通過?下標訪問?變長參數的?特定元素：

#define PP_GET_N(N, ...) PP_CONCAT(PP_GET_N_, N)(__VA_ARGS__)
#define PP_GET_N_0(_0, ...) _0
#define PP_GET_N_1(_0, _1, ...) _1
#define PP_GET_N_2(_0, _1, _2, ...) _2
// ...
#define PP_GET_N_8(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) _8

PP_GET_N(0, foo, bar) // -> foo
PP_GET_N(1, foo, bar) // -> bar

PP_GET_N()?的參數分為兩部分：下標?N?和變長參數?...
先通過?PP_CONCAT()?選擇下標?I(從?0?開始)對應的?PP_GET_N_I?符號
PP_GET_N_I()?接受至少?I + 1?個參數(其余的參數是變長參數)，并返回第?I + 1?個參數(其余的變長參數直接丟棄)

借助?PP_REMOVE_PARENS()，我們還可以通過下標訪問?元組?的特定元素：

#define PP_GET_TUPLE(N, T) PP_GET_N(N, PP_REMOVE_PARENS(T))

PP_GET_TUPLE(0, (foo, bar)) // -> foo
PP_GET_TUPLE(1, (foo, bar)) // -> bar

需要注意?變長參數的?長度必須大于?N，否則無法展開：

#define FOO(P, T) PP_IF(P, PP_GET_TUPLE(1, T), PP_GET_TUPLE(0, T))

FOO(0, (foo, bar)) // -> foo
FOO(1, (foo, bar)) // -> bar
FOO(0, (baz)) // -> PP_GET_N_1(baz) (too few arguments)

對于?P == 0?的情況，FOO()?只返回?T?的第一個元素
但是另一個分支里的?PP_GET_TUPLE(1, T)?仍會被展開，從而要求?T?有至少兩個元素

類似的，我們可以借助?惰性求值?避免該問題：

#define FOO(P, T) PP_IF(P, PP_GET_N_1, PP_GET_N_0) T

FOO(0, (foo, bar)) // -> foo
FOO(1, (foo, bar)) // -> bar
FOO(0, (baz)) // -> baz

PP_IF()?先返回?PP_GET_N_1?或?PP_GET_N_0?符號
類似?PP_REMOVE_PARENS()，再用?PP_GET_N_I (...)?元組解包
對于?P == 0?的情況，不會展開?PP_GET_N_1()?宏

長度判空

借助?PP_GET_N()，我們可以檢查?變長參數是否為空：

#define PP_IS_EMPTY(...) \
PP_AND(PP_AND(PP_NOT(PP_HAS_COMMA(__VA_ARGS__)), \
PP_NOT(PP_HAS_COMMA(__VA_ARGS__()))), \
PP_AND(PP_NOT(PP_HAS_COMMA(PP_COMMA_V __VA_ARGS__)), \
PP_HAS_COMMA(PP_COMMA_V __VA_ARGS__())))
#define PP_HAS_COMMA(...) PP_GET_N_8(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 0, 0)
#define PP_COMMA_V(...) ,

PP_IS_EMPTY() // -> 1
PP_IS_EMPTY(foo) // -> 0
PP_IS_EMPTY(foo()) // -> 0
PP_IS_EMPTY(()) // -> 0
PP_IS_EMPTY(()foo) // -> 0
PP_IS_EMPTY(PP_EMPTY) // -> 0
PP_IS_EMPTY(PP_COMMA) // -> 0
PP_IS_EMPTY(, ) // -> 0
PP_IS_EMPTY(foo, bar) // -> 0
PP_IS_EMPTY(, , , ) // -> 0

先定義兩個輔助宏：
- PP_HAS_COMMA()?用于檢查變長參數里?有沒有逗號(原理類似下文的?PP_NARG())
- PP_COMMA_V()?用于?吃掉?(eat)?變長參數，并返回一個?逗號
如果變長參數為空，需要滿足以下條件：
- PP_COMMA_V __VA_ARGS__()?展開為逗號，即構成?PP_COMMA_V()?的形式
- __VA_ARGS__、__VA_ARGS__()?和?PP_COMMA_V __VA_ARGS__?展開結果里沒有逗號，排除對上一個條件的干擾

借助?PP_COMMA_IF()?和?PP_IS_EMPTY()，我們可以實現 C++ 20 的?__VA_OPT__(,)?功能：

#define PP_VA_OPT_COMMA(...) PP_COMMA_IF(PP_NOT(PP_IS_EMPTY(__VA_ARGS__)))
#define log(format, ...) \
printf("LOG: " format PP_VA_OPT_COMMA(__VA_ARGS__) __VA_ARGS__)

log("%d%f", 1, .2); // -> printf("LOG: %d%f", 1, .2);
log("hello world"); // -> printf("LOG: hello world");
log("hello world", ); // -> printf("LOG: hello world");

長度計算

借助?PP_GET_N()?和?PP_VA_OPT_COMMA()，我們可以計算?變長參數的個數(長度)：

#define PP_NARG(...) \
PP_GET_N(8, __VA_ARGS__ PP_VA_OPT_COMMA(__VA_ARGS__) 8, 7, 6, 5, 4, 3, 2, 1, \
0)

PP_NARG() // -> 0
PP_NARG(foo) // -> 1
PP_NARG(foo()) // -> 1
PP_NARG(()) // -> 1
PP_NARG(()foo) // -> 1
PP_NARG(PP_EMPTY) // -> 1
PP_NARG(PP_COMMA) // -> 1
PP_NARG(, ) // -> 2
PP_NARG(foo, bar) // -> 2
PP_NARG(, , , ) // -> 4

將?__VA_ARGS__ PP_VA_OPT_COMMA(__VA_ARGS__)?和?8, ..., 0?一起傳給?PP_GET_N(8, ...)
如果?__VA_ARGS__?為空，等價與?PP_GET_N(8, 8, ..., 0)，直接返回第九個元素?0
如果?__VA_ARGS__?非空，等價于?PP_GET_N(8, __VA_ARGS__, 8, ..., 0)，變長參數?__VA_ARGS__?把?8, ..., 0?向后推移，使得返回的第九個元素剛好是?__VA_ARGS__?的參數個數
然而，上述操作有上限(例如此處支持的最大長度為?8)

另外，這里只能用?PP_GET_N(8, ...)，而不能用?PP_GET_N_8()：

PP_GET_N(0, 1 PP_COMMA() 2) // -> 1
PP_GET_N_0(1 PP_COMMA() 2) // -> 1 , 2

如果使用?PP_GET_N_8()，沒被展開的?__VA_ARGS__ PP_VA_OPT_COMMA(__VA_ARGS__) 8?會被當成?包含逗號?的?一個參數，而不是多個參數
而?PP_GET_N()?在把?__VA_ARGS__?轉發給?PP_GET_N_8()?時，會把上述參數展開為多個參數

遍歷訪問

借助?PP_CONCAT()?和?PP_NARG()，我們可以?遍歷?(traverse)?變長參數：

#define PP_FOR_EACH(DO, CTX, ...) \
PP_CONCAT(PP_FOR_EACH_, PP_NARG(__VA_ARGS__))(DO, CTX, 0, __VA_ARGS__)
#define PP_FOR_EACH_0(DO, CTX, IDX, ...)
#define PP_FOR_EACH_1(DO, CTX, IDX, VAR, ...) DO(VAR, IDX, CTX)
#define PP_FOR_EACH_2(DO, CTX, IDX, VAR, ...) \
DO(VAR, IDX, CTX) \
PP_FOR_EACH_1(DO, CTX, PP_INC(IDX), __VA_ARGS__)
#define PP_FOR_EACH_3(DO, CTX, IDX, VAR, ...) \
DO(VAR, IDX, CTX) \
PP_FOR_EACH_2(DO, CTX, PP_INC(IDX), __VA_ARGS__)
// ...

#define DO_EACH(VAR, IDX, CTX) PP_COMMA_IF(IDX) CTX VAR

PP_FOR_EACH(DO_EACH, void, ) // (empty)
PP_FOR_EACH(DO_EACH, int, a, b, c) // -> int a, int b, int c
PP_FOR_EACH(DO_EACH, bool, x) // -> bool x

PP_FOR_EACH()?的參數分為三部分：元素的轉換操作?DO、遍歷的上下文參數?CTX?和變長參數?...
- 其中?DO()?接受三個參數：當前元素?VAR、對應下標?IDX?和遍歷的上下文?CTX，并返回元素?VAR?轉換后的結果
先通過?PP_CONCAT()?和?PP_NARG()?選擇變長參數長度對應的?PP_FOR_EACH_I?符號
PP_FOR_EACH_I()?的參數分為四部分：元素的轉換操作?DO、遍歷的上下文參數?CTX、當前元素下標?IDX?和變長參數?...
- 展開為兩部分：變長參數?第一個元素?的轉換?DO()?和變長參數?剩余元素?遞歸調用?I - 1?宏(下標更新為?IDX + 1)
- 當?I == 0?時，展開為空，遞歸終止

借助?PP_FOR_EACH()?和上邊的?DO_EACH()(借助其?PP_COMMA_IF()，并忽略?CTX)，我們可以實現等效于?PP_VA_OPT_COMMA()?的功能：

#define log(format, ...) \
printf("LOG: " format PP_FOR_EACH(DO_EACH, , __VA_ARGS__))

log("%d%f", 1, .2); // -> printf("LOG: %d%f", 1, .2);
log("hello world"); // -> printf("LOG: hello world");
log("hello world", ); // -> printf("LOG: hello world");

符號匹配

借助?PP_CONCAT()?和?PP_IS_EMPTY()，我們可以?匹配任意的特定符號：

#define PP_IS_SYMBOL(PREFIX, SYMBOL) PP_IS_EMPTY(PP_CONCAT(PREFIX, SYMBOL))
#define IS_VOID_void

PP_IS_SYMBOL(IS_VOID_, void) // -> 1
PP_IS_SYMBOL(IS_VOID_, ) // -> 0
PP_IS_SYMBOL(IS_VOID_, int) // -> 0
PP_IS_SYMBOL(IS_VOID_, void*) // -> 0
PP_IS_SYMBOL(IS_VOID_, void x) // -> 0
PP_IS_SYMBOL(IS_VOID_, void(int, int)) // -> 0

先定義一個輔助宏?IS_VOID_void：字面量是前綴?IS_VOID_?和目標結果?void?的拼接，展開為空
再通過?PP_CONCAT(PREFIX, SYMBOL)?把前綴和參數拼接為新的符號，并用?PP_IS_EMPTY()?檢查拼接結果展開后是否為空
只有?SYMBOL?是單個符號?void，才能展開為空
但該方法不支持?模式匹配??(如果大家有什么好想法，歡迎提出~)

借助?PP_IS_EMPTY()，我們還可以?檢查符號序列是否是元組：

#define PP_EMPTY_V(...)
#define PP_IS_PARENS(SYMBOL) PP_IS_EMPTY(PP_EMPTY_V SYMBOL)

PP_IS_PARENS() // -> 0
PP_IS_PARENS(foo) // -> 0
PP_IS_PARENS(foo()) // -> 0
PP_IS_PARENS(()foo) // -> 0
PP_IS_PARENS(()) // -> 1
PP_IS_PARENS((foo)) // -> 1
PP_IS_PARENS(((), foo, bar)) // -> 1

先定義一個輔助宏?PP_EMPTY_V()：用于?吃掉?變長參數，展開為空
再通過?PP_IS_EMPTY()?檢查?PP_EMPTY_V SYMBOL?拼接結果展開后是否為空
只有?SYMBOL?符合?(...)?的形式，PP_EMPTY_V (...)?才能展開為空

在?gmock-1.10.0?中，MOCK_METHOD()?借助?PP_IS_PARENS()，自動識別?參數是不是元組，再進行選擇性的?元組解包?—— 使用時可以只把包含逗號的參數變為元組，而其他參數保持不變：

#define PP_IDENTITY(N) N
#define TRY_REMOVE_PARENS(T) \
PP_IF(PP_IS_PARENS(T), PP_REMOVE_PARENS, PP_IDENTITY)(T)

#define FOO(A, B) int foo(A x, B y)
#define BAR(A, B) FOO(TRY_REMOVE_PARENS(A), TRY_REMOVE_PARENS(B))

FOO(bool, IntPair) // -> int foo(bool x, IntPair y)
BAR(bool, IntPair) // -> int foo(bool x, IntPair y)
BAR(bool, (std::pair<int, int>)) // -> int foo(bool x, std::pair y)

數據結構

由于?變長參數?只能表示?一維數據，如果需要處理?嵌套的多維數據，還需要高級的數據結構(例如列表的每一項包含多個屬性，而每個屬性又是一個列表；參考下文的?遞歸重入?提到的?嵌套元組)。

BOOST_PP 定義了四種數據結構：

元組?(tuple)?的每個元素通過?逗號分隔，所有元素放到一個?括號對?里
序列?(sequence)?的每個元素放到一個元組里，組成多個?連續的元組
列表?(list)?是一個?遞歸定義的二元組，第一個元素是當前元素，第二個元素是后續列表，并通過?nil?標識結束符
數組?(array)?=?元組實際長度 + 元組?組成的二元組(已過時，直接使用?元組?即可)

例如，一組數據的三個元素分別是?f(12)?/?a + 1?/?foo：

元組表示為?(f(12), a + 1, foo)
序列表示為?(f(12))(a + 1)(foo)
列表表示為?(f(12), (a + 1, (foo, PP_NIL)))
數組表示為?(3, (f(12), a + 1, foo))

另外，元組?()?表示包含一個空元素的?一元組，而不是不包含任何元素的?空元組(序列、列表、數組不涉及這個問題)。

關于上述數據結構的基本運算(下標訪問、長度計算、遍歷訪問、增刪元素、類型轉換)，推薦閱讀 BOOST_PP 源碼。

遞歸重入

因為?自參照宏?(self referential macro)?不會被展開 —— 在展開一個宏時，如果遇到當前宏的符號，則不會繼續展開，避免?無限展開?(infinite expansion)?—— 所以宏?不支持遞歸/重入。

例如，PP_FOR_EACH()?在遍歷?兩層嵌套元組?時，DO_EACH_1()?無法展開?內層元組，結果保留?PP_FOR_EACH(...)?的形式：

#define OUTER(N, T) PP_FOR_EACH(DO_EACH_1, N, PP_REMOVE_PARENS(T))
#define DO_EACH_1(VAR, IDX, CTX) \
PP_FOR_EACH(DO_EACH_2, CTX.PP_GET_TUPLE(0, VAR), \
PP_REMOVE_PARENS(PP_GET_TUPLE(1, VAR)))
#define DO_EACH_2(VAR, IDX, CTX) CTX .VAR = VAR;

// -> PP_FOR_EACH(DO_EACH_2, obj.x, x1, x2) PP_FOR_EACH(DO_EACH_2, obj.y, y1)
OUTER(obj, ((x, (x1, x2)), (y, (y1))))

一種解決方法是，在?預掃描?階段，先展開?內層元組，再把展開結果?作為參數，傳遞給?外層元組，從而避免遞歸調用(但不一定適用于所有場景)：

#define OUTER(N, T) PP_FOR_EACH(DO_EACH_1, N, PP_REMOVE_PARENS(T))
#define DO_EACH_1(VAR, IDX, CTX) CTX.VAR;
#define INNER(N, T) PP_FOR_EACH(DO_EACH_2, N, PP_REMOVE_PARENS(T))
#define DO_EACH_2(VAR, IDX, CTX) PP_COMMA_IF(IDX) CTX .VAR = VAR

// -> obj.x.x1 = x1; obj.x.x2 = x2; obj.y.y1 = y1;
OUTER(obj, (INNER(x, (x1, x2)), INNER(y, (y1))))

另一種解決方法是，定義另一個相同功能的宏?PP_FOR_EACH_INNER()，用于內層循環，從而避免和外層循環沖突(如果遍歷三層嵌套，則需要再定義一個類似的宏)：

#define PP_FOR_EACH_INNER(DO, CTX, ...) \
PP_CONCAT(PP_FOR_EACH_INNER_, PP_NARG(__VA_ARGS__)) \
(DO, CTX, 0, __VA_ARGS__)
#define PP_FOR_EACH_INNER_0(DO, CTX, IDX, ...)
#define PP_FOR_EACH_INNER_1(DO, CTX, IDX, VAR, ...) DO(VAR, IDX, CTX)
#define PP_FOR_EACH_INNER_2(DO, CTX, IDX, VAR, ...) \
DO(VAR, IDX, CTX) \
PP_FOR_EACH_INNER_1(DO, CTX, PP_INC(IDX), __VA_ARGS__)
// ...

#define OUTER(N, T) PP_FOR_EACH(DO_EACH_1, N, PP_REMOVE_PARENS(T))
#define DO_EACH_1(VAR, IDX, CTX) \
PP_FOR_EACH_INNER(DO_EACH_2, CTX.PP_GET_TUPLE(0, VAR), \
PP_REMOVE_PARENS(PP_GET_TUPLE(1, VAR)))
#define DO_EACH_2(VAR, IDX, CTX) CTX .VAR = VAR;

// -> obj.x.x1 = x1; obj.x.x2 = x2; obj.y.y1 = y1;
OUTER(obj, ((x, (x1, x2)), (y, (y1))))

條件循環

上文提到的?PP_FOR_EACH()?主要用于?遍歷?變長參數的元素，輸出長度和輸入相同。但有時候，我們仍需要一個用于?迭代?(iterate)?的?條件循環?PP_WHILE()，最后只輸出一個結果：

#define PP_WHILE PP_WHILE_1
#define PP_WHILE_1(PRED, OP, VAL) \
PP_IF(PRED(VAL), PP_WHILE_2, VAL PP_EMPTY_V) \
(PRED, OP, PP_IF(PRED(VAL), OP, PP_EMPTY_V)(VAL))
#define PP_WHILE_2(PRED, OP, VAL) \
PP_IF(PRED(VAL), PP_WHILE_3, VAL PP_EMPTY_V) \
(PRED, OP, PP_IF(PRED(VAL), OP, PP_EMPTY_V)(VAL))
#define PP_WHILE_3(PRED, OP, VAL) \
PP_IF(PRED(VAL), PP_WHILE_4, VAL PP_EMPTY_V) \
(PRED, OP, PP_IF(PRED(VAL), OP, PP_EMPTY_V)(VAL))
#define PP_WHILE_4(PRED, OP, VAL) \
PP_IF(PRED(VAL), PP_WHILE_5, VAL PP_EMPTY_V) \
(PRED, OP, PP_IF(PRED(VAL), OP, PP_EMPTY_V)(VAL))
// ...

#define PRED(VAL) PP_GET_TUPLE(1, VAL)
#define OP(VAL) \
(PP_GET_TUPLE(0, VAL) + PP_GET_TUPLE(1, VAL), PP_DEC(PP_GET_TUPLE(1, VAL)))

PP_GET_TUPLE(0, PP_WHILE(PRED, OP, (x, 2))) // -> x + 2 + 1

PP_WHILE()?接受三個參數：循環條件謂詞?PRED、迭代操作運算?OP?和初始值?VAL
- 其中?PRED()?接受當前值?VAL?作為參數，并返回非負整數
- 其中?OP()?接受當前值?VAL?作為參數，并返回迭代后的下一個?VAL?值
原理和?PP_FOR_EACH()?類似，PP_WHILE_I()?根據?PRED(VAL)?選擇展開方式
- 如果?PRED(VAL) != 0，遞歸調用?I + 1?宏，并傳入?OP(VAL)?作為?下一輪迭代?的當前值
- 如果?PRED(VAL) == 0，展開為?VAL，并?跳過?OP(VAL)，遞歸終止
PP_WHILE?從?PP_WHILE_1?開始迭代

和?PP_FOR_EACH()?不同，不需要定義?PP_WHILE_INNER()，就可以在循環展開時重入 —— 如果?當前遞歸狀態?是?I，重入代碼可以使用任意?I?以后的宏：

例如當展開?PP_WHILE_2()?時，只有?PP_WHILE_1?和?PP_WHILE_2?正在展開，所以?PRED()/OP()?可以使用?PP_WHILE_3()?及以后的宏
由于?PRED(VAL)/OP(VAL)?只在參數里展開，在下一輪迭代的?PP_WHILE_3()?展開時，不會構成遞歸調用

為了支持方便的遞歸調用，BOOST_PP 提出了?自動推導?當前遞歸狀態?的方法：

#define PP_WHILE PP_CONCAT(PP_WHILE_, PP_AUTO_DIM(PP_WHILE_CHECK))

#define PP_AUTO_DIM(CHECK) \
PP_IF(CHECK(2), PP_AUTO_DIM_12, PP_AUTO_DIM_34)(CHECK)
#define PP_AUTO_DIM_12(CHECK) PP_IF(CHECK(1), 1, 2)
#define PP_AUTO_DIM_34(CHECK) PP_IF(CHECK(3), 3, 4)

#define PP_WHILE_CHECK(N) \
PP_CONCAT(PP_WHILE_CHECK_, PP_WHILE_##N(0 PP_EMPTY_V, , 1))
#define PP_WHILE_CHECK_1 1
#define PP_WHILE_CHECK_PP_WHILE_1(PRED, OP, VAL) 0
#define PP_WHILE_CHECK_PP_WHILE_2(PRED, OP, VAL) 0
#define PP_WHILE_CHECK_PP_WHILE_3(PRED, OP, VAL) 0
#define PP_WHILE_CHECK_PP_WHILE_4(PRED, OP, VAL) 0
// ...

#define OP_1(VAL) \
(PP_GET_TUPLE(0, PP_WHILE(PRED, OP_2, \
(PP_GET_TUPLE(0, VAL), PP_GET_TUPLE(1, VAL), \
PP_GET_TUPLE(1, VAL)))), \
PP_DEC(PP_GET_TUPLE(1, VAL)))
#define OP_2(VAL) \
(PP_GET_TUPLE(0, VAL) + PP_GET_TUPLE(2, VAL) * PP_GET_TUPLE(1, VAL), \
PP_DEC(PP_GET_TUPLE(1, VAL)), PP_GET_TUPLE(2, VAL))

PP_GET_TUPLE(0, PP_WHILE(PRED, OP_1, (x, 2))) // -> x + 2 * 2 + 2 * 1 + 1 * 1

定義輔助宏?PP_WHILE_CHECK(I)?用于檢查?I?對應的?PP_WHILE_I()?是否可用
- 使用?0 PP_EMPTY_V?作為謂詞，調用?PP_WHILE_I()
- 如果?PP_WHILE_I()?正在展開，此處不會再被展開，和前綴?PP_WHILE_CHECK_?拼接為?PP_WHILE_CHECK_PP_WHILE_I(0 PP_EMPTY_V, , 1)?的形式，最后展開為?0
- 如果?PP_WHILE_I()?沒有使用，此處先被展開為?1，再和前綴?PP_WHILE_CHECK_?拼接為?PP_WHILE_CHECK_1?的形式，最后展開為?1
定義輔助宏?PP_AUTO_DIM()?用于推導?最小可用的遞歸狀態?I
- 使用?二分查找?(binary search)?的方法，時間復雜度可以降到 O(logN)
- 假設?下標最大值?是?4，那么先檢查?2?是否可用；如果可用再嘗試?1，否則檢查?3
PP_WHILE?通過?PP_AUTO_DIM(PP_WHILE_CHECK)?推導出的?PP_WHILE_I?保證總是可用

不過，在展開?PP_WHILE()?時，當前遞歸狀態?總是確定的，實際上?不需要推導。所以 BOOST_PP 建議盡量?傳遞狀態，而不是自動推導：

PP_WHILE_I()?展開時，把下一個狀態的下標?I + 1(連同當前?VAL)傳給?PRED(PP_INC(I), VAL)?和?OP(PP_INC(I), VAL)
PRED()/OP()?可以直接使用?I + 1?對應的宏(及?I + 1?以后的宏)，不再需要用?PP_AUTO_DIM()?推導可用的下標

延遲展開

CHAOS_PP 提出了一種?基于?延遲展開?的遞歸調用方法：

#define PP_WHILE_RECURSIVE(PRED, OP, VAL) \
PP_IF(PRED(VAL), PP_WHILE_DEFER, VAL PP_EMPTY_V) \
(PRED, OP, PP_IF(PRED(VAL), OP, PP_EMPTY_V)(VAL))
#define PP_WHILE_INDIRECT() PP_WHILE_RECURSIVE
#define PP_WHILE_DEFER PP_WHILE_INDIRECT PP_EMPTY PP_EMPTY PP_EMPTY()()()()

// -> PP_WHILE_INDIRECT PP_EMPTY PP_EMPTY()()()
PP_WHILE_DEFER
// -> PP_WHILE_INDIRECT PP_EMPTY()()
PP_IDENTITY(PP_WHILE_DEFER)
// -> PP_WHILE_INDIRECT ()
PP_IF(1, PP_WHILE_DEFER, )
// -> PP_WHILE_RECURSIVE
PP_IDENTITY(PP_IF(1, PP_WHILE_DEFER, ))

和?PP_WHILE_I()?類似，PP_WHILE_RECURSIVE()?在?PRED(VAL) != 0?的情況下，展開為調用?PP_WHILE_DEFER?宏(即?PP_WHILE_INDIRECT PP_EMPTY PP_EMPTY PP_EMPTY()()()())的形式
其中的?PP_EMPTY()?起到了?延遲展開?的作用
- PP_WHILE_DEFER?會被原地展開為?PP_WHILE_INDIRECT PP_EMPTY PP_EMPTY()()()，即其中一組?PP_EMPTY()?展開為空，然后?停止展開
- PP_WHILE_DEFER?作為參數傳給?PP_IF()?時，一組?PP_EMPTY()?再展開為空；再作為?PP_IF()?的結果傳出時，一組?PP_EMPTY()?又展開為空；最后得到?PP_WHILE_INDIRECT()，然后?停止展開
- 所以，在當前場景下，需要至少 3 組?PP_EMPTY()
在?PP_WHILE_RECURSIVE()?展開時
- 如果?PP_WHILE_DEFER?內的?PP_EMPTY()?數量不足，就不會形成?PP_WHILE_INDIRECT()，而直接變為?PP_WHILE_RECURSIVE
- 然而，自參照的宏符號?PP_WHILE_RECURSIVE?不能繼續展開，即使使用下文提到的?PP_EXPAND()?也不行

在每次循環結束后，得到的?PP_WHILE_INDIRECT()，需要先?手動展開?為?PP_WHILE_RECURSIVE，再進入下一輪迭代，直到?PRED(VAL) == 0?為止：

#define PP_EXPAND(...) __VA_ARGS__

// -> PP_WHILE_INDIRECT() (PRED, OP, (x + 2, 1))
PP_WHILE_RECURSIVE(PRED, OP, (x, 2))
// -> PP_WHILE_INDIRECT() (PRED, OP, (x + 2 + 1, 0))
PP_EXPAND(PP_WHILE_RECURSIVE(PRED, OP, (x, 2)))
// -> (x + 2 + 1, 0)
PP_EXPAND(PP_EXPAND(PP_WHILE_RECURSIVE(PRED, OP, (x, 2))))

需要展開幾輪?PP_WHILE_RECURSIVE()，就需要嵌套幾次?PP_EXPAND()
所以，可以定義一個嵌套層數為?最大循環次數?的輔助宏，專門用于?PP_WHILE_RECURSIVE()?的延遲展開機制

需要注意?上述方法不一定適用于所有編譯器，一般建議使用?PP_WHILE()。

數值運算

借助?PP_WHILE()?和?PP_INC()/PP_DEC()，我們可以實現?非負整數加法：

#define PP_ADD(X, Y) PP_GET_TUPLE(0, PP_WHILE(PP_ADD_P, PP_ADD_O, (X, Y)))
#define PP_ADD_P(V) PP_GET_TUPLE(1, V)
#define PP_ADD_O(V) (PP_INC(PP_GET_TUPLE(0, V)), PP_DEC(PP_GET_TUPLE(1, V)))

PP_ADD(0, 2) // -> 2
PP_ADD(1, 1) // -> 2
PP_ADD(2, 0) // -> 2

PP_ADD()?從二元組?(X, Y)?開始迭代
迭代操作?PP_ADD_O()?返回?(X + 1, Y - 1)
終止條件?PP_ADD_P()?是?Y == 0，此時的?X?為所求(可能上溢)

借助?PP_WHILE()?和?PP_DEC()，我們還可以實現?非負整數減法：

#define PP_SUB(X, Y) PP_GET_TUPLE(0, PP_WHILE(PP_SUB_P, PP_SUB_O, (X, Y)))
#define PP_SUB_P(V) PP_GET_TUPLE(1, V)
#define PP_SUB_O(V) (PP_DEC(PP_GET_TUPLE(0, V)), PP_DEC(PP_GET_TUPLE(1, V)))

PP_SUB(2, 2) // -> 0
PP_SUB(2, 1) // -> 1
PP_SUB(2, 0) // -> 2

PP_SUB()?從二元組?(X, Y)?開始迭代
迭代操作?PP_SUB_O()?返回?(X - 1, Y - 1)
終止條件?PP_SUB_P()?是?Y == 0，此時的?X?為所求(可能下溢)

借助?PP_WHILE()?和?PP_ADD()，我們可以實現?非負整數乘法：

#define PP_MUL(X, Y) PP_GET_TUPLE(0, PP_WHILE(PP_MUL_P, PP_MUL_O, (0, X, Y)))
#define PP_MUL_P(V) PP_GET_TUPLE(2, V)
#define PP_MUL_O(V) \
(PP_ADD(PP_GET_TUPLE(0, V), PP_GET_TUPLE(1, V)), PP_GET_TUPLE(1, V), \
PP_DEC(PP_GET_TUPLE(2, V)))

PP_MUL(1, 2) // -> 2
PP_MUL(2, 1) // -> 2
PP_MUL(2, 0) // -> 0
PP_MUL(0, 2) // -> 0

PP_MUL()?從三元組?(R, X, Y)?開始迭代(R?初始值為?0)
迭代操作?PP_MUL_O()?返回?(R + X, X, Y - 1)(此處的?PP_ADD()?內部調用?PP_WHILE()?宏，構成?遞歸重入)
終止條件?PP_MUL_P()?是?Y == 0，此時的?R?為所求(可能上溢)

除法和取模運算?基于?數值比較，見下文。

數值比較

借助?PP_WHILE()?和?PP_DEC()，我們還可以實現?等于比較：

#define PP_CMP(X, Y) PP_WHILE(PP_CMP_P, PP_CMP_O, (X, Y))
#define PP_CMP_P(V) \
PP_AND(PP_BOOL(PP_GET_TUPLE(0, V)), PP_BOOL(PP_GET_TUPLE(1, V)))
#define PP_CMP_O(V) (PP_DEC(PP_GET_TUPLE(0, V)), PP_DEC(PP_GET_TUPLE(1, V)))

#define PP_EQUAL(X, Y) PP_IDENTITY(PP_EQUAL_IMPL PP_CMP(X, Y))
#define PP_EQUAL_IMPL(RX, RY) PP_AND(PP_NOT(PP_BOOL(RX)), PP_NOT(PP_BOOL(RY)))

PP_EQUAL(1, 2) // -> 0
PP_EQUAL(1, 1) // -> 1
PP_EQUAL(1, 0) // -> 0

PP_CMP()?從二元組?(X, Y)?開始迭代
- 迭代操作?PP_CMP_O()?返回?(X - 1, Y - 1)(同?PP_SUB_O())
- 終止條件?PP_CMP_P()?是?X == 0 || Y == 0，此時的?(X, Y)?為所求(不會下溢)
- 最終結果?(RX, RY)?只有三種情況：RX == 0 && RY == 0?/?RX != 0 && RY == 0?/?RX == 0 && RY != 0
PP_EQUAL()?返回?RX == 0 && RY == 0?的布爾值
類似?PP_WHILE_RECURSIVE()，PP_EQUAL_IMPL PP_CMP(X, Y)?在?PP_CMP()?展開為?(RX, RY)?后，仍需要借助?PP_IDENTITY()?手動展開?PP_EQUAL_IMPL(RX, RY)

類似的，我們還可以實現?小于比較：

#define PP_LESS(X, Y) PP_IDENTITY(PP_LESS_IMPL PP_CMP(X, Y))
#define PP_LESS_IMPL(RX, RY) PP_AND(PP_NOT(PP_BOOL(RX)), PP_BOOL(RY))

PP_LESS(0, 1) // -> 1
PP_LESS(1, 2) // -> 1
PP_LESS(1, 1) // -> 0
PP_LESS(2, 1) // -> 0

借助?PP_CMP()?的結果，PP_LESS()?返回?RX == 0 && RY != 0?的布爾值

其他比較方式(不等于、大于、小于等于、大于等于)可以通過?PP_EQUAL()/PP_LESS()?的布爾運算得到。

借助?PP_IF()?和?PP_LESS()，我們可以獲取?最大值/最小值：

#define PP_MIN(X, Y) PP_IF(PP_LESS(X, Y), X, Y)
#define PP_MAX(X, Y) PP_IF(PP_LESS(X, Y), Y, X)

PP_MIN(0, 1) // -> 0
PP_MIN(1, 1) // -> 1
PP_MAX(1, 2) // -> 2
PP_MAX(2, 1) // -> 2

借助?PP_WHILE()?和?PP_SUB()/PP_LESS()，我們可以實現?非負整數除法/取模：

#define PP_DIV_BASE(X, Y) PP_WHILE(PP_DIV_BASE_P, PP_DIV_BASE_O, (0, X, Y))
#define PP_DIV_BASE_P(V) \
PP_NOT(PP_LESS(PP_GET_TUPLE(1, V), PP_GET_TUPLE(2, V))) // X >= Y
#define PP_DIV_BASE_O(V) \
(PP_INC(PP_GET_TUPLE(0, V)), PP_SUB(PP_GET_TUPLE(1, V), PP_GET_TUPLE(2, V)), \
PP_GET_TUPLE(2, V))

#define PP_DIV(X, Y) PP_GET_TUPLE(0, PP_DIV_BASE(X, Y))
#define PP_MOD(X, Y) PP_GET_TUPLE(1, PP_DIV_BASE(X, Y))

PP_DIV(2, 1), PP_MOD(2, 1) // -> 2, 0
PP_DIV(1, 1), PP_MOD(1, 1) // -> 1, 0
PP_DIV(0, 1), PP_MOD(0, 1) // -> 0, 0
PP_DIV(1, 2), PP_MOD(1, 2) // -> 0, 1

PP_DIV_BASE()?從三元組?(R, X, Y)?開始迭代(R?初始值為?0)
迭代操作?PP_DIV_BASE_O()?返回?(R + 1, X - Y, Y)(此處的?PP_SUB()?內部調用?PP_WHILE()?宏，構成?遞歸重入)
終止條件?PP_DIV_BASE_P()?是?X >= Y，此時的?R?為商、X?為余數(R?可能上溢，X?不會下溢)

結合模板

有時候，可以使用 C++ 模板處理?類型，不必完全依賴于宏。例如把函數的?class?類型參數轉為?const T&，而其他類型參數保持?T：

template <typename T, bool Condition = std::is_class_v>using maybe_cref_t =std::conditional_tstd::add_lvalue_reference_t<std::add_const_t>,
T>;#define MAKE_ARG(TYPE, IDX, _) \
PP_COMMA_IF(IDX) maybe_cref_t PP_CONCAT(v, IDX)// -> void foo(maybe_cref_t v0, maybe_cref_t<:string> v1);// -> void foo(int v0, const std::string& v1);void foo(PP_FOR_EACH(MAKE_ARG, , int, std::string));

宏展開結果為?maybe_cref_t?和?maybe_cref_t<:string>
C++ 模板展開結果為?int?和?const std::string&
如果只用宏，很難完成這項任務

參考資料

本文的用法?主要參考?以下資料：

BOOST_PP：目前流行的?預處理庫?(preprocessor library)(導讀：Appendix A - An Introduction to Preprocessor Metaprogramming by David Abrahams and Aleksey Gurtovoy)
CHAOS_PP：BOOST_PP 的前身(by Vesa Karvonen/Paul Mensonides)
GMOCK_PP：BOOST_PP 精簡版，在 gmock-1.10.0?中用于?MOCK_METHOD()?自動推導參數個數
ORDER_PP：CHAOS_PP 的衍生(Vesa 設計的 ORDER 語言)
pfultz2/Cloak：CHAOS_PP 的精選(導讀：C Preprocessor tricks, tips, and idioms)

寫在最后

本文主要介紹了宏編程的常用方法，但可能存在不足：

不一定適用于所有編譯器(例如 BOOST_PP 源碼針對 MSVC 做了很多兼容處理)
部分代碼沒考慮到某些特殊場景(例如?PP_IS_SYMBOL()?不能檢查以非標識符開頭的參數)

實際應用場景中，建議使用成熟的預處理庫。

如果有什么問題，歡迎交流。?

Delivered under MIT License ? 2020, BOT Man

左下角 閱讀原文 ??/?分享文章??

右下角 留言評論~ ? / 覺得好看??

總結

以上是生活随笔為你收集整理的makefile使用宏及用法$(宏标识符) $(cc)_宏编程的艺术的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： micropython解释器原理_了解一
下一篇： jpa query 取数组第一个_数据结