Boost serialization and pointers to parent class - serialization

Question

Assuming the following simplified code:
Parent class
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/unique_ptr.hpp>
class Parent
{
public:
Parent();
...
private:
// boost serialization
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
ar & *m_child;
}
std::unique_ptr<Child> m_child;
}
Parent::Parent()
{
...
m_child = std::unique_ptr<Child>(new Child(this));
}
Child class
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/unique_ptr.hpp>
class Child
{
public:
Child(Parent * parent)
{
m_parent = parent;
};
...
private:
// boost serialization
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
ar & m_parent;
}
Child(){};
Parent m_parent{ nullptr };
}
My parent class creates a child class and passes a pointer to itself stored by the child.
When archiving the parent class, it archives the child which archives the pointer to the parent.
When restoring the parent class, it creates the child class and restores it as well. My question is this:
Will the pointer in the child class get restore properly so it is guaranteed to point to it's parent?
This SEEMS to work which I've verified by stepping through the debugger and comparing the values of the Parent's this pointer with the child's m_parent. However, I can't figure out how boost pulls this off and it makes me wonder if I'm just 'getting lucky'. Can anyone verify that boost serialization is smart enough to maintain the child::m_parent->parent relationship?
Or should I be taking the extra step of not archiving the pointer and setting it after loading the object?

Answer 1

Two things:
Object Tracking facilitates this. Object Tracking is enabled by default when serializing pointers.
No, you do not serialize the unique_ptr like that.
In fact, there's little reason to serialize the m_parent of the child, either, because the parent can set the self-reference from within the load handler.
But assuming that you want the easy way, let's stick with that idea and make it work due to Object Tracking
DEMO
I included some tricks to demonstrate that deserialization
correct de-duplicates pointers to the same object
restores the member pointers even if we forcefully "break" the invariants prior to deserialization
Live On Coliru
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <memory>
#include <sstream>
#include <iostream>
class Parent;
class Child {
public:
Child(Parent *parent)
: m_parent(parent), m_duplicate_parent(parent) {}
Parent *m_parent { nullptr };
Parent *m_duplicate_parent{ nullptr };
private:
friend class boost::serialization::access;
template <class Archive> void serialize(Archive &ar, unsigned) {
ar & m_parent & m_duplicate_parent;
}
Child() = default;
};
class Parent {
public:
Parent() : m_child(std::make_unique<Child>(this)) {}
//private:
friend class boost::serialization::access;
template <class Archive> void serialize(Archive &ar, unsigned) {
ar & m_child;
}
std::unique_ptr<Child> m_child;
};
int main() {
std::stringstream ss;
{
boost::archive::text_oarchive oa(ss);
Parent p;
assert(&p == p.m_child->m_parent);
assert(&p == p.m_child->m_duplicate_parent);
oa << p;
}
std::cout << ss.str();
{
boost::archive::text_iarchive ia(ss);
Parent p;
// let's purposelly break the invariants so we know deserialization
// does restore them as required, and we not just "getting lucky":
p.m_child->m_parent = nullptr;
p.m_child->m_duplicate_parent = nullptr;
assert(&p != p.m_child->m_parent);
assert(&p != p.m_child->m_duplicate_parent);
// nuclear:
p.m_child.reset();
// now deserialize
ia >> p;
assert(&p == p.m_child->m_parent);
assert(&p == p.m_child->m_duplicate_parent);
}
}
Prints something similar to
22 serialization::archive 15 1 0
0 0 0 2 1 0
1 0 0 0 0