Question

I defined the following classes to be serialized:

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

I then run the following code:

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

And I always get an output similar to the following one:

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

As can be observed from the pointer values I manage to deserialize pointers that point to elements down to the second recursion level of MyRecursiveObject. As soon as I try to do it with pointers to the third level or even deeper the deserialization fails.

Am I using boost::serialization wrongly?

Please note that MyRecursiveObject is always successfully deserialized, no matter how many recursion levels it has. I encounter the problem only deserializing pointers to its elements.

Thank you in advance
Kean

Answer 1

Let’s first examine what goes wrong. The default container deserializer basically works like this:

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

The container (in your case the vector<MyRecursiveObject<T>>) is filled using local variables. Unfortunately, their address is registered (object tracking) and referred to when you deserialize the vector<MyElementObject*>. In other words, your elt_ptrs_deserialized is pointing to local variables that are long gone.

To fix that, serialize the vector manually without using local variables:

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

Now, memory for the entire vector is allocated first and the elements are deserialized directly into it, therefore registering the correct memory address. This should yield the desired result:

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