雖然通過一系列的奇技淫巧，讓預處理也圖靈完備一把，但是用預處理來做計算，真的很吃力不討好。因為預處理一開始設計出來的目的，就沒什么野心，原本就僅僅只是為了做簡簡單單的文本替換工作，并沒有想過要成為正兒八經的編程語言，即便是最最縮水版腳本語言的功能要求都達不到。只是后來，實在是大量要求要批量自動生成代碼，特別是c++11之前的版本玩什么模板元編程，鋪天蓋地的要有大量相似的代碼。這些代碼用其他工具來生成，當然形式會更加漂亮，但是始終還是用原生的預處理來做這種事情會更加的方便，否則每次修改，都要運行一遍外部工具，都麻煩??！本人是傾向于用預處理來生成代碼的。另外，c++11之后，的確原來很多需要宏來生成代碼的場合已經不必要了，但是因為c++11的類型推導能力大大加強了之后，發現又有一大波地方可以用宏來生成代碼了。并不是說C++中的宏是必不可少之物，但是用了宏，真的可以減少很多很多的重復代碼，起碼紙面上的代碼清爽了很多。

預處理的原生數據類型就只有符號，然后符號只支持##的并接運算，同時，預處理也能識別并接后的結果（否則，并接運算就沒意義了），如果是宏函數，就進行調用操作，如果是宏符號，就替換文本，如果什么都不是，就什么都不做，保留符號。但是這樣的弱雞類型，顯然遠遠不能滿足離經叛道的碼猿需要。經過大量的宏編程的嘗試之后，可以很肯定一點，預處理里面只能再模擬出來一種數據類型，那就是正整數，雖然通過補碼運算來仿真負數，但是由于預處理里面的符號不能包含減號(-)字符，當然要花大力氣搗鼓負整數也是可以的，只是使用上也不方便也不直觀，性價比不高，基本上，必須用宏來生成代碼的地方，都可以不需要負整數的。

另外，預處理也沒有變量類型的概念，不要說強類型，就連弱類型也不是，完全就是無類型。正整數類型的概念全靠碼猿人肉編譯器來維護，一個循環的宏代碼生成一般都是來來回回也不知道調用了多少層宏調用，任何一個地方出錯，有時候是幾噸密密麻麻的中間失敗代碼（編譯器的預處理緩沖溢出，棄械投降），有時候就完全沒有輸出，沒有任何一丁點的提示，簡直是大海撈針的找問題。因此，在用宏循環生成代碼時，必須小心翼翼，步步為營，不得不感慨，正兒八經語言里面的類型真是好東西啊。

其實，數據類型并不重要，重要的是數據上能夠支持的運算集合以及這些運算能運用的場合。
好了，回到上文，我們用_ZPP_INC_N搞了10個數，通過復制粘貼，可以把N增加到255。實際運用中，完全足夠用了。

#define _ZPP_INC_JOIN(_A, _B) _ZPP_INC_JOIN_IMP1(_A, _B)
#define _ZPP_INC_JOIN_IMP1(_A, _B) _ZPP_INC_JOIN_IMP2(~, _A##_B)
#define _ZPP_INC_JOIN_IMP2(p, res) res

#define PP_INC(x, ) _ZPP_INC_JOIN(_ZPP_INC_, x)
#define _ZPP_INC_0 1
#define _ZPP_INC_1 2
#define _ZPP_INC_2 3
#define _ZPP_INC_3 4
#define _ZPP_INC_4 5
#define _ZPP_INC_5 6
#define _ZPP_INC_6 7
#define _ZPP_INC_7 8
#define _ZPP_INC_8 9
#define _ZPP_INC_9 10
...
#define _ZPP_INC_255 256

同樣的方式，再如法泡制PP_DEC，從256開始，一直遞減到0為止。對于大于256的數，就不支持了，那就都是未定義操作。這樣子，通過PP_INC(n)，就得到n+1；而PP_DEC(n)，則是n-1。比如PP_INC(PP_DEC(9))，其結果肯定是9了。很好，這樣子，在預處理中就實現了自然數自增1和自減1的運算了。另外，對于大于256的數，比如512傳遞給PP_INC，就只得到一個_ZPP_INC_512的符號，完全沒有任何意義。

然后，兩個自然數是否相等的判斷，也非常重要，必須支持。但是，在此之前，要實現一個宏函數PP_NOT，用來判斷入參是否為0。為0的話，則函數返回1，否則，就返回0。也即是：
PP_NOT(0) == 1
PP_NOT(23) == 0，或者 PP_NOT(var) == 0。
記住，預處理提供給我們的原生類型就只有符號和##并接運算，除此之外，別無他物。好像工具太簡陋，能完成目的嗎？不得不佩服有些碼猿的腦洞。以下代碼是這樣運作的，假設PP_NOT生成以下的調用形式，先不管PP_ARG1，至于符號~，是這樣子的，可以看成普通的變量名字，它就是占位符，因為預處理只識別逗號(,)，和小括號，至于其他符號，完全無視，那些是C/C++編譯階段才關心的符號。
PP_NOT(0) = PP_ARG1(~, 1, 0)
PP_NOT(n) = PP_ARG1(_ZPP_NOT_n, 0)
然后，讓PP_ARG1取第二個參數（碼猿的計數是從0開始的，也即是，0即是1，1即是2），就完成任務了。至于_ZPP_NOT_n是什么鬼，那個只是中間生成的臨時符號，可以舍棄。我們只需對_ZPP_NOT_0做特別處理。因此，代碼可以這樣寫了。PP_PROBE()用以生成兩個入參
#define PP_PROBE() ~, 1
#define _ZPP_NOT_0 PP_PROBE()
#define PP_NOT(_X, ...) PP_IS(PP_JOIN(_ZPP_NOT_, _X))
# define PP_IS(...) PP_ARG1(__VA_ARGS__, 0)

這樣子之后，顯然PP_NOT(n)就可以變成PP_ARG1(_ZPP_NOT_n, 0)的形式了。PP_NOT不是只需一個入參嗎？為何后面還要帶省略號，純粹是為了后面各種變態的運用，取悅編譯器。已經用宏來寫代碼了，就不必再遵守什么清規戒律，只要能完成任務就行了。

至于PP_ARG1的實現，就很簡單了，如下所示，
#define PP_ARG0(_0, ...) _0
#define PP_ARG1(_0, _1, ...) _1
#define PP_ARG2(_0, _1, _2, ...) _2

然后通過兩次取反的函數，再補上函數PP_BOOL，如果入參>0，就返回1，否則返回0，類似于整型到bool的強制類型轉換。
#define PP_BOOL(_X, ...) PP_NOT(PP_NOT(_X))

有了這些的鋪墊之后，要比較兩個自然數是否相等，就簡單了。其實沒什么神秘的，就是針對從0到255，重復256個以下形式的#define語句，
#define _ZPP_0_EQUALS_0 PP_PROBE()
#define _ZPP_1_EQUALS_1 PP_PROBE()
#define _ZPP_2_EQUALS_2 PP_PROBE()
...
#define PP_EQUALS(x, y) PP_IS(PP_CONCAT4(_ZPP_, x, _EQUALS_, y))
PP_EQUALS就是將入參并接成_ZPP_x_EQUALS_y的形式，只要x和y相同，也即是說，它們在上面的表格中，那么，道理就如同PP_NOT的實現那樣，最后結果就是1了。其實，預處理中沒有判斷這種玩意，只有表格，只有并接，只有查表。所謂的圖靈完備，說白了，沒有玄虛的，就是建表，然后查表。對相等比較取反PP_NOT，自然就得到不相等的判斷函數。
#define PP_UN_EQUALS(x, y) PP_NOT(PP_IS(PP_CONCAT4(_ZPP_, x, _EQUALS_, y)))
再次建表，就可以得到bool運算的函數，或與
#define PP_OR(a,b) PP_CONCAT3(_ZPP_OR_, a, b)
#define _ZPP_OR_00 0
#define _ZPP_OR_01 1
#define _ZPP_OR_10 1
#define _ZPP_OR_11 1

#define PP_AND(a,b) PP_CONCAT3(_ZPP_AND_, a, b)
#define _ZPP_AND_00 0
#define _ZPP_AND_01 0
#define _ZPP_AND_10 0
#define _ZPP_AND_11 1

再準備一張表格，將字節映射到8個二進制位。
#define _ZPP_BINARY_0 (0, 0, 0, 0, 0, 0, 0, 0)
#define _ZPP_BINARY_1 (0, 0, 0, 0, 0, 0, 0, 1)
#define _ZPP_BINARY_2 (0, 0, 0, 0, 0, 0, 1, 0)
#define _ZPP_BINARY_3 (0, 0, 0, 0, 0, 0, 1, 1)
#define _ZPP_BINARY_4 (0, 0, 0, 0, 0, 1, 0, 0)
...
然后通過模擬計算機組成原理里面的加減乘除的原理，就可以實現四則運算了。對了，整個預處理庫的代碼都在壓縮包上，功能比boost的預處理庫強多了，但是代碼卻少了很多，也容易理解多了，所有代碼在vs下面正常運行，其他平臺還沒有測試。代碼包：preprocessor.rar