BOOST_PP_CAT / BOOST_PP_SEQ_CAT / BOOST_PP_SEQ_SIZE / BOOST_PP_SEQ_HEAD / BOOST_PP_LESS_EQUAL

最新推荐文章于 2023-04-11 09:43:40 发布
最新推荐文章于 2023-04-11 09:43:40 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： C++&&算法&&设计模式 文章标签： less 编译器 fold list oo c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yshuise/article/details/4211063
版权 
BOOST的预处理十分复杂。真是非常难以理清楚。下面的内容只能算作笔记，避免忘记了。
 
也只有自己能看明白了。
// push_back_.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#define  seq (a) (b) (c)
int _tmain(int argc, _TCHAR* argv[])
{  
   
    return 0;
}
// VC6 1200
// VC7 1300
// VC8 1400
// VC9 1500
#    define BOOST_PP_CAT(a, b) BOOST_PP_CAT_OO((a, b))
#    define BOOST_PP_CAT_OO(par) BOOST_PP_CAT_I ## par
#    define BOOST_PP_CAT_I(a, b) a ## b
# define BOOST_PP_SEQ_CAT(seq) /
    BOOST_PP_IF( /
    BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)), /
    BOOST_PP_SEQ_CAT_I, /
    BOOST_PP_SEQ_HEAD(seq) BOOST_PP_TUPLE_EAT_1 /
    )(seq) /
    /**/
//seq是一个带括弧的序列，如上面定义的#define seq (a) (b) (c)
# define BOOST_PP_SEQ_SIZE(seq) BOOST_PP_SEQ_SIZE_I(seq)
#    define BOOST_PP_SEQ_SIZE_I(seq) BOOST_PP_CAT(BOOST_PP_SEQ_SIZE_, BOOST_PP_SEQ_SIZE_0 seq)
//上面 BOOST_PP_CAT()括弧里面( BOOST_PPSEQ_SIZE_, BOOST_PP_SEQ_SIZE_0 seq),先对BOOST_PP_SEQ_SIZE_0进行扩展
//也就是BOOST_PP_SIZE_0 (a) (b) (c)  这是宏调用不是宏定义，对空格不敏感。
//先执行BOOST_PP_SIZE_0 (a) 为 BOOST_PP_SEQ_SIZE_1
//再扩展BOOST_PP_SEQ_SIZE_1 (b) 为 BOOST_PP_SEQ_SIZE_2
//在扩展BOOST_PP_SEQ_SIZE_2 (c) 为 BOOST_PP_SEQ_SIZE_3
//上面再用BOOST_PP_CAT(BOOST_PP_SEQ_SIZE_, BOOST_PPSEQ_SIZE_3)连接起来，成为：
//BOOST_PP_SEQ_SIZE_BOOST_PPSEQ_SIZE_3,
//而它的值为 3,就是这个序列的有三个元素的意思。
# define BOOST_PP_SEQ_SIZE_0(_) BOOST_PP_SEQ_SIZE_1
# define BOOST_PP_SEQ_SIZE_1(_) BOOST_PP_SEQ_SIZE_2
# define BOOST_PP_SEQ_SIZE_2(_) BOOST_PP_SEQ_SIZE_3
# define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_3 3
#    define BOOST_PP_DEC(x) BOOST_PP_DEC_OO((x))
#    define BOOST_PP_DEC_OO(par) BOOST_PP_DEC_I ## par
# define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x
# define BOOST_PP_DEC_0 0
# define BOOST_PP_DEC_3 2 //上面的BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)) 最终结果是 2
# define BOOST_PP_SEQ_HEAD(seq) BOOST_PP_SEQ_ELEM(0, seq) //最终得到的是首元素。
//宏调用的时候不会理会是否有空格。
//宏定义就不会忽略是否有空格。
#    define BOOST_PP_SEQ_ELEM(i, seq) BOOST_PP_SEQ_ELEM_I((i, seq))//这儿的i而序列的下标，可以得到序列的任何一个元素。
#    define BOOST_PP_SEQ_ELEM_I(i, seq) BOOST_PP_SEQ_ELEM_II((BOOST_PP_SEQ_ELEM_ ## i seq))
#    define BOOST_PP_SEQ_ELEM_II(res) BOOST_PP_SEQ_ELEM_IV(BOOST_PP_SEQ_ELEM_III res)
#    define BOOST_PP_SEQ_ELEM_III(x, _) x BOOST_PP_EMPTY()//最终得到的是x
#    define BOOST_PP_SEQ_ELEM_IV(x) x
# define BOOST_PP_EMPTY()
# define BOOST_PP_SEQ_ELEM_0(x) x, BOOST_PP_NIL//BOOST_PP_NIL只是一个符号，像占位符一样的功能。
# define BOOST_PP_SEQ_CAT_I(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_CAT_O, BOOST_PP_SEQ_HEAD(seq), BOOST_PP_SEQ_TAIL(seq))
//上面展开的部分结构是：
BOOST_PP_IF( 2, BOOST_PP_SEQ_CAT_I, a BOOST_PP_TUPLE_EAT_1 )(seq)
#    define BOOST_PP_IF(cond, t, f) BOOST_PP_IF_I(cond, t, f)
#    define BOOST_PP_IF_I(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f)
#    define BOOST_PP_BOOL(x) BOOST_PP_BOOL_OO((x))
#    define BOOST_PP_BOOL_OO(par) BOOST_PP_BOOL_I ## par
# define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x
# define BOOST_PP_BOOL_2 1 //BOOST_PP_BOOL(2)的值为1
#    define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_OO((bit, t, f))
#    define BOOST_PP_IIF_OO(par) BOOST_PP_IIF_I ## par
#    define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_ ## bit(t, f)
# define BOOST_PP_IIF_0(t, f) f //false 选f
# define BOOST_PP_IIF_1(t, f) t //true  选 t
//因此BOOST_PP_IF( 2, BOOST_PP_SEQ_CAT_I, a BOOST_PP_TUPLE_EAT_1 )(seq) 推导的结果是：
BOOST_PP_SEQ_CAT_I(seq)
# define BOOST_PP_SEQ_CAT_I(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_CAT_O, BOOST_PP_SEQ_HEAD(seq), BOOST_PP_SEQ_TAIL(seq))
//BOOST_PP_SEQ_TAIL(seq)是除第一个元素外余下的元素。
#    define BOOST_PP_SEQ_TAIL(seq) BOOST_PP_SEQ_TAIL_ID(BOOST_PP_SEQ_TAIL_I seq)
#    define BOOST_PP_SEQ_TAIL_ID(id) id
# define BOOST_PP_SEQ_TAIL_I(x)
# define BOOST_PP_SEQ_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_SEQ_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_SEQ_FOLD_LEFT_P, 256))
# define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred)
# define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
# define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
# define BOOST_PP_SEQ_FOLD_LEFT_P(n) BOOST_PP_CAT(BOOST_PP_SEQ_FOLD_LEFT_CHECK_, BOOST_PP_SEQ_FOLD_LEFT_I_ ## n(BOOST_PP_SEQ_FOLD_LEFT_O, BOOST_PP_NIL, (nil), 1))
# define BOOST_PP_SEQ_FOLD_LEFT_256(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, ss, BOOST_PP_SEQ_SIZE(ss))
# define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, ss, sz) 0
//BOOST_PP_LESS_EQUAL(2,3)
#    define BOOST_PP_LESS_EQUAL(x, y) BOOST_PP_LESS_EQUAL_I(x, y)
#    define BOOST_PP_LESS_EQUAL_I(x, y) BOOST_PP_NOT(BOOST_PP_SUB(x, y))
#    define BOOST_PP_SUB(x, y) BOOST_PP_SUB_I(x, y)
#    define BOOST_PP_SUB_I(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y)))
//2_
BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE(BOOST_PP_SUB_P,BOOST_PP_SUB_O,(2,3)))
//%%%%%
BOOST_PP_TUPLE_ELEM(2,0,(0,0))
为: 0
//1_
# define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256))
# define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred)
BOOST_PP_NODE_ENTRY_256(BOOST_PP_WHILE_P)
# define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p)
BOOST_PP_NODE_128(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)
# define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)
//XX
BOOST_PP_IIF(BOOST_PP_WHILE_P(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)
//BOOST_PP_WHILE_P(128)
#    define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))
BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_128(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_128(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))//这儿推断有错误。
//BOOST_PP_WHILE_128
# define BOOST_PP_WHILE_128(p, o, s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p##(129, s)), p, o, s)
BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(BOOST_PP_WHILE_F(129,BOOST_PP_NIL),BOOST_PP_WHILE_F,BOOST_PP_NIL,BOOST_PP_NIL))
# define BOOST_PP_WHILE_F(d, _) 0
BOOST_PP_WHILE_128_C(0,BOOST_PP_WHILE_F,BOOST_PP_NIL,BOOST_PP_NIL))
# define BOOST_PP_WHILE_128_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
BOOST_PP_IIF(0, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s))
BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3(BOOST_PP_WHILE_F,BOOST_PP_NIL,BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2(129,BOOST_PP_NIL))
# define BOOST_PP_TUPLE_EAT_2(a, b)
BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3(BOOST_PP_WHILE_F,BOOST_PP_NIL,BOOST_PP_NIL)
# define BOOST_PP_TUPLE_EAT_3(a, b, c)
BOOST_PP_NIL//这一节的最后结果
//at BOOST_PP_WHILE_128
BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_NIL), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_128(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))//
# define BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l))
BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(BOOST_PP_NIL), BOOST_PP_LIST_FOLD_LEFT_129, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(BOOST_PP_NIL, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(BOOST_PP_NIL), BOOST_PP_NIL)(129, BOOST_PP_NIL, BOOST_PP_LIST_FIRST(BOOST_PP_NIL)), BOOST_PP_LIST_REST(BOOST_PP_NIL))
#    define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list)
#    define BOOST_PP_IS_BINARY(x) BOOST_PP_IS_BINARY_I(x)
#    define BOOST_PP_IS_BINARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK)
BOOST_PP_CHECK(BOOST_PP_NIL, BOOST_PP_IS_BINARY_CHECK)
#    define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_OO((x, type))
#    define BOOST_PP_CHECK_OO(par) BOOST_PP_CHECK_D ## par
BOOST_PP_CHECK_D(BOOST_PP_NIL, BOOST_PP_IS_BINARY_CHECK)
#    define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(type x)
#    define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk)
#    define BOOST_PP_CHECK_2(chk) BOOST_PP_CHECK_3((BOOST_PP_CHECK_RESULT_ ## chk))
BOOST_PP_CHECK_3((BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK BOOST_PP_NIL))
# define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL
BOOST_PP_CHECK_3(( 0, BOOST_PP_NIL BOOST_PP_NIL))
#    define BOOST_PP_CHECK_3(im) BOOST_PP_CHECK_5(BOOST_PP_CHECK_4 im)
BOOST_PP_CHECK_5(BOOST_PP_CHECK_4( 0, BOOST_PP_NIL BOOST_PP_NIL) )
#    define BOOST_PP_CHECK_4(res, _) res
#    define BOOST_PP_CHECK_5(res) res
//最后为 0
BOOST_PP_IIF(0, BOOST_PP_LIST_FOLD_LEFT_129, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(BOOST_PP_NIL, BOOST_PP_EXPR_IIF(0, BOOST_PP_NIL)(129, BOOST_PP_NIL, BOOST_PP_LIST_FIRST(BOOST_PP_NIL)), BOOST_PP_LIST_REST(BOOST_PP_NIL))
#    define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IF_I(cond, expr)
#    define BOOST_PP_EXPR_IF_I(cond, expr) BOOST_PP_EXPR_IIF(0, BOOST_PP_NIL)
BOOST_PP_EXPR_IIF(0, BOOST_PP_NIL)
#    define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_OO((bit, expr))
#    define BOOST_PP_EXPR_IIF_OO(par) BOOST_PP_EXPR_IIF_I ## par
BOOST_PP_EXPR_IIF_I(0, BOOST_PP_NIL)
# define BOOST_PP_EXPR_IIF_I(bit, expr) BOOST_PP_EXPR_IIF_ ## bit(expr)
BOOST_PP_EXPR_IIF_0(BOOST_PP_NIL)
# define BOOST_PP_EXPR_IIF_0(expr)
# define BOOST_PP_EXPR_IIF_1(expr) expr
BOOST_PP_IIF(0, BOOST_PP_LIST_FOLD_LEFT_129, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(BOOST_PP_NIL, (129, BOOST_PP_NIL, BOOST_PP_LIST_FIRST(BOOST_PP_NIL)), BOOST_PP_LIST_REST(BOOST_PP_NIL))
BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3(BOOST_PP_NIL, (129, BOOST_PP_NIL, BOOST_PP_LIST_FIRST(BOOST_PP_NIL)), BOOST_PP_LIST_REST(BOOST_PP_NIL)))
# define BOOST_PP_TUPLE_EAT_3(a, b, c)
//推出为：
BOOST_PP_NIL
BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_NIL), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_NIL))//
BOOST_PP_BITAND(BOOST_PP_WHILE_CHECK_BOOST_PP_NIL, BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL)
# define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1
# define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1
#    define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ ## x ## y
BOOST_PP_BITAND_I(1,1)   BOOST_PP_BITAND_11
# define BOOST_PP_BITAND_11 1
//这儿的结果为：
1
// at XX
BOOST_PP_NODE_64(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)(BOOST_PP_WHILE_P)
#   define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2)
//因此 at 2_
BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE_1(BOOST_PP_SUB_P,BOOST_PP_SUB_O,(2,3)))
# define BOOST_PP_WHILE_1(p, o, s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s)
BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(BOOST_PP_SUB_P(2,(2,3)),BOOST_PP_SUB_P,BOOST_PP_SUB_O),(2,3))
# define BOOST_PP_SUB_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
BOOST_PP_TUPLE_ELEM(2,1,(2,3))
# define BOOST_PP_SUB_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
BOOST_PP_TUPLE_ELEM(2,1,(2,3))
#    define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_OO((size, index, tuple))
#    define BOOST_PP_TUPLE_ELEM_OO(par) BOOST_PP_TUPLE_ELEM_I ## par
BOOST_PP_TUPLE_ELEM_OO((2,1,(2,3)))
BOOST_PP_TUPLE_ELEM_I(2,1,(2,3))
#    define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t)
#    define BOOST_PP_TUPLE_ELEM_II(res) res
BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_2_1(2,3))
BOOST_PP_TUPLE_ELEM_2_1(2,3)
# define BOOST_PP_TUPLE_ELEM_2_1(a, b) b
3
#    define BOOST_PP_BOOL(x) BOOST_PP_BOOL_OO((x))
#    define BOOST_PP_BOOL_OO(par) BOOST_PP_BOOL_I ## par
# define BOOST_PP_BOOL_3 1
BOOST_PP_WHILE_1_C(1,BOOST_PP_SUB_P,BOOST_PP_SUB_O,(2,3))
# define BOOST_PP_WHILE_1_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s))
BOOST_PP_IIF(1, BOOST_PP_WHILE_2, (2,3) BOOST_PP_TUPLE_EAT_3)(BOOST_PP_SUB_P, BOOST_PP_SUB_O, BOOST_PP_IIF(1, BOOST_PP_SUB_O, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, (2,3)))
BOOST_PP_WHILE_2(BOOST_PP_SUB_P, BOOST_PP_SUB_O,BOOST_PP_SUB_O(2, (2,3)))
#    define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2, 0, xy), BOOST_PP_TUPLE_ELEM(2, 1, xy))
BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2,0,(2,3)),BOOST_PP_TUPLE_ELEM(2, 1, (2,3)))
BOOST_PP_SUB_O_I(2,3)
# define BOOST_PP_SUB_O_I(x, y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))
(1,2)
BOOST_PP_WHILE_2(BOOST_PP_SUB_P, BOOST_PP_SUB_O,(1,2))
# define BOOST_PP_WHILE_2(p, o, s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s)
BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(BOOST_PP_SUB_P(3, (1,2))), BOOST_PP_SUB_P, BOOST_PP_SUB_O, (1,2))
# define BOOST_PP_SUB_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
BOOST_PP_TUPLE_ELEM(2,1,(1,2))
#    define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_OO((size, index, tuple))
#    define BOOST_PP_TUPLE_ELEM_OO(par) BOOST_PP_TUPLE_ELEM_I ## par
BOOST_PP_TUPLE_ELEM_OO((2,1,(1,2)))
BOOST_PP_TUPLE_ELEM_I(2,1,(1,2))
#    define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t)
#    define BOOST_PP_TUPLE_ELEM_II(res) res
BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_2_1(1,2))
BOOST_PP_TUPLE_ELEM_2_1(1,2)
# define BOOST_PP_TUPLE_ELEM_2_1(a, b) b
2
BOOST_PP_WHILE_2_C(1, BOOST_PP_SUB_P, BOOST_PP_SUB_O, (1,2))
# define BOOST_PP_WHILE_2_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s))
BOOST_PP_IIF(1, BOOST_PP_WHILE_3, (1,2) BOOST_PP_TUPLE_EAT_3)(BOOST_PP_SUB_P, BOOST_PP_SUB_O, BOOST_PP_IIF(1, BOOST_PP_SUB_O, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, (1,2)))
BOOST_PP_WHILE_3(BOOST_PP_SUB_P, BOOST_PP_SUB_O,BOOST_PP_SUB_O(3, (1,2)))
#    define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2, 0, xy), BOOST_PP_TUPLE_ELEM(2, 1, xy))
BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2,0,(1,2)), BOOST_PP_TUPLE_ELEM(2,1,(1,2)))
BOOST_PP_SUB_O_I(1,2)
# define BOOST_PP_SUB_O_I(x, y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y))
(0,1)
BOOST_PP_WHILE_3(BOOST_PP_SUB_P, BOOST_PP_SUB_O,(0,1))
# define BOOST_PP_WHILE_3(p, o, s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s)
BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(BOOST_PP_SUB_P(4, (0,1))), BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,1))
# define BOOST_PP_SUB_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy)
BOOST_PP_TUPLE_ELEM(2,1,(0,1))
BOOST_PP_TUPLE_ELEM(2,1,(0,1))
#    define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_OO((size, index, tuple))
#    define BOOST_PP_TUPLE_ELEM_OO(par) BOOST_PP_TUPLE_ELEM_I ## par
BOOST_PP_TUPLE_ELEM_OO((2,1,(0,1)))
BOOST_PP_TUPLE_ELEM_I(2,1,(0,1))
#    define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t)
#    define BOOST_PP_TUPLE_ELEM_II(res) res
BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_2_1(0,1))
BOOST_PP_TUPLE_ELEM_2_1(0,1)
# define BOOST_PP_TUPLE_ELEM_2_1(a, b) b
1
BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(1), BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,1))
BOOST_PP_WHILE_3_C(1, BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,1))
# define BOOST_PP_WHILE_3_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s))
BOOST_PP_IIF(1, BOOST_PP_WHILE_4, (0,1) BOOST_PP_TUPLE_EAT_3)(BOOST_PP_SUB_P, BOOST_PP_SUB_O, BOOST_PP_IIF(1, BOOST_PP_SUB_O, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, (0,1)))
BOOST_PP_WHILE_4(BOOST_PP_SUB_P, BOOST_PP_SUB_O, BOOST_PP_SUB_O(4, (0,1)))
#    define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2, 0, (0,1)), BOOST_PP_TUPLE_ELEM(2, 1, (0,1)))
BOOST_PP_SUB_O_I(1, 1)
(0,0)
BOOST_PP_WHILE_4(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,0))
# define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
BOOST_PP_WHILE_4_C(0, BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,0))
# define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s)
BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(BOOST_PP_SUB_P(5, (0,0))), BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,0))
BOOST_PP_WHILE_4_C(0, BOOST_PP_SUB_P, BOOST_PP_SUB_O, (0,0))
# define BOOST_PP_WHILE_4_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s))
BOOST_PP_IIF(0, BOOST_PP_WHILE_5, (0,0) BOOST_PP_TUPLE_EAT_3)(BOOST_PP_SUB_P, BOOST_PP_SUB_O, BOOST_PP_IIF(0, BOOST_PP_SUB_O, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, (0,0)))
//最后结果是：
(0,0)

 

yshuise
关注
专栏目录
如何优雅地利用C++编程从1乘到20？
C语言与CPP编程的博客
02-18 930
击上方“C语言与CPP编程”，选择“关注/置顶/星标公众号”干货福利，第一时间送达！来自：知乎，作者：小白白链接：https://www.zhihu.com/question/365763...
boost::preprocess的神秘魔法的实现细节:BOOST_PP_SEQ_SIZE(SEQ)
taodm的专栏
01-30 2709
BOOST_PP_SEQ_SIZE还可以展示一下，BEGIN BOOST_PP_SEQ_FOLD_LEFT(SUB_S, 22, SEQ) == 10 END直接生产了2.6M的log过程。 # define SEQ (4)(1)(5)(2)   开始处理代码： BOOST_PP_SEQ_SIZE(SEQ) //--------------------------------------
BOOST_PP_SEQ_ENUM宏
freemannnn的专栏
04-26 1533
定义此宏的头文件boost\preprocessor\seq\enum.hpp 此宏用来将一个序列转换成数组。   举个例子： 先定义一个序列， #define BOOST_UNORDERED_PRIMES (17ul)(29ul)(37ul)(53ul) （此序列可以在boost\unordered\detail\util.hpp中找到） BOOST_PP_SEQ_ENUM（BOO
BOOST_PP_CAT 宏
xinqingwuji的博客
04-09 1022
Boost _ pp _ cat 宏将其参数连接在展开后。 使用 BOOST _ PP _ CAT(a、b)) 参数 a 连接的左操作数。 B 连接的右操作数。 备注 预处理器的 token-pasting 操作符(##) 会阻止参数进行展开。本宏则允许其参数在连接之前先进行展开。 连接的结果不可以引起对一个使用了BOOST_PP_CAT的宏的调用。如果发生，则BOOS...
boost 中 cat.hpp 学习笔记
LucienShui
12-21 373
boost 中 cat.hpp 学习笔记 文章地址 https://www.lucien.ink 引入 Linux 需要 install 一下 libboost-dev 这个库，macOS 没有测，Windows 日常不在考虑范围内。 BOOST_PP_CAT 宏包含于 boost/preprocessor/cat.hpp 中。 用法 BOOST_PP_CAT(a, b) 这个宏会将 a 和 b ...
BOOST_PP_CAT宏
freemannnn的专栏
04-26 3914
BOOST_PP_CAT宏主要用来连接两个标识符。此宏被其它地方用到。 头文件boost\preprocessor\cat.hpp #    define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b) #    define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(~, a ## b) #    define BOOST_
BOOST_PP_SEQ_SIZE宏
freemannnn的专栏
04-26 1133
定义此宏的头文件boost\preprocessor\seq\size.hpp 此宏用来求一个序列的长度。 举个列子： 先定义一个序列， #define BOOST_UNORDERED_PRIMES (17ul)(29ul)(37ul)(53ul) （此序列可以在boost\unordered\detail\util.hpp中找到） BOOST_PP_SEQ_SIZE（BOOST_UN
boost学习笔记
dodobear的小窝窝
04-11 1330
时间类： 1. timer类可以用来计时，progress_timer继承timer，在析构的时候会自动调用elapsed()函数，显示计时时间。 2. progress_display可以显示一个cui下面的进度条，需要在终端下面显示进度的可以用这个类 3. date类内部存储了一个32位的天数，因此可以作为基本类型用，对应的时长类为date_duration，对应的区间类为date_pe
Elasticsearch
weixin_55261016的博客
06-15 722
ELK是包含但不限于Elasticsearch（简称es）、Logstash、Kibana 三个开源软件的组成的一个整体。这三个软件合成ELK。是用于数据抽取（Logstash）、搜索分析（Elasticsearch）、数据展现（Kibana）的一整套解决方案，所以也称作ELK stack。 本课程从分别对三个组件经行详细介绍，尤其是Elasticsearch，因为它是elk的核心。本课程从es底层对文档、索引、搜索、聚合、集群经行介绍，从搜索和聚合分析实例来展现es的魅力。Logstash从内部如何采集
kaggle TMDB 票房预测 -step by step解读代码
Amor167的博客
03-22 4295
点这传送kaggle原作者 点这传送数据源&比赛 特征工程 belongs_to_collection for i, e in enumerate(train['belongs_to_collection'][:5]): print(i, e) 0 [{'id': 313576, 'name': 'Hot Tub Time Machine Collection', 'poster...
类如BOOST_PP_CAT等含有##、#的宏，需要一个中间宏的原因
ll5161551615的博客
10-29 661
在BOOST中有个BOOST_PP_CAT的宏定义: #define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b) #define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(~, a##b) #define BOOST_PP_CAT_II(p, res) res 相当于:#define M(a, ...
boost学习之BOOST_PP_SEQ_FOR_EACH_R
WangIcter的专栏
01-15 2730
BOOST_PP_SEQ_FOR_EACH_R 将seq中的每一个元素按照指定宏进行展开。它使用更高效的BOOST_PP_FOR。 用法： BOOST_PP_SEQ_FOR_EACH_R(r, macro, data, seq) 变量： r下一个 BOOST_PP_FOR 重复项。macro按照格式macro(r, data, elem)进行展开。该宏被 BOOST_PP_
boost学习之BOOST_PP_SEQ_FOR_EACH
weixin_34088838的博客
01-15 479
用途： BOOST_PP_SEQ_FOR_EACH宏，用于将一个序列中参数依次按照指定宏进行展开。 语法： BOOST_PP_SEQ_FOR_EACH(macro, data, seq) 变量： macro 一个以格式macro(r,data,elem)定义的三元宏。该宏被BOOST_PP_SEQ_FOR_EACH按照seq中每个元素进行展开。展开该宏，需要...
学习代码段重复宏：BOOST_PP_ENUM_PARAMS
qq_18661527的博客
05-25 810
需求场景 有些时候，我们想要写一段有固定规律代码，如下 int a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14 , a15 , a16 , a17 , a18 , a19; 解决方案 包含BOOST的PP库，使用BOOST_PP_ENUM_PARAMS宏 int BOOST_PP_ENUM_PARAMS(20, a); 背后原理 通过学习BOOST_PP_ENUM_PARAMS宏的实现，加深我们对
使用BOOST_PP库遍历C语言可变参数宏variadic
m
12-12 1758
1. 前言 C99和C++11规范中引入了可变参数宏(variadic macro)的概念，允许在宏函数中使用可变的参数，但是只提供了简单的展开功能。如果我们需要对每一个参数分别做不同的处理时，就需要对它们进行遍历，这时可以使用boost库中包含的preprocessor库（简称PP库）进行处理。preprocessor库中都是一些头文件，只需要包含后就可以使用了，不需要进行特别的编译和链接处理。 2. 数据类型 PP库中对序列化的数据定义了下面几种的数据类型： #define Array (3, (a,
BOOST_PP_CHECK_EMPTY宏相关的测试程序
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-19 260
BOOST_PP_CHECK_EMPTY宏相关的测试程序实现功能C++实现代码 实现功能 BOOST_PP_CHECK_EMPTY宏相关的测试程序 C++实现代码 # include <libs/preprocessor/test/test.h> # include <boost/preprocessor/facilities/check_empty.hpp> # if BOOST_PP_VARIADIC_HAS_OPT() # include <boost/preproces
boost笔记
dodobear的小窝窝
10-09 601
有用的boost函数   boost_autoboost_bindboost_functionboost_factoryboost_pp_catboost_pp_seq_for_eachboost_pp_tuple_elemboost_pp_seq_for_each_iboost_pp_seq_sizeboost_pp_ifboost_pp_seq_tailboost_pp_seq_hea
[C++]BOOST_PP_SEQ_FOR_EACH_I根据enum值访问类的不同成员
tlrainty的专栏
04-12 2179
C++中没有反射机制，所以收到一个枚举的时候想根据枚举名称调用不同的类成员/函数就很麻烦， 比如服务器传过来一个枚举enum Property{HP, MP, STR, ...}，无法修改服务器端数据结构的情况下想访问Player类中的对应成员，一般情况只能 switch(property) { case HP: DoSomething(Player.HP); break; case MP
使用BOOST_PP_SEQ_FOR_EACH宏处理序列
最新发布
weixin_42295969的博客
04-11 273
【代码】使用BOOST_PP_SEQ_FOR_EACH宏处理序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yshuise

权术横行

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值