blocks|key|276733|text|C%2B%2B不支持开箱即用的反射，因此您所要求的在核心语言中是不可能实现的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|276734|不同的库试图提供这样的功能，通常是通过一些方法或宏注册字段，这将在后台将字段保存到某种类型的集合中，您可以在该集合上进行迭代。|276735|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

C++ does not support reflection out of the box, so what you are asking for is impossible within the core language.

Various libraries try to provide such functionality, typically by making you register your fields through some methods or macros, which will behind the scene save them into a collection of some sort, on which you can iterate.

blocks|key|60360|text|有几种方法可以做到这一点，但您需要使用一些宏来定义或调整结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|60361|您可以使用this+answer中提供的REFLECTABLE宏来定义结构，如下所示：|offset|length|style|CODE|60362|struct+A
{
++++REFLECTABLE
++++(
++++++++(int)+a,
++++++++(int)+b,
++++++++(const+char+*)+c
++++)
};|code-block|syntax|javascript|60363|然后，您可以遍历字段并打印每个值，如下所示：|60364|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());
}

A+x;
print_fields(x);|60365|另一种方法是将结构调整为融合序列(参见the+documentation)。下面是一个例子：|60366|struct+A
{
++++int+a;
++++int+b;
++++const+char+*+c;
};

BOOST_FUSION_ADAPT_STRUCT
(
++++A,
++++(int,+a)
++++(int,+b)
++++(const+char+*,+c)
)|60367|然后，您还可以使用以下命令打印这些字段：|60368|struct+print_visitor
{
++++template<class+Index,+class+C>
++++void+operator()(Index,+C+&+c)
++++{

++++++++std::cout+<<+boost::fusion::extension::struct_member_name<C,+Index::value>::call()+
++++++++++++++++++<<+"="+
++++++++++++++++++<<+boost:::fusion::at<Index>(c)+
++++++++++++++++++<<+std::endl;
++++}
};


template<class+C>
void+print_fields(C+&+c)
{
++++typedef+boost::mpl::range_c<int,0,+boost::fusion::result_of::size<C>::type::value>+range;
++++boost::mpl::for_each<range>(boost::bind<void>(print_visitor(),+_1,+boost::ref(c)));
}|60369|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/11744832/375343|1|http://www.boost.org/doc/libs/1_55_0/libs/fusion/doc/html/fusion/adapted/adapt_struct.html^0|0|K|B|5|B|0|0|0|0|0|J|H|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@$D|1A|E|1B|F|G]]|9|@$D|1C|E|1D|1|1E]]|A|$]]|$1|H|3|I|5|J|7|1F|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1I|8|@]|9|@$D|1J|E|1K|1|1L]]|A|$]]|$1|S|3|T|5|J|7|1M|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|W|3|X|5|J|7|1O|8|@]|9|@]|A|$K|L]]|$1|Y|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

There are a couple of ways to do this, but you need to use some macros to either define or adapt the struct. 

You can use the <code>REFLECTABLE</code> macro given in <a href="https://stackoverflow.com/a/11744832/375343">this answer</a> to define the struct like this:

<pre><code>struct A
{
 REFLECTABLE
 (
 (int) a,
 (int) b,
 (const char *) c
 )
};
</code></pre>

And then you can iterate over the fields and print each value like this:

<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());
}

A x;
print_fields(x);
</code></pre>

Another way is to adapt the struct as a fusion sequence (see <a href="http://www.boost.org/doc/libs/1_55_0/libs/fusion/doc/html/fusion/adapted/adapt_struct.html" rel="noreferrer">the documentation</a>). Here's an example:

<pre><code>struct A
{
 int a;
 int b;
 const char * c;
};

BOOST_FUSION_ADAPT_STRUCT
(
 A,
 (int, a)
 (int, b)
 (const char *, c)
)
</code></pre>

Then you can print the fields as well using this:

<pre><code>struct print_visitor
{
 template&lt;class Index, class C&gt;
 void operator()(Index, C &amp; c)
 {

 std::cout &lt;&lt; boost::fusion::extension::struct_member_name&lt;C, Index::value&gt;::call() 
 &lt;&lt; "=" 
 &lt;&lt; boost:::fusion::at&lt;Index&gt;(c) 
 &lt;&lt; std::endl;
 }
};


template&lt;class C&gt;
void print_fields(C &amp; c)
{
 typedef boost::mpl::range_c&lt;int,0, boost::fusion::result_of::size&lt;C&gt;::type::value&gt; range;
 boost::mpl::for_each&lt;range&gt;(boost::bind&lt;void&gt;(print_visitor(), _1, boost::ref(c)));
}
</code></pre>

blocks|key|60399|text|正如@Paul所建议的，我使用带有自写for_each_member函数的BOOST_FUSION_ADAPT_STRUCT：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|60400|/**
+*+\brief+Allows+iteration+on+member+name+and+values+of+a+Fusion+adapted+struct.
+*+
+*++
+*+BOOST_FUSION_ADAPT_STRUCT(ns::point,
+*++++++(int,+x)
+*++++++(int,+y)
+*++++++(int,+z));
+*
+*+template<class+T>
+*+print_name_and_value(const+char*+name,+T&+value)+const+{
+*++++std::cout+<<+name+<<+"="+<<+value+<<+std::endl;
+*+}+
+*
+*+
+*+int+main(void)+{
+*++
+*++ns::point+mypoint;
+*
+*++
+*++++++boost::fusion::for_each_member(mypoint,+&print_name_and_value);
+*
+*
+*+}
+*
+*/
#ifndef+BOOST_FUSION_FOR_EACH_MEMBER_HPP
#define+BOOST_FUSION_FOR_EACH_MEMBER_HPP

#include+<functional>

#include+<boost/fusion/include/adapt_struct.hpp>

#include+<boost/fusion/sequence/intrinsic/begin.hpp>
#include+<boost/fusion/sequence/intrinsic/end.hpp>
#include+<boost/fusion/sequence/intrinsic/front.hpp>
#include+<boost/fusion/iterator/equal_to.hpp>
#include+<boost/fusion/iterator/next.hpp>
#include+<boost/fusion/iterator/deref.hpp>
#include+<boost/fusion/iterator/distance.hpp>
#include+<boost/fusion/support/category_of.hpp>
#include+<boost/mpl/bool.hpp>

namespace+boost+{+namespace+fusion+{

namespace+detail+{

++template+<typename+First,+typename+Last,+typename+F>
++inline+void
++for_each_member_linear(First+const&+first,
++++++Last+const&+last,
++++++F+const&+f,
++++++boost::mpl::true_)+{}

++template+<typename+First,+typename+Last,+typename+F>
++inline+void
++for_each_member_linear(First+const&+first,
++++++Last+const&+last,
++++++F+const&+f,
++++++boost::mpl::false_)+{

++++++f(
++++++++++++++++extension::struct_member_name<
++++++++++++++++++++typename+First::seq_type,+First::index::value
++++++++++++++++>::call(),
++++++++++++++++*first
++++++++++++);

++++++for_each_member_linear(
++++++++++next(first),
++++++++++last,
++++++++++f,
++++++++++result_of::equal_to<+typename+result_of::next<First>::type,+Last>()
++++++);
++}

++template+<typename+Sequence,+typename+F>
++inline+void
++for_each_member(Sequence&+seq,+F+const&+f)+{

++++detail::for_each_member_linear(
++++++fusion::begin(seq),
++++++fusion::end(seq),
++++++f,
++++++result_of::equal_to<
++++++++typename+result_of::begin<Sequence>::type,
++++++++typename+result_of::end<Sequence>::type>()
++++);
++}

}

++template+<typename+Sequence,+typename+F>
++inline+void
++for_each_member(Sequence&+seq,+F+f)+{
++++detail::for_each_member(seq,+f);
++}

}}

#endif+|code-block|syntax|javascript|60401|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As suggested by @Paul I use BOOST_FUSION_ADAPT_STRUCT with a self written for_each_member function :

<pre><code>/**
 * \brief Allows iteration on member name and values of a Fusion adapted struct.
 * 
 * 
 * BOOST_FUSION_ADAPT_STRUCT(ns::point,
 * (int, x)
 * (int, y)
 * (int, z));
 *
 * template&lt;class T&gt;
 * print_name_and_value(const char* name, T&amp; value) const {
 * std::cout &lt;&lt; name &lt;&lt; "=" &lt;&lt; value &lt;&lt; std::endl;
 * } 
 *
 * 
 * int main(void) {
 * 
 * ns::point mypoint;
 *
 * 
 * boost::fusion::for_each_member(mypoint, &amp;print_name_and_value);
 *
 *
 * }
 *
 */
#ifndef BOOST_FUSION_FOR_EACH_MEMBER_HPP
#define BOOST_FUSION_FOR_EACH_MEMBER_HPP

#include &lt;functional&gt;

#include &lt;boost/fusion/include/adapt_struct.hpp&gt;

#include &lt;boost/fusion/sequence/intrinsic/begin.hpp&gt;
#include &lt;boost/fusion/sequence/intrinsic/end.hpp&gt;
#include &lt;boost/fusion/sequence/intrinsic/front.hpp&gt;
#include &lt;boost/fusion/iterator/equal_to.hpp&gt;
#include &lt;boost/fusion/iterator/next.hpp&gt;
#include &lt;boost/fusion/iterator/deref.hpp&gt;
#include &lt;boost/fusion/iterator/distance.hpp&gt;
#include &lt;boost/fusion/support/category_of.hpp&gt;
#include &lt;boost/mpl/bool.hpp&gt;

namespace boost { namespace fusion {

namespace detail {

 template &lt;typename First, typename Last, typename F&gt;
 inline void
 for_each_member_linear(First const&amp; first,
 Last const&amp; last,
 F const&amp; f,
 boost::mpl::true_) {}

 template &lt;typename First, typename Last, typename F&gt;
 inline void
 for_each_member_linear(First const&amp; first,
 Last const&amp; last,
 F const&amp; f,
 boost::mpl::false_) {

 f(
 extension::struct_member_name&lt;
 typename First::seq_type, First::index::value
 &gt;::call(),
 *first
 );

 for_each_member_linear(
 next(first),
 last,
 f,
 result_of::equal_to&lt; typename result_of::next&lt;First&gt;::type, Last&gt;()
 );
 }

 template &lt;typename Sequence, typename F&gt;
 inline void
 for_each_member(Sequence&amp; seq, F const&amp; f) {

 detail::for_each_member_linear(
 fusion::begin(seq),
 fusion::end(seq),
 f,
 result_of::equal_to&lt;
 typename result_of::begin&lt;Sequence&gt;::type,
 typename result_of::end&lt;Sequence&gt;::type&gt;()
 );
 }

}

 template &lt;typename Sequence, typename F&gt;
 inline void
 for_each_member(Sequence&amp; seq, F f) {
 detail::for_each_member(seq, f);
 }

}}

#endif 
</code></pre>

blocks|key|60413|text|如果结构中的所有字段都相同，则可以执行以下操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|60414|template+<typename+S>+uint64_t*+get_begin(S+*s)
{
++++return+(uint64_t*)s;
}

template+<typename+S>+uint64_t*+get_end(S+*s)
{
++++return+(uint64_t*)((uint8_t*)s%2Bsizeof(*s));
}

struct+statistics_s+{
++++++++uint64_t+f1;
++++++++uint64_t+f2;
}+statistics;

for+(uint64_t*+p+=+get_begin(&statistics);p+<+get_end(&statistics);p%2B%2B)
++++printf("%25lu+",+*p);|code-block|syntax|javascript|60415|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If all fields in the structure are the same, you can do

<pre><code>template &lt;typename S&gt; uint64_t* get_begin(S *s)
{
 return (uint64_t*)s;
}

template &lt;typename S&gt; uint64_t* get_end(S *s)
{
 return (uint64_t*)((uint8_t*)s+sizeof(*s));
}

struct statistics_s {
 uint64_t f1;
 uint64_t f2;
} statistics;

for (uint64_t* p = get_begin(&amp;statistics);p &lt; get_end(&amp;statistics);p++)
 printf("%lu ", *p);
</code></pre>

blocks|key|60447|text|我写了一个没有Boost或其他第三方库的版本，已经使用GCC+4.9(c%2B%2B11)，CLAN5.0(c%2B%2B11)，VS2008，VS2019进行了测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|60448|#include+<iostream>
#include+<string>

#define+REFLECTION_WITH_FIELD_NAME+1

#define+_PP_EVAL(...)+__VA_ARGS__
#define+_PP_EAT(...)
#define+_PP_EMPTY
#define+_PP_STR2(x)+#x
#define+_PP_STR(x)+_PP_STR2(x)

#define+_PP_MAP01(f,+x)+f(x)
#define+_PP_MAP02(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP01(f,+__VA_ARGS__))
#define+_PP_MAP03(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP02(f,+__VA_ARGS__))
#define+_PP_MAP04(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP03(f,+__VA_ARGS__))
#define+_PP_MAP05(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP04(f,+__VA_ARGS__))
#define+_PP_MAP06(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP05(f,+__VA_ARGS__))
#define+_PP_MAP07(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP06(f,+__VA_ARGS__))
#define+_PP_MAP08(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP07(f,+__VA_ARGS__))
#define+_PP_MAP09(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP08(f,+__VA_ARGS__))
#define+_PP_MAP10(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP09(f,+__VA_ARGS__))
#define+_PP_MAP11(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP10(f,+__VA_ARGS__))
#define+_PP_MAP12(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP11(f,+__VA_ARGS__))
#define+_PP_MAP13(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP12(f,+__VA_ARGS__))
#define+_PP_MAP14(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP13(f,+__VA_ARGS__))
#define+_PP_MAP15(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP14(f,+__VA_ARGS__))
#define+_PP_MAP16(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP15(f,+__VA_ARGS__))
#define+_PP_MAP17(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP16(f,+__VA_ARGS__))
#define+_PP_MAP18(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP17(f,+__VA_ARGS__))
#define+_PP_MAP19(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP18(f,+__VA_ARGS__))
#define+_PP_MAP20(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP19(f,+__VA_ARGS__))
#define+_PP_MAP21(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP20(f,+__VA_ARGS__))
#define+_PP_MAP22(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP21(f,+__VA_ARGS__))
#define+_PP_MAP23(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP22(f,+__VA_ARGS__))
#define+_PP_MAP24(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP23(f,+__VA_ARGS__))
#define+_PP_MAP25(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP24(f,+__VA_ARGS__))
#define+_PP_MAP26(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP25(f,+__VA_ARGS__))
#define+_PP_MAP27(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP26(f,+__VA_ARGS__))
#define+_PP_MAP28(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP27(f,+__VA_ARGS__))
#define+_PP_MAP29(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP28(f,+__VA_ARGS__))
#define+_PP_MAP30(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP29(f,+__VA_ARGS__))
#define+_PP_MAP31(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP30(f,+__VA_ARGS__))
#define+_PP_MAP32(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP31(f,+__VA_ARGS__))
#define+_PP_MAP33(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP32(f,+__VA_ARGS__))
#define+_PP_MAP34(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP33(f,+__VA_ARGS__))
#define+_PP_MAP35(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP34(f,+__VA_ARGS__))
#define+_PP_MAP36(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP35(f,+__VA_ARGS__))
#define+_PP_MAP37(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP36(f,+__VA_ARGS__))
#define+_PP_MAP38(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP37(f,+__VA_ARGS__))
#define+_PP_MAP39(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP38(f,+__VA_ARGS__))
#define+_PP_MAP40(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP39(f,+__VA_ARGS__))
#define+_PP_MAP41(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP40(f,+__VA_ARGS__))
#define+_PP_MAP42(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP41(f,+__VA_ARGS__))
#define+_PP_MAP43(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP42(f,+__VA_ARGS__))
#define+_PP_MAP44(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP43(f,+__VA_ARGS__))
#define+_PP_MAP45(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP44(f,+__VA_ARGS__))
#define+_PP_MAP46(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP45(f,+__VA_ARGS__))
#define+_PP_MAP47(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP46(f,+__VA_ARGS__))
#define+_PP_MAP48(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP47(f,+__VA_ARGS__))
#define+_PP_MAP49(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP48(f,+__VA_ARGS__))
#define+_PP_MAP50(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP49(f,+__VA_ARGS__))
#define+_PP_MAP51(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP50(f,+__VA_ARGS__))
#define+_PP_MAP52(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP51(f,+__VA_ARGS__))
#define+_PP_MAP53(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP52(f,+__VA_ARGS__))
#define+_PP_MAP54(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP53(f,+__VA_ARGS__))
#define+_PP_MAP55(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP54(f,+__VA_ARGS__))
#define+_PP_MAP56(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP55(f,+__VA_ARGS__))
#define+_PP_MAP57(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP56(f,+__VA_ARGS__))
#define+_PP_MAP58(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP57(f,+__VA_ARGS__))
#define+_PP_MAP59(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP58(f,+__VA_ARGS__))
#define+_PP_MAP60(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP59(f,+__VA_ARGS__))
#define+_PP_MAP61(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP60(f,+__VA_ARGS__))
#define+_PP_MAP62(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP61(f,+__VA_ARGS__))
#define+_PP_MAP63(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP62(f,+__VA_ARGS__))
#define+_PP_MAP64(f,+x,+...)+f(x)+_PP_EVAL(_PP_MAP63(f,+__VA_ARGS__))

#define+_PP_GET_NTH_ARG(+\
++_1,+_2,+_3,+_4,+_5,+_6,+_7,+_8,+_9,+_10,+\
++_11,+_12,+_13,+_14,+_15,+_16,+_17,+_18,+_19,+_20,+\
++_21,+_22,+_23,+_24,+_25,+_26,+_27,+_28,+_29,+_30,+\
++_31,+_32,+_33,+_34,+_35,+_36,+_37,+_38,+_39,+_40,+\
++_41,+_42,+_43,+_44,+_45,+_46,+_47,+_48,+_49,+_50,+\
++_51,+_52,+_53,+_54,+_55,+_56,+_57,+_58,+_59,+_60,+\
++_61,+_62,+_63,+_64,+N,+...)+N

#define+_PP_MAP(f,+...)+_PP_EVAL(_PP_EVAL(_PP_GET_NTH_ARG(__VA_ARGS__,+\
++_PP_MAP64,+_PP_MAP63,+_PP_MAP62,+_PP_MAP61,+\
++_PP_MAP60,+_PP_MAP59,+_PP_MAP58,+_PP_MAP57,+_PP_MAP56,+\
++_PP_MAP55,+_PP_MAP54,+_PP_MAP53,+_PP_MAP52,+_PP_MAP51,+\
++_PP_MAP50,+_PP_MAP49,+_PP_MAP48,+_PP_MAP47,+_PP_MAP46,+\
++_PP_MAP45,+_PP_MAP44,+_PP_MAP43,+_PP_MAP42,+_PP_MAP41,+\
++_PP_MAP40,+_PP_MAP39,+_PP_MAP38,+_PP_MAP37,+_PP_MAP36,+\
++_PP_MAP35,+_PP_MAP34,+_PP_MAP33,+_PP_MAP32,+_PP_MAP31,+\
++_PP_MAP30,+_PP_MAP29,+_PP_MAP28,+_PP_MAP27,+_PP_MAP26,+\
++_PP_MAP25,+_PP_MAP24,+_PP_MAP23,+_PP_MAP22,+_PP_MAP21,+\
++_PP_MAP20,+_PP_MAP19,+_PP_MAP18,+_PP_MAP17,+_PP_MAP16,+\
++_PP_MAP15,+_PP_MAP14,+_PP_MAP13,+_PP_MAP12,+_PP_MAP11,+\
++_PP_MAP10,+_PP_MAP09,+_PP_MAP08,+_PP_MAP07,+_PP_MAP06,+\
++_PP_MAP05,+_PP_MAP04,+_PP_MAP03,+_PP_MAP02,+_PP_MAP01+\
++))(f,+__VA_ARGS__))

#if+REFLECTION_WITH_FIELD_NAME
#define+_PP_REFLECTION_FIELD_NAME(x)+_PP_STR(_PP_EVAL(x))
#else
#define+_PP_REFLECTION_FIELD_NAME(x)+""
#endif

#define+_PP_REFLECTION_ALL(x)+_PP_EVAL+x
#define+_PP_REFLECTION_SECOND(x)+_PP_EAT+x
#define+_PP_REFLECTION_FIELD(x)+_PP_REFLECTION_ALL(x);
#define+_PP_REFLECTION_METHOD2(x)+v(this,+_PP_REFLECTION_FIELD_NAME(x),+x);
#define+_PP_REFLECTION_METHOD(x)+_PP_REFLECTION_METHOD2(_PP_REFLECTION_SECOND(x))

#define+_PP_REFLECTION_VISTOR_METHOD(type,+...)+\
++template+<class+Vistor>+\
++void+_reflect(Vistor&+v)+type+{+\
++++_PP_MAP(_PP_REFLECTION_METHOD,+__VA_ARGS__)+\
++}

#define+REFLECT(...)+\
++_PP_MAP(_PP_REFLECTION_FIELD,+__VA_ARGS__)+\
++_PP_REFLECTION_VISTOR_METHOD(_PP_EMPTY,+__VA_ARGS__)+\
++_PP_REFLECTION_VISTOR_METHOD(const,+__VA_ARGS__)


//+Usage+of+REFLECT()

#define+OBJECT_NAME_METHOD(obj)+\
++static+const+char*+object_name()+{+\
++++return+#obj;+\
++}

struct+Demo
{
++OBJECT_NAME_METHOD(Demo)

++REFLECT(
++++(int)+a,
++++(int)+b,
++++(std::string)+c
++)

++int+d;+//+DO+NOT+REFLECT
};

struct+Amplifier+{
++template+<class+Obj>
++void+apply(Obj*+obj)+{
++++obj->_reflect(*this);
++}

++template+<class+Obj,+class+Field>
++void+operator()+(Obj*+/*obj*/,+const+char*+/*name*/,+Field&+field)+{
++++field+*=+100;
++}

++template+<class+Obj>
++void+operator()+(Obj*+/*obj*/,+const+char*+/*name*/,+std::string&+field)+{
++++field+%2B=+"00";
++}
};

struct+Printer+{
++template+<class+Obj>
++void+print(const+Obj&+obj)+{
++++obj._reflect(*this);
++}

++template+<class+Obj,+class+Field>
++void+operator()+(Obj*+obj,+const+char*+name,+const+Field&+field)+{
++++std::cout+<<+obj->object_name()+<<+"."
++++++<<+name+<<+":+"+<<+field+<<+std::endl;
++}
};

int+main()+{
++Demo+a+=+{100,+200,+"300",+400};

++Amplifier+amplifier;
++amplifier.apply(&a);

++Printer+printer;
++printer.print(a);
}

/*
Output:
Demo.a:+10000
Demo.b:+20000
Demo.c:+30000
*/|code-block|syntax|javascript|60449|顺便说一下，下面的代码是用来生成所有_PP_MAP_的？宏(用JS编写，因此您可以在web浏览器中运行它)。|60450|(function()+{
++const+maxNumOfEle+=+64;
++const+mapNamePrefix+=+'_PP_MAP';
++let+codeText+=+'';

++function+formatNumWidth(num)+{
++++return+("0"+%2B+num).slice(-2);
++}

++function+AddNewLine()+{
++++if+(codeText.slice(-1)+!=+'+')+{
++++++codeText+%2B=+'+';
++++}

++++codeText+%2B=+'\\\n';
++++codeText+%2B=+'+'.repeat(2);
++}

++codeText+%2B=+`#define+${mapNamePrefix}${formatNumWidth(1)}(f,+x)+f(x)\n`;
++for+(let+i+=+2;+i+<=+maxNumOfEle;+%2B%2Bi)+{
++++let+funId+=+formatNumWidth(i);
++++codeText+%2B=+`#define+${mapNamePrefix}${funId}(f,+x,+...)+f(x)`;

++++let+nextFunId+=+formatNumWidth(i+-+1);
++++codeText+%2B=+'+_PP_EVAL(';
++++codeText+%2B=+`${mapNamePrefix}${nextFunId}(f,+__VA_ARGS__)`;
++++codeText+%2B=+')';

++++codeText+%2B=+'\n';
++}

++codeText+%2B=+'\n#define+_PP_GET_NTH_ARG(';
++AddNewLine();
++for+(let+i+=+1;+i+<=+maxNumOfEle;+%2B%2Bi)+{
++++codeText+%2B=+`_${i},+`;
++++if+((i+%25+10)+==+0)+{
++++++AddNewLine();
++++}
++}
++codeText+%2B=+'N,+...)+N\n';

++codeText+%2B=+`\n#define+${mapNamePrefix}(f,+...)+`;
++codeText+%2B=+'_PP_EVAL(_PP_EVAL(_PP_GET_NTH_ARG(__VA_ARGS__,';
++AddNewLine();
++for+(let+i+=+maxNumOfEle;+i+>=+1;+--i)+{
++++let+funId+=+formatNumWidth(i);
++++codeText+%2B=+`${mapNamePrefix}${funId}`;
++++if+(i+!=+1)+{
++++++codeText+%2B=+',+';
++++}

++++if+((i+%25+5)+==+1)+{
++++++AddNewLine();
++++}
++}
++codeText+%2B=+'))(f,+__VA_ARGS__))\n';

++console.log(codeText);
})();|60451|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I wrote a version without Boost or other third-party library, which has been tested using GCC 4.9(c++11), clang 5.0(c++11), VS 2008, VS 2019.

<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;

#define REFLECTION_WITH_FIELD_NAME 1

#define _PP_EVAL(...) __VA_ARGS__
#define _PP_EAT(...)
#define _PP_EMPTY
#define _PP_STR2(x) #x
#define _PP_STR(x) _PP_STR2(x)

#define _PP_MAP01(f, x) f(x)
#define _PP_MAP02(f, x, ...) f(x) _PP_EVAL(_PP_MAP01(f, __VA_ARGS__))
#define _PP_MAP03(f, x, ...) f(x) _PP_EVAL(_PP_MAP02(f, __VA_ARGS__))
#define _PP_MAP04(f, x, ...) f(x) _PP_EVAL(_PP_MAP03(f, __VA_ARGS__))
#define _PP_MAP05(f, x, ...) f(x) _PP_EVAL(_PP_MAP04(f, __VA_ARGS__))
#define _PP_MAP06(f, x, ...) f(x) _PP_EVAL(_PP_MAP05(f, __VA_ARGS__))
#define _PP_MAP07(f, x, ...) f(x) _PP_EVAL(_PP_MAP06(f, __VA_ARGS__))
#define _PP_MAP08(f, x, ...) f(x) _PP_EVAL(_PP_MAP07(f, __VA_ARGS__))
#define _PP_MAP09(f, x, ...) f(x) _PP_EVAL(_PP_MAP08(f, __VA_ARGS__))
#define _PP_MAP10(f, x, ...) f(x) _PP_EVAL(_PP_MAP09(f, __VA_ARGS__))
#define _PP_MAP11(f, x, ...) f(x) _PP_EVAL(_PP_MAP10(f, __VA_ARGS__))
#define _PP_MAP12(f, x, ...) f(x) _PP_EVAL(_PP_MAP11(f, __VA_ARGS__))
#define _PP_MAP13(f, x, ...) f(x) _PP_EVAL(_PP_MAP12(f, __VA_ARGS__))
#define _PP_MAP14(f, x, ...) f(x) _PP_EVAL(_PP_MAP13(f, __VA_ARGS__))
#define _PP_MAP15(f, x, ...) f(x) _PP_EVAL(_PP_MAP14(f, __VA_ARGS__))
#define _PP_MAP16(f, x, ...) f(x) _PP_EVAL(_PP_MAP15(f, __VA_ARGS__))
#define _PP_MAP17(f, x, ...) f(x) _PP_EVAL(_PP_MAP16(f, __VA_ARGS__))
#define _PP_MAP18(f, x, ...) f(x) _PP_EVAL(_PP_MAP17(f, __VA_ARGS__))
#define _PP_MAP19(f, x, ...) f(x) _PP_EVAL(_PP_MAP18(f, __VA_ARGS__))
#define _PP_MAP20(f, x, ...) f(x) _PP_EVAL(_PP_MAP19(f, __VA_ARGS__))
#define _PP_MAP21(f, x, ...) f(x) _PP_EVAL(_PP_MAP20(f, __VA_ARGS__))
#define _PP_MAP22(f, x, ...) f(x) _PP_EVAL(_PP_MAP21(f, __VA_ARGS__))
#define _PP_MAP23(f, x, ...) f(x) _PP_EVAL(_PP_MAP22(f, __VA_ARGS__))
#define _PP_MAP24(f, x, ...) f(x) _PP_EVAL(_PP_MAP23(f, __VA_ARGS__))
#define _PP_MAP25(f, x, ...) f(x) _PP_EVAL(_PP_MAP24(f, __VA_ARGS__))
#define _PP_MAP26(f, x, ...) f(x) _PP_EVAL(_PP_MAP25(f, __VA_ARGS__))
#define _PP_MAP27(f, x, ...) f(x) _PP_EVAL(_PP_MAP26(f, __VA_ARGS__))
#define _PP_MAP28(f, x, ...) f(x) _PP_EVAL(_PP_MAP27(f, __VA_ARGS__))
#define _PP_MAP29(f, x, ...) f(x) _PP_EVAL(_PP_MAP28(f, __VA_ARGS__))
#define _PP_MAP30(f, x, ...) f(x) _PP_EVAL(_PP_MAP29(f, __VA_ARGS__))
#define _PP_MAP31(f, x, ...) f(x) _PP_EVAL(_PP_MAP30(f, __VA_ARGS__))
#define _PP_MAP32(f, x, ...) f(x) _PP_EVAL(_PP_MAP31(f, __VA_ARGS__))
#define _PP_MAP33(f, x, ...) f(x) _PP_EVAL(_PP_MAP32(f, __VA_ARGS__))
#define _PP_MAP34(f, x, ...) f(x) _PP_EVAL(_PP_MAP33(f, __VA_ARGS__))
#define _PP_MAP35(f, x, ...) f(x) _PP_EVAL(_PP_MAP34(f, __VA_ARGS__))
#define _PP_MAP36(f, x, ...) f(x) _PP_EVAL(_PP_MAP35(f, __VA_ARGS__))
#define _PP_MAP37(f, x, ...) f(x) _PP_EVAL(_PP_MAP36(f, __VA_ARGS__))
#define _PP_MAP38(f, x, ...) f(x) _PP_EVAL(_PP_MAP37(f, __VA_ARGS__))
#define _PP_MAP39(f, x, ...) f(x) _PP_EVAL(_PP_MAP38(f, __VA_ARGS__))
#define _PP_MAP40(f, x, ...) f(x) _PP_EVAL(_PP_MAP39(f, __VA_ARGS__))
#define _PP_MAP41(f, x, ...) f(x) _PP_EVAL(_PP_MAP40(f, __VA_ARGS__))
#define _PP_MAP42(f, x, ...) f(x) _PP_EVAL(_PP_MAP41(f, __VA_ARGS__))
#define _PP_MAP43(f, x, ...) f(x) _PP_EVAL(_PP_MAP42(f, __VA_ARGS__))
#define _PP_MAP44(f, x, ...) f(x) _PP_EVAL(_PP_MAP43(f, __VA_ARGS__))
#define _PP_MAP45(f, x, ...) f(x) _PP_EVAL(_PP_MAP44(f, __VA_ARGS__))
#define _PP_MAP46(f, x, ...) f(x) _PP_EVAL(_PP_MAP45(f, __VA_ARGS__))
#define _PP_MAP47(f, x, ...) f(x) _PP_EVAL(_PP_MAP46(f, __VA_ARGS__))
#define _PP_MAP48(f, x, ...) f(x) _PP_EVAL(_PP_MAP47(f, __VA_ARGS__))
#define _PP_MAP49(f, x, ...) f(x) _PP_EVAL(_PP_MAP48(f, __VA_ARGS__))
#define _PP_MAP50(f, x, ...) f(x) _PP_EVAL(_PP_MAP49(f, __VA_ARGS__))
#define _PP_MAP51(f, x, ...) f(x) _PP_EVAL(_PP_MAP50(f, __VA_ARGS__))
#define _PP_MAP52(f, x, ...) f(x) _PP_EVAL(_PP_MAP51(f, __VA_ARGS__))
#define _PP_MAP53(f, x, ...) f(x) _PP_EVAL(_PP_MAP52(f, __VA_ARGS__))
#define _PP_MAP54(f, x, ...) f(x) _PP_EVAL(_PP_MAP53(f, __VA_ARGS__))
#define _PP_MAP55(f, x, ...) f(x) _PP_EVAL(_PP_MAP54(f, __VA_ARGS__))
#define _PP_MAP56(f, x, ...) f(x) _PP_EVAL(_PP_MAP55(f, __VA_ARGS__))
#define _PP_MAP57(f, x, ...) f(x) _PP_EVAL(_PP_MAP56(f, __VA_ARGS__))
#define _PP_MAP58(f, x, ...) f(x) _PP_EVAL(_PP_MAP57(f, __VA_ARGS__))
#define _PP_MAP59(f, x, ...) f(x) _PP_EVAL(_PP_MAP58(f, __VA_ARGS__))
#define _PP_MAP60(f, x, ...) f(x) _PP_EVAL(_PP_MAP59(f, __VA_ARGS__))
#define _PP_MAP61(f, x, ...) f(x) _PP_EVAL(_PP_MAP60(f, __VA_ARGS__))
#define _PP_MAP62(f, x, ...) f(x) _PP_EVAL(_PP_MAP61(f, __VA_ARGS__))
#define _PP_MAP63(f, x, ...) f(x) _PP_EVAL(_PP_MAP62(f, __VA_ARGS__))
#define _PP_MAP64(f, x, ...) f(x) _PP_EVAL(_PP_MAP63(f, __VA_ARGS__))

#define _PP_GET_NTH_ARG( \
 _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
 _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
 _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
 _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
 _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \
 _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \
 _61, _62, _63, _64, N, ...) N

#define _PP_MAP(f, ...) _PP_EVAL(_PP_EVAL(_PP_GET_NTH_ARG(__VA_ARGS__, \
 _PP_MAP64, _PP_MAP63, _PP_MAP62, _PP_MAP61, \
 _PP_MAP60, _PP_MAP59, _PP_MAP58, _PP_MAP57, _PP_MAP56, \
 _PP_MAP55, _PP_MAP54, _PP_MAP53, _PP_MAP52, _PP_MAP51, \
 _PP_MAP50, _PP_MAP49, _PP_MAP48, _PP_MAP47, _PP_MAP46, \
 _PP_MAP45, _PP_MAP44, _PP_MAP43, _PP_MAP42, _PP_MAP41, \
 _PP_MAP40, _PP_MAP39, _PP_MAP38, _PP_MAP37, _PP_MAP36, \
 _PP_MAP35, _PP_MAP34, _PP_MAP33, _PP_MAP32, _PP_MAP31, \
 _PP_MAP30, _PP_MAP29, _PP_MAP28, _PP_MAP27, _PP_MAP26, \
 _PP_MAP25, _PP_MAP24, _PP_MAP23, _PP_MAP22, _PP_MAP21, \
 _PP_MAP20, _PP_MAP19, _PP_MAP18, _PP_MAP17, _PP_MAP16, \
 _PP_MAP15, _PP_MAP14, _PP_MAP13, _PP_MAP12, _PP_MAP11, \
 _PP_MAP10, _PP_MAP09, _PP_MAP08, _PP_MAP07, _PP_MAP06, \
 _PP_MAP05, _PP_MAP04, _PP_MAP03, _PP_MAP02, _PP_MAP01 \
 ))(f, __VA_ARGS__))

#if REFLECTION_WITH_FIELD_NAME
#define _PP_REFLECTION_FIELD_NAME(x) _PP_STR(_PP_EVAL(x))
#else
#define _PP_REFLECTION_FIELD_NAME(x) ""
#endif

#define _PP_REFLECTION_ALL(x) _PP_EVAL x
#define _PP_REFLECTION_SECOND(x) _PP_EAT x
#define _PP_REFLECTION_FIELD(x) _PP_REFLECTION_ALL(x);
#define _PP_REFLECTION_METHOD2(x) v(this, _PP_REFLECTION_FIELD_NAME(x), x);
#define _PP_REFLECTION_METHOD(x) _PP_REFLECTION_METHOD2(_PP_REFLECTION_SECOND(x))

#define _PP_REFLECTION_VISTOR_METHOD(type, ...) \
 template &lt;class Vistor&gt; \
 void _reflect(Vistor&amp; v) type { \
 _PP_MAP(_PP_REFLECTION_METHOD, __VA_ARGS__) \
 }

#define REFLECT(...) \
 _PP_MAP(_PP_REFLECTION_FIELD, __VA_ARGS__) \
 _PP_REFLECTION_VISTOR_METHOD(_PP_EMPTY, __VA_ARGS__) \
 _PP_REFLECTION_VISTOR_METHOD(const, __VA_ARGS__)


// Usage of REFLECT()

#define OBJECT_NAME_METHOD(obj) \
 static const char* object_name() { \
 return #obj; \
 }

struct Demo
{
 OBJECT_NAME_METHOD(Demo)

 REFLECT(
 (int) a,
 (int) b,
 (std::string) c
 )

 int d; // DO NOT REFLECT
};

struct Amplifier {
 template &lt;class Obj&gt;
 void apply(Obj* obj) {
 obj-&gt;_reflect(*this);
 }

 template &lt;class Obj, class Field&gt;
 void operator() (Obj* /*obj*/, const char* /*name*/, Field&amp; field) {
 field *= 100;
 }

 template &lt;class Obj&gt;
 void operator() (Obj* /*obj*/, const char* /*name*/, std::string&amp; field) {
 field += "00";
 }
};

struct Printer {
 template &lt;class Obj&gt;
 void print(const Obj&amp; obj) {
 obj._reflect(*this);
 }

 template &lt;class Obj, class Field&gt;
 void operator() (Obj* obj, const char* name, const Field&amp; field) {
 std::cout &lt;&lt; obj-&gt;object_name() &lt;&lt; "."
 &lt;&lt; name &lt;&lt; ": " &lt;&lt; field &lt;&lt; std::endl;
 }
};

int main() {
 Demo a = {100, 200, "300", 400};

 Amplifier amplifier;
 amplifier.apply(&amp;a);

 Printer printer;
 printer.print(a);
}

/*
Output:
Demo.a: 10000
Demo.b: 20000
Demo.c: 30000
*/
</code></pre>

BTW, the following code is used for generating all _PP_MAP_? macros (written in JS, so you can run it in web browser).

<pre><code>(function() {
 const maxNumOfEle = 64;
 const mapNamePrefix = '_PP_MAP';
 let codeText = '';

 function formatNumWidth(num) {
 return ("0" + num).slice(-2);
 }

 function AddNewLine() {
 if (codeText.slice(-1) != ' ') {
 codeText += ' ';
 }

 codeText += '\\\n';
 codeText += ' '.repeat(2);
 }

 codeText += `#define ${mapNamePrefix}${formatNumWidth(1)}(f, x) f(x)\n`;
 for (let i = 2; i &lt;= maxNumOfEle; ++i) {
 let funId = formatNumWidth(i);
 codeText += `#define ${mapNamePrefix}${funId}(f, x, ...) f(x)`;

 let nextFunId = formatNumWidth(i - 1);
 codeText += ' _PP_EVAL(';
 codeText += `${mapNamePrefix}${nextFunId}(f, __VA_ARGS__)`;
 codeText += ')';

 codeText += '\n';
 }

 codeText += '\n#define _PP_GET_NTH_ARG(';
 AddNewLine();
 for (let i = 1; i &lt;= maxNumOfEle; ++i) {
 codeText += `_${i}, `;
 if ((i % 10) == 0) {
 AddNewLine();
 }
 }
 codeText += 'N, ...) N\n';

 codeText += `\n#define ${mapNamePrefix}(f, ...) `;
 codeText += '_PP_EVAL(_PP_EVAL(_PP_GET_NTH_ARG(__VA_ARGS__,';
 AddNewLine();
 for (let i = maxNumOfEle; i &gt;= 1; --i) {
 let funId = formatNumWidth(i);
 codeText += `${mapNamePrefix}${funId}`;
 if (i != 1) {
 codeText += ', ';
 }

 if ((i % 5) == 1) {
 AddNewLine();
 }
 }
 codeText += '))(f, __VA_ARGS__))\n';

 console.log(codeText);
})();
</code></pre>

I have a structure

<pre><code>typedef struct A
{
 int a;
 int b;
 char * c;
}aA;
</code></pre>

I want to iterate over each an every member of the structure and print its value. Something like:

<pre><code>void print_struct_value(struct *A)
{
 for each member of struct A
 cout &lt;&lt; "struct name . member name" &lt;&lt; "value";
}
</code></pre>

How can this be done in C++ ??

Iterating over a struct in C++

我有一个结构typedef struct A{ int a; int b; char * c;}aA;我想遍历结构的每个成员并打印它的值。类似于：void print_struct_value(struct *A){ for each member of struct A cout << ...

问迭代C++中的结构
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问迭代C++中的结构EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问迭代C++中的结构
EN