Question

我定义了以下要序列化的类：

using namespace std;

class MyElementObject
{
    friend class boost::serialization::access;

    public:
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version) { }
};

template<class T>
class MyRecursiveObject
{
    friend class boost::serialization::access;

    public:
        T element;
        std::vector<MyRecursiveObject<T> > children;

        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & element;
            ar & children;
        }
};

然后我运行以下代码：

int main()
{
    //MyRecursiveObject initialization
    MyRecursiveObject<MyElementObject> rec_object;    
    rec_object.children.push_back(MyRecursiveObject<MyElementObject>());
    rec_object.children[0].children.push_back(MyRecursiveObject<MyElementObject>());

    //create vector of pointers to MyRecursiveObject's elements
    vector<MyElementObject *> elt_ptrs;
    elt_ptrs.push_back(&rec_object.element);
    elt_ptrs.push_back(&rec_object.children[0].element);
    elt_ptrs.push_back(&rec_object.children[0].children[0].element);

    //serialize MyRecursiveObject and the vector of pointers
    {
        ofstream ofs("filename");
        boost::archive::text_oarchive oa(ofs);
        oa << rec_object;
        oa << elt_ptrs;
    }

    //create new MyRecursiveObject and vector of pointers for deserialization
    MyRecursiveObject<MyElementObject> rec_object_deserialized;    
    rec_object_deserialized.children.push_back(MyRecursiveObject<MyElementObject>());
    rec_object_deserialized.children[0].children.push_back(MyRecursiveObject<MyElementObject>());
    vector<MyElementObject *> elt_ptrs_deserialized;

    //deserialize
    {
        ifstream ifs("filename");
        boost::archive::text_iarchive ia(ifs);
        ia >> rec_object_deserialized;
        ia >> elt_ptrs_deserialized;
    }

    //compare deserialized pointers
    cout<<"elt_ptrs first level="<<elt_ptrs_deserialized[0]
    <<" expected="<<&rec_object_deserialized.element<<endl;

    cout<<"elt_ptrs second level="<<elt_ptrs_deserialized[1]
    <<" expected="<<&rec_object_deserialized.children[0].element<<endl;

    cout<<"elt_ptrs third level="<<elt_ptrs_deserialized[2]
    <<" expected="<<&rec_object_deserialized.children[0].children[0].element<<endl;

    return 0;
}

我总是得到类似于下面的输出：

elt_ptrs first level=0x7fff57c787c0 expected=0x7fff57c787c0
elt_ptrs second level=0x18e7020 expected=0x18e7020
elt_ptrs third level=0xffff8000ab5564f0 expected=0x18e7450

从指针值可以看出，我设法反序列化指向元素的指针，直到MyRecursiveObject的第二个递归级别。一旦我尝试使用指向第三级甚至更深的指针，反序列化就会失败。

我错误地使用了boost :: serialization吗？

请注意，MyRecursiveObject总是被成功反序列化，无论它有多少递归级别。我遇到的问题只是反序列化其元素的指针。

提前谢谢你基恩

Answer 1

让我们先来看看出了什么问题。默认的容器反序列化器基本上是这样的：

size_t count;
ar >> BOOST_SERIALIZATION_NVP(count); // get element count
while( count-- > 0 ) {
    T temp; // <- and here's the problem!
    ar >> boost::serialization::make_nvp("item",temp);
    container.push_back(temp);
}

使用局部变量填充容器（在您的情况下为vector<MyRecursiveObject<T>>）。不幸的是，他们的地址已注册（对象跟踪），并在您反序列化vector<MyElementObject*>时引用。换句话说，您的elt_ptrs_deserialized指向已经消失的局部变量。

要解决此问题，请手动序列化矢量而不使用局部变量：

template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
    ar & BOOST_SERIALIZATION_NVP(element);
    size_t count = children.size();        // 0 when loading, N when storing
    ar & BOOST_SERIALIZATION_NVP(count);   // load or store element count
    children.resize(count);                // should be a no-op when storing
    while( count-- > 0 )
        ar & boost::serialization::make_nvp("item",children[count]);
}
// You should split serialize() into load() and save() with
// BOOST_SERIALIZATION_SPLIT_MEMBER() for a cleaner version

现在，首先分配整个向量的内存，然后将元素直接反序列化，从而注册正确的内存地址。这应该产生预期的结果：

elt_ptrs 1st level=0x22fe90 expected=0x22fe90
elt_ptrs 2nd level=0x6127d0 expected=0x6127d0
elt_ptrs 3rd level=0x613d50 expected=0x613d50
elt_ptrs 4th level=0x613c88 expected=0x613c88

提升递归对象的序列化

1 个答案: