Boost:序列化重构(加载)

EDIT:

手册中有一部分我想我们都错过了:这里的非默认构造函数部分。要使其工作，您需要save_construct_data和load_construct_data功能。这里有一个轻微的技术术语，在这里讨论这些。

还有，你说你在尝试只加载时遇到了这个问题，但是你可以保存好。这让我觉得你可能省略了

BOOST_CLASS_EXPORT_GUID(state, "state")

一旦进行加载编译(请参阅手册的导出部分)，此遗漏可能会导致分段错误

为了确保我没有弄错，我做了一个编译示例，我添加了它，以防它有用。

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/export.hpp>
#include <iostream>
#include <fstream>
//base class
struct base
{
  base(double d) : m_d(d) {}
  virtual double run() = 0;
private:
  friend class boost::serialization::access;
  double m_d;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version)
  {
    ar & m_d;
  }
};
//forward declare the save construct data before friending it 
// (something about friend being in a different namespace)
class derived;
namespace boost { namespace serialization {
template<class Archive>
inline void save_construct_data(Archive & ar, const derived * t, const unsigned int file_version);
}}

//derived class with non-default constructor
struct derived : public base
{
  derived(double a , double b) : 
    base(a+b),
    m_a(a),m_b(b),m_c(a*b) 
  {}
  //some checks
  double get_a() const {return m_a;}
  double get_b() const {return m_b;}
  double get_c() const {return m_c;}
  double run(){return 1.0;}
private:
  friend class boost::serialization::access;
  template<class Archive> 
  friend void boost::serialization::save_construct_data(Archive & ar, const derived * t, const unsigned int file_version);
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version)
  {
    ar & boost::serialization::base_object<base>(*this);
    //only need to return c, a and b already done for constructor
    ar & m_c;
  }
  double m_a, m_b, m_c;
 };
//Save and load the data required for the constructor.
namespace boost { namespace serialization {
  template <class Archive>
    inline void save_construct_data(
                    Archive & ar,const derived* d,const unsigned int file_version
                    )
    {
      // save data required to construct instance
      ar << d->m_a;
      ar << d->m_b;
    }
    template <class Archive>
    inline void load_construct_data(
                        Archive & ar, derived* d,const unsigned int file_version
                        )
    {
      double a,b;
      ar >> a;
      ar >> b;
    // invoke inplace constructor to initialize instance of my_class
      ::new(d) derived(a,b);
    }
  }
}
//register the derived class with boost.
BOOST_CLASS_EXPORT_GUID(derived, "derived")
int
main  (int ac, char **av)
{
  std::ofstream ofs("filename");
  base* p = new derived(2,3);
  // save data to archive
  {
    boost::archive::text_oarchive oa(ofs);
    oa << p;
  }
  // ... some time later restore the class instance to its orginal state
  base* p2;
  {
     std::ifstream ifs("filename");
     boost::archive::text_iarchive ia(ifs);
     ia >> p2;
  }
  derived* d = static_cast<derived*>(p2);
  std::cout<<"p2 vals are: "<<d->get_a()<<" "<<d->get_b()<<" "<<d->get_c()<<std::endl;
}

老回应:

不确定我完全理解你的问题(一个更完整的例子会帮助我)-当您序列化对象时，构造函数通常不会出现在其中:您序列化原始数据?

你的意思是你不想序列化对象的所有原始数据，而只是想在反序列化对象时再次重构它(使用构造函数)?如果是这样，那么您可以通过序列化重建所需的数据并拆分保存和加载操作来实现此目的。

struct my_class
{
  my_class(Agent& A, ACTION_MODE const & m)
    : m_state(A,M)
  {}

private: 
  State m_state;
  friend class boost::serialization::access;
  void save(Archive & ar, const unsigned int version) const
  {
      // note, version is always the latest when saving
      Agent tmp_A = m_state.get_A();
      ACTION_MODE tmp_m = m_state.get_m();
      ar & tmp_A; 
      ar & tmp_m;
  }
  template<class Archive>
  void load(Archive & ar, const unsigned int version)
  {
      Agent tmp_A;
      ACTION_MODE tmp_m
      ar & tmp_A; 
      ar & tmp_m;
      m_state = State(tmp_A,tmp_m);
  }
  BOOST_SERIALIZATION_SPLIT_MEMBER()
}

这有帮助吗，还是我没抓住重点?