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可以对Add类型的所有成员运行模板函数T。例如，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)
);

adapt struct 之后，您可以使用Foo类型的对象作为融合序列，可以由成员迭代。 small live example

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/daminetreg/lib-cpp-pre/blob/master/pre/fusion/for_each_member.hpp

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

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

3 个答案: