雖然通過一系列的奇技淫巧，讓預處理也圖靈完備一把，但是用預處理來做計算，真的很吃力不討好。因為預處理一開始設計出來的目的，就沒什么野心，原本就僅僅只是為了做簡簡單單的文本替換工作，并沒有想過要成為正兒八經的編程語言，即便是最最縮水版腳本語言的功能要求都達不到。只是后來，實在是大量要求要批量自動生成代碼，特別是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下面正常運行，其他平臺還沒有測試。代碼包：/Files/huaxiazhihuo/preprocessor.rar