我有一个类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;
}
解决方案之一是将A中的保存和加载方法更改为:
template<class Archive>
void save(Archive & ar, const unsigned int version) const {
ar & data;
std::cout << "SAVE> data size: " << data.v.size() << " ptr: " << &data << std::endl;
}
template<class Archive>
void load(Archive & ar, const unsigned int version) {
ar & data;
std::cout << "LOAD> data size: " << data.v.size() << " ptr: " << &data << std::endl;
}
也就是说,直接序列化vector_wrapper,而不是作为指针。在修复之后,将传递所有断言。