增强序列化-启用对象跟踪

我有一个类a，它拥有一个std:：向量，还有一组类B的实例，其中包含一个指向a中向量的指针。

现在我想使用boost:：serialization来序列化A和B的所有实例，但在序列化的数据中可能只存在A中数据向量的一个实例。

我知道这个问题可以（而且经常应该）通过使用shared_ptr来解决，但这在我的特定情况下不起作用。

要将其归档，序列化方法会是什么样子？

以下是我尝试过的。对我来说，似乎没有完成对象跟踪，或者reset_object_address没有像我想象的那样工作。

#include <assert.h>
#include <vector>
#include <sstream>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/vector.hpp>
std::stringstream ss;
// A wrapper class created to controle the serialization traits
template< typename T >
struct vector_wrapper {
    std::vector<T> v;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        ar & v;
    }
};
namespace boost {
namespace serialization {
template<class T>
struct tracking_level<const vector_wrapper<T> * >
{
    typedef mpl::integral_c_tag tag;
    typedef mpl::int_<track_always> type;
    BOOST_STATIC_CONSTANT(
        int,
        value = tracking_level::type::value
    );
};
} // namespace serialization
} // namespace boost
struct A {
    vector_wrapper<unsigned> data;
    BOOST_SERIALIZATION_SPLIT_MEMBER();
    A() {};
    A(unsigned i) { data.v.push_back(i); }
    template<class Archive>
    void save(Archive & ar, const unsigned int version) const {
        const vector_wrapper<unsigned> * ptr = &data;
        ar & ptr;
        std::cout << "SAVE> data size: " << data.v.size() << " ptr: " << &data << std::endl;
    }
    template<class Archive>
    void load(Archive & ar, const unsigned int version) {
        const vector_wrapper<unsigned> * ptr = 0;
        ar & ptr;
        data = *ptr;
        ar.reset_object_address(&data, ptr); // does not seem to have any effect
        std::cout << "LOAD> data size: " << data.v.size() << " ptr: " << &data << std::endl;
        delete ptr;
    }
};
struct B {
    const vector_wrapper<unsigned> * ptr_data;
    B() : ptr_data(0) { }
    B( const vector_wrapper<unsigned> * p ) : ptr_data(p) { }
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        ar & ptr_data;
        std::cout << "SERILIAZE> ptr: " << ptr_data << std::endl;
    }
};
struct C {
    A a;
    B b1;
    B b2;
    B b3;
    C () { } // default constructor
    C (unsigned i) : // bootstrap constructor
        a(i),
        b1(&a.data),
        b2(&a.data),
        b3(&a.data) { }
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
        ar & a;
        ar & b1;
        ar & b2;
        ar & b3;
    }
};
int main(int argc, const char *argv[]) {
    C c1(7);
    boost::archive::binary_oarchive o(ss);
    o << c1;
    C c2;
    boost::archive::binary_iarchive i(ss);
    i >> c2;
    assert( &c1.a.data == c1.b1.ptr_data );
    assert( &c1.a.data == c1.b2.ptr_data );
    assert( &c1.a.data == c1.b3.ptr_data );
    assert( &c2.a.data == c2.b1.ptr_data ); // fails
    assert( &c2.a.data == c2.b2.ptr_data ); // fails
    assert( &c2.a.data == c2.b3.ptr_data ); // fails
    return 0;
}