C++ 如何使用boost预处理器生成访问器?
比如说C++ 如何使用boost预处理器生成访问器?,c++,boost,boost-preprocessor,C++,Boost,Boost Preprocessor,比如说 class A { int m_x; float m_y; double m_z; int x() const {return m_x;} float y() const {return m_y;} double z() const {return m_z;} }; 变得像 class A { MY_MACRO((int)(float)(double), (x)(y)(z)); }; 请使用boost预处理器序列来执行此操作,
class A
{
int m_x;
float m_y;
double m_z;
int x() const {return m_x;}
float y() const {return m_y;}
double z() const {return m_z;}
};
变得像
class A
{
MY_MACRO((int)(float)(double), (x)(y)(z));
};
请使用boost预处理器序列来执行此操作,因为此宏将与其他已使用boost预处理器序列的现有宏组合。免责声明:您可能应该等待,以防出现更好的答案,即使您对此答案感到满意,因为我远不是专家,这些可能不是最佳方法 第一次进近:
//two different sequences
struct A
{
MY_MACRO1((int)(float)(double),(x)(y)(z))
};
//just one sequence but you need to put two sets of parentheses around each pair
struct B
{
MY_MACRO2(((int, x))((float,y))((double,z)))
};
//one sequence but the macro is more complex
struct C
{
MY_MACRO3((int,x)(float,y)(double,z))
};
我认为这种方法提供了看起来不那么可怕的宏:
#define DECLARE_DATA_MEMBER1(R,TYPES,INDEX,NAME) \
BOOST_PP_SEQ_ELEM(INDEX,TYPES) BOOST_PP_CAT(m_,NAME);
#define DEFINE_ACCESSOR1(R,TYPES,INDEX,NAME) \
BOOST_PP_SEQ_ELEM(INDEX,TYPES) NAME(){ return BOOST_PP_CAT(m_,NAME); }
#define MY_MACRO1(TYPES,NAMES) \
BOOST_PP_SEQ_FOR_EACH_I(DECLARE_DATA_MEMBER1,TYPES,NAMES) \
public: \
BOOST_PP_SEQ_FOR_EACH_I(DEFINE_ACCESSOR1,TYPES,NAMES)
MY_宏
获取两个序列:类型
和名称
。为了声明数据成员,我使用宏declare\u data\u MEMBER1
并将序列类型作为数据,在序列NAMES
上为每个\u使用BOOST\u PP\u SEQ\u。这个“调用”DECLARE\u DATA\u MEMBER1
有4个参数:R
它是未使用的(我不知道它是做什么的),类型(类型的顺序),索引(告诉我们现在在哪个迭代中,从0开始),和名称
(与此迭代相对应的原始名称序列的元素)。
DECLARE\u DATA\u MEMBER1
和DEFINE\u ACCESSOR1
的“主体”很简单,我们只需获取类型序列中的索引
th元素,并将m
与名称
连接起来
第二种方法:
//two different sequences
struct A
{
MY_MACRO1((int)(float)(double),(x)(y)(z))
};
//just one sequence but you need to put two sets of parentheses around each pair
struct B
{
MY_MACRO2(((int, x))((float,y))((double,z)))
};
//one sequence but the macro is more complex
struct C
{
MY_MACRO3((int,x)(float,y)(double,z))
};
这个仍然相当简单,但不方便使用双括号
#define DECLARE_DATA_MEMBER2(R,_,TYPE_AND_NAME) \
BOOST_PP_TUPLE_ELEM(2,0,TYPE_AND_NAME) BOOST_PP_CAT(m_,BOOST_PP_TUPLE_ELEM(2,1,TYPE_AND_NAME));
#define DEFINE_ACCESSOR2(R,_,TYPE_AND_NAME) \
BOOST_PP_TUPLE_ELEM(2,0,TYPE_AND_NAME) BOOST_PP_TUPLE_ELEM(2,1,TYPE_AND_NAME)(){ return BOOST_PP_CAT(m_,BOOST_PP_TUPLE_ELEM(2,1,TYPE_AND_NAME)); }
#define MY_MACRO2(TYPES_AND_NAMES) \
BOOST_PP_SEQ_FOR_EACH(DECLARE_DATA_MEMBER2,_,TYPES_AND_NAMES) \
public: \
BOOST_PP_SEQ_FOR_EACH(DEFINE_ACCESSOR2,_,TYPES_AND_NAMES)
这一次只有一个序列,因此我们不需要帮助宏中的索引。因此,BOOST\u PP\u SEQ\u For\u每个
都使用宏DECLARE\u DATA\u MEMBER2
在类型和名称上使用,并且不传递任何额外数据。此宏接收三个“参数”:R
再次未使用,
(或数据
,此处也未使用),以及类型和名称
(格式为(类型,名称)
)的元组。
在两个helper宏的“body”中,BOOST\u PP\u TUPLE\u ELEM
用于获取类型(索引为0)或名称(索引为1)。此宏需要传递元组的大小、所需元素的索引和元组
第三种方法:
//two different sequences
struct A
{
MY_MACRO1((int)(float)(double),(x)(y)(z))
};
//just one sequence but you need to put two sets of parentheses around each pair
struct B
{
MY_MACRO2(((int, x))((float,y))((double,z)))
};
//one sequence but the macro is more complex
struct C
{
MY_MACRO3((int,x)(float,y)(double,z))
};
该宏大量借用了BOOST\u FUSION\u ADAPT\u STRUCT
和类似的宏
//Heavily "inspired" from BOOST_FUSION_ADAPT_STRUCT
#define CREATE_MY_MACRO_PLACEHOLDER_FILLER_0(X, Y) \
((X, Y)) CREATE_MY_MACRO_PLACEHOLDER_FILLER_1
#define CREATE_MY_MACRO_PLACEHOLDER_FILLER_1(X, Y) \
((X, Y)) CREATE_MY_MACRO_PLACEHOLDER_FILLER_0
#define CREATE_MY_MACRO_PLACEHOLDER_FILLER_0_END
#define CREATE_MY_MACRO_PLACEHOLDER_FILLER_1_END
#define DECLARE_DATA_MEMBER3(R,_,TYPE_AND_NAME) \
BOOST_PP_TUPLE_ELEM(2,0,TYPE_AND_NAME) BOOST_PP_CAT(m_,BOOST_PP_TUPLE_ELEM(2,1,TYPE_AND_NAME));
#define DEFINE_ACCESSOR3(R,_,TYPE_AND_NAME) \
BOOST_PP_TUPLE_ELEM(2,0,TYPE_AND_NAME) BOOST_PP_TUPLE_ELEM(2,1,TYPE_AND_NAME)(){ return BOOST_PP_CAT(m_,BOOST_PP_TUPLE_ELEM(2,1,TYPE_AND_NAME)); }
#define MY_MACRO3(TYPES_AND_NAMES) \
BOOST_PP_SEQ_FOR_EACH(DECLARE_DATA_MEMBER3,_,BOOST_PP_CAT(CREATE_MY_MACRO_PLACEHOLDER_FILLER_0 TYPES_AND_NAMES,_END)) \
public: \
BOOST_PP_SEQ_FOR_EACH(DEFINE_ACCESSOR3,_,BOOST_PP_CAT(CREATE_MY_MACRO_PLACEHOLDER_FILLER_0 TYPES_AND_NAMES,_END))
在这种方法中,helper宏基本上是不变的。唯一的(大)区别是for\u中使用的序列不仅仅是类型和\u名称
,而是BOOST\u PP\u CAT(创建\u我的\u宏\u占位符\u填充器\u 0类型和\u名称,\u END)
。这是一个巧妙的技巧,可以强制使用双括号。它的工作原理如下:
CREATE_MY_MACRO_PLACEHOLDER_FILLER_0(int,x)(float,y)_END
//CREATE_MY_MACRO_PLACEHOLDER_FILLER_0(A,B)->((A,B))CREATE_MY_MACRO_PLACEHOLDER_FILLER_1
((int,x))CREATE_MY_MACRO_PLACEHOLDER_FILLER_1(float,y)_END
//CREATE_MY_MACRO_PLACEHOLDER_FILLER_1(A,B)->((A,B))CREATE_MY_MACRO_PLACEHOLDER_FILLER_0
((int,x))((float,y))CREATE_MY_MACRO_PLACEHOLDER_FILLER_0_END
//CREATE_MY_MACRO_PLACEHOLDER_FILLER_0_END->
((int,x))((float,y))
我猜你会更容易操作((int,x)(float,y)(double,z))
。在不进行测试的情况下,一些采用类型和基名称的宏可以生成声明,而访问器和序列foreach可以简单地将元素传递给该声明,为每个序列元素提供两个参数。跟踪哪个成员具有哪种类型也变得更容易。我不知道有什么巫术可以将参数按类型拆分空格,但如果可能,可以是((int x)(float y)(双z))
。函数应为public@chris很好的建议。我会试试。呃,它实际上没有我想象的那么好。这个论点必须经过好几层宏,所以它会弄乱中间层。该死,我以前尝试过方法2,即使有额外的括号,但遇到了一个障碍:p我想我们正在寻找的更好的答案是不过,不需要宏就可以了。比如说,制作一个编辑器扩展来完成这项工作,并生成普通代码,甚至是一段代码片段,如果您希望有一部分public:blah;private:blah;
东西的话。