在编译时存储struct元数据以进行序列化

Question

#include <iostream>
#include <string>
#include <tuple>
#include <vector>
#include <cstdlib>

struct FieldBase
{
    // To enable dynamic_cast.
    virtual void fb()
    {

    }
};

template <typename A, typename B>
struct Field : public FieldBase
{
    Field(A B::* v) :
        value(v)
    {

    }

    A B::* value;
};

template <typename A>
struct MetaData
{
    static std::vector<FieldBase> fields;
};

struct Test
{
    unsigned int a;
    std::string b;
};

template <>
struct MetaData<Test>
{
    static const std::vector<FieldBase*> fields;
};

const std::vector<FieldBase*> MetaData<Test>::fields{ new Field<unsigned int, Test>(&Test::a), new Field<std::string, Test>(&Test::b) };

template <typename A>
void serialize(const A& object)
{
    std::cout << typeid(A).name() << std::endl;

    for (const FieldBase* field : MetaData<A>::fields)
    {
        const Field<unsigned int, A>* f1 = dynamic_cast<const Field<unsigned int, A>*>(field);

        if (f1 != 0)
            std::cout << object.*f1->value << std::endl;

        const Field<std::string, A>* f2 = dynamic_cast<const Field<std::string, A>*>(field);

        if (f2 != 0)
            std::cout << object.*f2->value << std::endl;
    }
}

int main()
{
    Test test;
    test.a = 2014;
    test.b = "Hello";

    serialize(test);

    std::cin.sync();
    std::cin.get();
    return EXIT_SUCCESS;
}

这是我能想到的。但我认为这根本不是正确的做法。

我真正想做的是检查存储的字段而不进行任何动态转换。

将字段存储在元组中然后遍历所有元组元素是否有意义？虽然我不确定当索引来自循环计数器时如何访问元组元素。

std::tuple<Field<unsigned int, Test>, Field<std::string, Test>>

当它的大小可能变化时，如何迭代该元组？