静态迭代 C++ 结构的所有成员

Question

有没有办法静态迭代 C++ 结构的所有成员？

假设我们有许多预定义的结构，它们看起来像：

struct Foo {
    int field1;
    double field2;
    char field3;
    ...
    int field9;
};
struct Bar {
    double field14;
    char field15;
    int field16;
    bool field17;
    ...
    double field23;
};

我们想要一个模板函数

template<typename T>
void Iterate(T object);

以便Iterate可以对T类型的所有成员运行模板函数Add 。 例如， Iterate<Foo>和Iterate<Bar>将变成

void Iterate<Foo>(Foo object) {
    Add<int>(object.field1);
    Add<double>(object.field2);
    Add<char>(object.field3);
    ...
    Add<int>(object.field9);
}
void Iterate<Bar>(Bar object) {
    Add<double>(object.field14);
    Add<char>(object.field15);
    Add<int>(object.field16);
    Add<bool>(object.field17);
    ...
    Add<double>(object.field23);
}

这可以通过编写另一个程序来解析struct定义并生成cpp文件来完成，但这会太麻烦并且需要额外的编译和执行。

编辑：结构体可能有很多字段，并且它们是预定义的，因此不能更改为其他类型。 这也是在编译时，所以它与在运行时执行的“反射”关系不大，而更多地与“模板编程”或“元编程”有关。 我们有<type_traits>用于编译时的类型检查，但这似乎还不够。

Answer 1

没有明确的标准方法来做这样的事情，但你可以看看非标准的方法。 例如，您可以使用boost::fusion 。

BOOST_FUSION_ADAPT_STRUCT(
   Foo,
   (int, field1)
   (double, field2)
   (char, field3)
);

适配 struct之后，就可以使用Foo类型的对象作为 fusion-sequence ，可以通过 member 进行迭代。 活生生的小例子

Answer 2

在不保留索引到类型映射的编译时信息的情况下，我看不出有任何方法可以使用普通结构执行此操作-此时您可以创建另一个 std::tuple 类。 让我们试一试：

#include <iostream>
#include <tuple>
#include <typeinfo>

template <size_t Cur, size_t Last, class TupleType, template <typename> class Func>
struct Iterate_Helper
{
    void operator()(TupleType& tuple)
    {
        typedef typename std::tuple_element<Cur, TupleType>::type elem_type;
        Func<elem_type>()(std::get<Cur>(tuple));
        Iterate_Helper<Cur+1, Last, TupleType, Func>()(tuple);
    }
};

template <size_t Cur, class TupleType, template <typename> class Func>
struct Iterate_Helper<Cur, Cur, TupleType, Func>
{
    void operator()(TupleType& tuple)
    {
        typedef typename std::tuple_element<Cur, TupleType>::type elem_type;
        Func<elem_type>()(std::get<Cur>(tuple));
    }
};

template <template <typename> class Func, class TupleType>
void iterate(TupleType& tuple)
{
    Iterate_Helper<0, std::tuple_size<TupleType>::value-1, TupleType, Func>()(tuple);
}

template <typename T>
struct Add1
{
    void operator()(T& t)
    {
        t += 1;
    }
};

template <typename T>
struct Print
{
    void operator()(T& t)
    {
        std::cout << (int)t << std::endl;
    }
};

int main() {
    typedef std::tuple<int, double, char, /* ... */ int> Foo;
    Foo test(1, 2.0, 3, 4);
    iterate<Add1>(test);
    iterate<Print>(test);        
    return 0;
}

这是在我的头顶上，但我希望它可以给你一些见解。

Answer 3

是的，Boost.Fusion 和扩展机制很好地支持了这一点。

你可以在这里找到一个 for_each_member 实现： https : //github.com/cpp-pre/json/blob/master/pre/fusion/for_each_member.hpp

我使用它来生成 JSON 并从 json 读取结构，如我在此处的其他回复中所述： https : //stackoverflow.com/a/28580824/271781