blocks|key|1172907|text|我已经用JSON代码的泛型结构解决了同样的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1172908|定义宏:+REFLECT(+CLASS_NAME，MEMBER_SEQUENCE+)+where+MEMBER_SEQUENCE+is+(name)(age)(other)(...)|1172909|将反射扩展为类似以下内容：|1172910|template<>
struct+reflector<CLASS_NAME>+{
++template<typename+Visitor>
++void+visit(+Visitor&&+v+)+{
+++++v(+"name"+,+&CLASS_NAME::name+);
+++++v(+"age",+++&CLASS_NAME::age++);
+++++...+
++}
}|code-block|syntax|javascript|1172911|您可以使用BOOST_PP_SEQ_FOREACH将SEQ扩展到访问者。|1172912|然后定义你的打印访问者：|1172913|template<typename+T>
struct+print_visitor+{
++print_visitor(+T&+s+):self(s){}

++template<typename+R>
++void+operator(+const+char*+name,+R+(T::*member)+)const+{
+++++std::cout<<name<<"=+"<<self.*member<<std::endl;
++}+
++T&+self;
}

template<typename+T>
void+print(+const+T&+val+)+{
+++reflector<T>::visit(+print_visitor<T>(val)+);
}|1172914|http://bytemaster.github.com/mace/group__reflect__typeinfo.html|offset|length|1172915|https://github.com/bytemaster/mace/blob/master/libs/reflect/include/mace/reflect/reflect.hpp|1172916|entityMap|0|LINK|mutability|MUTABLE|url|http://bytemaster.github.com/mace/group__mace__reflect__typeinfo.html|1^0|0|0|0|0|0|0|0|0|1R|0|0|0|2K|1|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@$S|1D|T|1E|1|1F]]|A|$]]|$1|U|3|V|5|6|7|1G|8|@]|9|@$S|1H|T|1I|1|1J]]|A|$]]|$1|W|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|V]]]]

I have solved the same problem with my generic struct to JSON code.

Define a macro: REFLECT( CLASS_NAME, MEMBER_SEQUENCE )
where MEMBER_SEQUENCE is (name)(age)(other)(...)

Have REFLECT expand to something similar to:

<pre><code>template&lt;&gt;
struct reflector&lt;CLASS_NAME&gt; {
 template&lt;typename Visitor&gt;
 void visit( Visitor&amp;&amp; v ) {
 v( "name" , &amp;CLASS_NAME::name );
 v( "age", &amp;CLASS_NAME::age );
 ... 
 }
}
</code></pre>

You can use BOOST_PP_SEQ_FOREACH to expand the SEQ into the visitors.

Then define your print visitor: 

<pre><code>template&lt;typename T&gt;
struct print_visitor {
 print_visitor( T&amp; s ):self(s){}

 template&lt;typename R&gt;
 void operator( const char* name, R (T::*member) )const {
 std::cout&lt;&lt;name&lt;&lt;"= "&lt;&lt;self.*member&lt;&lt;std::endl;
 } 
 T&amp; self;
}

template&lt;typename T&gt;
void print( const T&amp; val ) {
 reflector&lt;T&gt;::visit( print_visitor&lt;T&gt;(val) );
}
</code></pre>

<a href="http://bytemaster.github.com/mace/group__mace__reflect__typeinfo.html">http://bytemaster.github.com/mace/group_mace_reflect__typeinfo.html</a>

<a href="https://github.com/bytemaster/mace/blob/master/libs/reflect/include/mace/reflect/reflect.hpp">https://github.com/bytemaster/mace/blob/master/libs/reflect/include/mace/reflect/reflect.hpp</a>

blocks|key|2897360|text|您需要做的是让预处理器生成关于字段的反射数据。这些数据可以存储为嵌套类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2897361|首先，为了使在预处理器中编写它变得更容易、更简洁，我们将使用类型化表达式。类型化表达式只是将类型放在括号中的表达式。因此，您将编写(int)+x，而不是编写int+x。下面是一些方便的宏，可以帮助您处理类型化表达式：|offset|length|style|CODE|2897362|#define+REM(...)+__VA_ARGS__
#define+EAT(...)

//+Retrieve+the+type
#define+TYPEOF(x)+DETAIL_TYPEOF(DETAIL_TYPEOF_PROBE+x,)
#define+DETAIL_TYPEOF(...)+DETAIL_TYPEOF_HEAD(__VA_ARGS__)
#define+DETAIL_TYPEOF_HEAD(x,+...)+REM+x
#define+DETAIL_TYPEOF_PROBE(...)+(__VA_ARGS__),
//+Strip+off+the+type
#define+STRIP(x)+EAT+x
//+Show+the+type+without+parenthesis
#define+PAIR(x)+REM+x|code-block|syntax|javascript|2897363|接下来，我们定义一个REFLECTABLE宏来生成有关每个字段(以及字段本身)的数据。这个宏将被这样调用：|2897364|REFLECTABLE
(
++++(const+char+*)+name,
++++(int)+age
)|2897365|因此，使用Boost.PP，我们迭代每个参数并生成如下数据：|2897366|//+A+helper+metafunction+for+adding+const+to+a+type
template<class+M,+class+T>
struct+make_const
{
++++typedef+T+type;
};

template<class+M,+class+T>
struct+make_const<const+M,+T>
{
++++typedef+typename+boost::add_const<T>::type+type;
};


#define+REFLECTABLE(...)+\
static+const+int+fields_n+=+BOOST_PP_VARIADIC_SIZE(__VA_ARGS__);+\
friend+struct+reflector;+\
template<int+N,+class+Self>+\
struct+field_data+{};+\
BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH,+data,+BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define+REFLECT_EACH(r,+data,+i,+x)+\
PAIR(x);+\
template<class+Self>+\
struct+field_data<i,+Self>+\
{+\
++++Self+&+self;+\
++++field_data(Self+&+self)+:+self(self)+{}+\
++++\
++++typename+make_const<Self,+TYPEOF(x)>::type+&+get()+\
++++{+\
++++++++return+self.STRIP(x);+\
++++}\
++++typename+boost::add_const<TYPEOF(x)>::type+&+get()+const+\
++++{+\
++++++++return+self.STRIP(x);+\
++++}\
++++const+char+*+name()+const+\
++++{\
++++++++return+BOOST_PP_STRINGIZE(STRIP(x));+\
++++}+\
};+\|2897367|这样做的作用是生成一个常量fields_n，即类中可反射字段的数量。然后，它为每个字段指定field_data。它也是reflector类的好友，这样即使字段是私有的，它也可以访问它们：|2897368|struct+reflector
{
++++//Get+field_data+at+index+N
++++template<int+N,+class+T>
++++static+typename+T::template+field_data<N,+T>+get_field_data(T&+x)
++++{
++++++++return+typename+T::template+field_data<N,+T>(x);
++++}

++++//+Get+the+number+of+fields
++++template<class+T>
++++struct+fields
++++{
++++++++static+const+int+n+=+T::fields_n;
++++};
};|2897369|现在，为了遍历这些字段，我们使用访问者模式。我们创建一个从0到字段数量的MPL范围，并访问该索引处的字段数据。然后，它将字段数据传递给用户提供的访问者：|2897370|struct+field_visitor
{
++++template<class+C,+class+Visitor,+class+T>
++++void+operator()(C&+c,+Visitor+v,+T)
++++{
++++++++v(reflector::get_field_data<T::value>(c));
++++}
};


template<class+C,+class+Visitor>
void+visit_each(C+&+c,+Visitor+v)
{
++++typedef+boost::mpl::range_c<int,0,reflector::fields<C>::n>+range;
++++boost::mpl::for_each<range>(boost::bind<void>(field_visitor(),+boost::ref(c),+v,+_1));
}|2897371|现在到了关键时刻，我们把它们放在一起。下面是我们如何定义Person类：|2897372|struct+Person
{
++++Person(const+char+*name,+int+age)
++++++++:
++++++++name(name),
++++++++age(age)
++++{
++++}
private:
++++REFLECTABLE
++++(
++++++++(const+char+*)+name,
++++++++(int)+age
++++)
};|2897373|下面是广义的print_fields函数：|2897374|struct+print_visitor
{
++++template<class+FieldData>
++++void+operator()(FieldData+f)
++++{
++++++++std::cout+<<+f.name()+<<+"="+<<+f.get()+<<+std::endl;
++++}
};

template<class+T>
void+print_fields(T+&+x)
{
++++visit_each(x,+print_visitor());
}|2897375|举个例子：|2897376|int+main()
{
++++Person+p("Tom",+82);
++++print_fields(p);
++++return+0;
}|2897377|以下哪项输出：|2897378|name=Tom
age=82|2897379|瞧，我们刚刚用C%2B%2B实现了反射，用了不到100行代码。|2897380|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_49_0/libs/preprocessor/doc/index.html^0|0|1T|7|26|5|0|0|A|B|0|0|5|8|0|0|0|D|8|19|A|1N|9|0|0|0|0|S|6|0|0|6|C|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1T|8|@$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1Z|8|@$D|20|E|21|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|22|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|23|8|@]|9|@$D|24|E|25|1|26]]|A|$]]|$1|S|3|T|5|J|7|27|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|28|8|@$D|29|E|2A|F|G]|$D|2B|E|2C|F|G]|$D|2D|E|2E|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|2F|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|2G|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|2H|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|2I|8|@$D|2J|E|2K|F|G]]|9|@]|A|$]]|$1|14|3|15|5|J|7|2L|8|@]|9|@]|A|$K|L]]|$1|16|3|17|5|6|7|2M|8|@$D|2N|E|2O|F|G]]|9|@]|A|$]]|$1|18|3|19|5|J|7|2P|8|@]|9|@]|A|$K|L]]|$1|1A|3|1B|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|J|7|2R|8|@]|9|@]|A|$K|L]]|$1|1E|3|1F|5|6|7|2S|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|J|7|2T|8|@]|9|@]|A|$K|L]]|$1|1I|3|1J|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|2V|8|@]|9|@]|A|$]]]|1L|$1M|$5|1N|1O|1P|A|$1Q|1R]]]]

What you need to do is have the preprocessor generate reflection data about the fields. This data can be stored as nested classes. 

First, to make it easier and cleaner to write it in the preprocessor we will use typed expression. A typed expression is just an expression that puts the type in parenthesis. So instead of writing <code>int x</code> you will write <code>(int) x</code>. Here are some handy macros to help with typed expressions:

<pre><code>#define REM(...) __VA_ARGS__
#define EAT(...)

// Retrieve the type
#define TYPEOF(x) DETAIL_TYPEOF(DETAIL_TYPEOF_PROBE x,)
#define DETAIL_TYPEOF(...) DETAIL_TYPEOF_HEAD(__VA_ARGS__)
#define DETAIL_TYPEOF_HEAD(x, ...) REM x
#define DETAIL_TYPEOF_PROBE(...) (__VA_ARGS__),
// Strip off the type
#define STRIP(x) EAT x
// Show the type without parenthesis
#define PAIR(x) REM x
</code></pre>

Next, we define a <code>REFLECTABLE</code> macro to generate the data about each field(plus the field itself). This macro will be called like this:

<pre><code>REFLECTABLE
(
 (const char *) name,
 (int) age
)
</code></pre>

So using <a href="http://www.boost.org/doc/libs/1_49_0/libs/preprocessor/doc/index.html" rel="noreferrer">Boost.PP</a> we iterate over each argument and generate the data like this:

<pre><code>// A helper metafunction for adding const to a type
template&lt;class M, class T&gt;
struct make_const
{
 typedef T type;
};

template&lt;class M, class T&gt;
struct make_const&lt;const M, T&gt;
{
 typedef typename boost::add_const&lt;T&gt;::type type;
};


#define REFLECTABLE(...) \
static const int fields_n = BOOST_PP_VARIADIC_SIZE(__VA_ARGS__); \
friend struct reflector; \
template&lt;int N, class Self&gt; \
struct field_data {}; \
BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH, data, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define REFLECT_EACH(r, data, i, x) \
PAIR(x); \
template&lt;class Self&gt; \
struct field_data&lt;i, Self&gt; \
{ \
 Self &amp; self; \
 field_data(Self &amp; self) : self(self) {} \
 \
 typename make_const&lt;Self, TYPEOF(x)&gt;::type &amp; get() \
 { \
 return self.STRIP(x); \
 }\
 typename boost::add_const&lt;TYPEOF(x)&gt;::type &amp; get() const \
 { \
 return self.STRIP(x); \
 }\
 const char * name() const \
 {\
 return BOOST_PP_STRINGIZE(STRIP(x)); \
 } \
}; \
</code></pre>

What this does is generate a constant <code>fields_n</code> that is number of reflectable fields in the class. Then it specializes the <code>field_data</code> for each field. It also friends the <code>reflector</code> class, this is so it can access the fields even when they are private:

<pre><code>struct reflector
{
 //Get field_data at index N
 template&lt;int N, class T&gt;
 static typename T::template field_data&lt;N, T&gt; get_field_data(T&amp; x)
 {
 return typename T::template field_data&lt;N, T&gt;(x);
 }

 // Get the number of fields
 template&lt;class T&gt;
 struct fields
 {
 static const int n = T::fields_n;
 };
};
</code></pre>

Now to iterate over the fields we use the visitor pattern. We create an MPL range from 0 to the number of fields, and access the field data at that index. Then it passes the field data on to the user-provided visitor:

<pre><code>struct field_visitor
{
 template&lt;class C, class Visitor, class T&gt;
 void operator()(C&amp; c, Visitor v, T)
 {
 v(reflector::get_field_data&lt;T::value&gt;(c));
 }
};


template&lt;class C, class Visitor&gt;
void visit_each(C &amp; c, Visitor v)
{
 typedef boost::mpl::range_c&lt;int,0,reflector::fields&lt;C&gt;::n&gt; range;
 boost::mpl::for_each&lt;range&gt;(boost::bind&lt;void&gt;(field_visitor(), boost::ref(c), v, _1));
}
</code></pre>

Now for the moment of truth we put it all together. Here is how we can define the <code>Person</code> class:

<pre><code>struct Person
{
 Person(const char *name, int age)
 :
 name(name),
 age(age)
 {
 }
private:
 REFLECTABLE
 (
 (const char *) name,
 (int) age
 )
};
</code></pre>

Here is the generalized <code>print_fields</code> function:

<pre><code>struct print_visitor
{
 template&lt;class FieldData&gt;
 void operator()(FieldData f)
 {
 std::cout &lt;&lt; f.name() &lt;&lt; "=" &lt;&lt; f.get() &lt;&lt; std::endl;
 }
};

template&lt;class T&gt;
void print_fields(T &amp; x)
{
 visit_each(x, print_visitor());
}
</code></pre>

An example:

<pre><code>int main()
{
 Person p("Tom", 82);
 print_fields(p);
 return 0;
}
</code></pre>

Which outputs:

<pre><code>name=Tom
age=82
</code></pre>

And voila, we have just implemented reflection in C++, in under 100 lines of code.

blocks|key|2897410|text|你需要一个元组，而不是一个类。这将很容易地解决您的所有问题，而不必求助于预处理器黑客。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2897411|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You need a tuple, not a class. This would easily solve all of your problems without having to resort to preprocessor hackery.

blocks|key|2897450|text|为什么需要使用预处理器？boost.fusion库简介中有一个与您的用例有点类似的示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2897451|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Why do you need to use preprocessor? Introduction to boost.fusion library has an example somewhat similar to your use-case.

blocks|key|1173076|text|我担心你的解决方案对于这个减少的用例来说是非常理想的。我们可以提供帮助的是，如果您除了print之外还有额外的函数，可以从字段迭代中受益。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1173077|这是Boost.Fusion+Fusion+Sequences的一个完美示例；它们可以用来引入编译时反射。最重要的是，您可以生成更通用的运行时行为。|1173078|因此，例如，您可以使用Fusion.Map+(它限制您只能在每种类型中出现一次)或其他此类幻想来声明您的元素。|1173079|如果您的类型不符合Fusion序列(或者您不想干预它的内部结构)，那么在adapted部分中有一些适配器，比如BOOST_FUSION_ADAPT_STRUCT。当然，由于并不是所有的类都是struct+(或者有公共成员)，所以还有一个更通用的类版本，它很快就会变得丑陋起来：BOOST_FUSION_ADAPT_ADT。|1173080|从quick+start窃取数据|1173081|struct+print_xml+{
++++template+<typename+T>
++++void+operator()(T+const&+x)+const+{
++++++++std::cout
++++++++++++<<+'<'+<<+typeid(x).name()+<<+'>'
++++++++++++<<+x
++++++++++++<<+"</"+<<+typeid(x).name()+<<+'>'
++++++++++++;
++++}
};

int+main()+{
++++vector<int,+char,+std::string>+stuff(1,+'x',+"howdy");
++++int+i+=+at_c<0>(stuff);
++++char+ch+=+at_c<1>(stuff);
++++std::string+s+=+at_c<2>(stuff);

++++for_each(stuff,+print_xml());
}|code-block|syntax|javascript|1173082|适配器将允许您“适配”一个类型，因此您将获得：|1173083|struct+Foo+{+int+bar;+char+const*+buzz;+};

BOOST_FUSION_ADAPT_STRUCT(
++++Foo,
++++(int,+bar)
++++(char+const*,+buzz)
)|1173084|然后：|1173085|int+main()+{
++++Foo+foo{1,+"Hello");
++++for_each(foo,+print_xml());
}|1173086|这是一个令人印象深刻的库:)|1173087|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/index.html|1|http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/introduction.html|2|http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/adapted.html|3|http://www.boost.org/doc/libs/1_46_1/libs/fusion/doc/html/fusion/adapted/adapt_struct.html|4|http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/adapted/adapt_adt.html|5|http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/quick_start.html^0|17|5|0|2|C|0|F|G|1|0|0|1J|P|2N|6|3U|M|10|7|2|1J|P|3|3U|M|4|0|1|B|5|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@]|D|@$9|1O|A|1P|1|1Q]|$9|1R|A|1S|1|1T]]|E|$]]|$1|H|3|I|5|6|7|1U|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@$9|22|A|23|1|24]|$9|25|A|26|1|27]|$9|28|A|29|1|2A]]|E|$]]|$1|L|3|M|5|6|7|2B|8|@]|D|@$9|2C|A|2D|1|2E]]|E|$]]|$1|N|3|O|5|P|7|2F|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|2G|8|@]|D|@]|E|$]]|$1|U|3|V|5|P|7|2H|8|@]|D|@]|E|$Q|R]]|$1|W|3|X|5|6|7|2I|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|P|7|2J|8|@]|D|@]|E|$Q|R]]|$1|10|3|11|5|6|7|2K|8|@]|D|@]|E|$]]|$1|12|3|-4|5|6|7|2L|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]|1A|$5|15|16|17|E|$18|1B]]|1C|$5|15|16|17|E|$18|1D]]|1E|$5|15|16|17|E|$18|1F]]|1G|$5|15|16|17|E|$18|1H]]|1I|$5|15|16|17|E|$18|1J]]]]

I am afraid that your solution is pretty optimal for this reduced usecase. Where we can help is if you have additional functions besides <code>print</code> that would benefit from iterating over the fields.

This is a perfect example for <a href="http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/index.html" rel="nofollow">Boost.Fusion</a> <a href="http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/introduction.html" rel="nofollow">Fusion Sequences</a>; they can be used to introduce compile-time reflection. On top of it you can then generate more generic runtime behavior.

So, you can for example declare your elements using a Fusion.Map (which restricts you to a single occurrence of each type) or other such fantasies.

If your type does not conform to a Fusion Sequence (or you don't want to meddle with its internals), there are adapters in the <a href="http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/adapted.html" rel="nofollow">adapted</a> section such as <a href="http://www.boost.org/doc/libs/1_46_1/libs/fusion/doc/html/fusion/adapted/adapt_struct.html" rel="nofollow"><code>BOOST_FUSION_ADAPT_STRUCT</code></a>. And of course, since not everything is a <code>struct</code> (or has public members), there is also a more generic version for classes, it just gets ugly soon: <a href="http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/adapted/adapt_adt.html" rel="nofollow"><code>BOOST_FUSION_ADAPT_ADT</code></a>.

Stealing from the <a href="http://www.boost.org/doc/libs/1_50_0/libs/fusion/doc/html/fusion/quick_start.html" rel="nofollow">quick start</a>:

<pre><code>struct print_xml {
 template &lt;typename T&gt;
 void operator()(T const&amp; x) const {
 std::cout
 &lt;&lt; '&lt;' &lt;&lt; typeid(x).name() &lt;&lt; '&gt;'
 &lt;&lt; x
 &lt;&lt; "&lt;/" &lt;&lt; typeid(x).name() &lt;&lt; '&gt;'
 ;
 }
};

int main() {
 vector&lt;int, char, std::string&gt; stuff(1, 'x', "howdy");
 int i = at_c&lt;0&gt;(stuff);
 char ch = at_c&lt;1&gt;(stuff);
 std::string s = at_c&lt;2&gt;(stuff);

 for_each(stuff, print_xml());
}
</code></pre>

The adapters will let you "adapt" a type, so you would get:

<pre><code>struct Foo { int bar; char const* buzz; };

BOOST_FUSION_ADAPT_STRUCT(
 Foo,
 (int, bar)
 (char const*, buzz)
)
</code></pre>

And then:

<pre><code>int main() {
 Foo foo{1, "Hello");
 for_each(foo, print_xml());
}
</code></pre>

It's a pretty impressive library :)

blocks|key|2897539|text|这里是我的2美分，作为对保罗的伟大的REFLECTABLE宏的补充。我需要有一个空的字段列表，即REFLECTABLE()，以便正确处理继承层次结构。下面的修改会处理这种情况：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2897540|//+http://stackoverflow.com/a/2831966/2725810
#define+REFLECTABLE_0(...)+++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++static+const+int+fields_n+=+BOOST_PP_VARIADIC_SIZE(__VA_ARGS__);+++++++++++\
++++friend+struct+reflector;+++++++++++++++++++++++++++++++++++++++++++++++++++\
++++template+<int+N,+class+Self>+struct+field_data+{};+++++++++++++++++++++++++\
++++BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH,+data,++++++++++++++++++++++++++++++++\
++++++++++++++++++++++++++++BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define+REFLECTABLE_1(...)+++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++static+const+int+fields_n+=+0;

#define+REFLECTABLE_CONST2(b,+...)+REFLECTABLE_##b(__VA_ARGS__)

#define+REFLECTABLE_CONST(b,+...)+REFLECTABLE_CONST2(b,__VA_ARGS__)


#define+REFLECTABLE(...)++++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++REFLECTABLE_CONST(BOOST_PP_IS_EMPTY(__VA_ARGS__),+__VA_ARGS__)+|code-block|syntax|javascript|2897541|entityMap^0|I|B|1C|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Here are my 2 cents as an addition to the great <code>REFLECTABLE</code> macro of Paul. I had a need to have an empty list of fields, i.e. <code>REFLECTABLE()</code>, to handle an inheritance hierarchy properly. The following modification handles this case:

<pre><code>// http://stackoverflow.com/a/2831966/2725810
#define REFLECTABLE_0(...) \
 static const int fields_n = BOOST_PP_VARIADIC_SIZE(__VA_ARGS__); \
 friend struct reflector; \
 template &lt;int N, class Self&gt; struct field_data {}; \
 BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH, data, \
 BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define REFLECTABLE_1(...) \
 static const int fields_n = 0;

#define REFLECTABLE_CONST2(b, ...) REFLECTABLE_##b(__VA_ARGS__)

#define REFLECTABLE_CONST(b, ...) REFLECTABLE_CONST2(b,__VA_ARGS__)


#define REFLECTABLE(...) \
 REFLECTABLE_CONST(BOOST_PP_IS_EMPTY(__VA_ARGS__), __VA_ARGS__) 
</code></pre>

I have a multiple classes each with different member variables that are initialized trivially in a constructor. Here is an example:

<pre><code>struct Person
{
 Person(const char *name, int age)
 :
 name(name),
 age(age)
 {
 }
private:
 const char *name;
 int age;
};
</code></pre>

Each has an associated <code>print&lt;&gt;()</code> function.

<pre><code>template &lt;&gt;
void print&lt;Person&gt;(const Person &amp;person)
{
 std::cout &lt;&lt; "name=" &lt;&lt; name &lt;&lt; "\n";
 std::cout &lt;&lt; "age=" &lt;&lt; age &lt;&lt; "\n";
}
</code></pre>

This code is error prone since the parameter list is replicated in four places. How can I rewrite the code to avoid this duplication? I'd like to use the preprocessor and/or templates.

For example, could I use the X-args preprocessor technique -- something like this?

<pre><code>#define ARGUMENTS \
 ARG(const char *, name) \
 ARG(int, age)

struct Person
{
 Person(LIST_TYPE_NAME_COMMA(ARGUMENTS))
 :
 LIST_NAME_INIT(ARGUMENTS)
 {
 }
private:
 LIST_TYPE_NAME_SEMICOLON(ARGUMENTS)
};

template &lt;&gt;
void print&lt;Person&gt;(const Person &amp;person)
{
 LIST_COUT_LINE(ARGUMENTS)
}

#undef ARGUMENTS
</code></pre>

Or better, a template-based approach?

Please don't question why I want to do this, there are reasoned design decisions that have resulted in multiple similar objects with named parameters. The parameters need to be named member variables for performance reasons. I'm just exploring whether it's possible to list the parameters and their types only once.

C++ preprocessor: avoid code repetition of member variable list

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个多个类，每个类都有不同的成员变量，这些变量在构造函数中被简单地初始化。下面是一个示例：struct Person{    Person(const char *name, int age)        :        name(name),        age(age)    {    }private:...

问C++预处理器:避免成员变量列表的代码重复
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++预处理器:避免成员变量列表的代码重复EN