Question

我有一个奇怪的问题，尝试使用boost serialize反序列化指向派生类的指针。我有一个基础，并在其外部使用保存/加载函数（非侵入版本）派生，但每次我尝试反序列化指针时，我得到“输入流错误”异常或“未注册类”异常。这是我的工作：

首先我定义我的类：

#include <fstream>
#include <iomanip>

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/archive_exception.hpp>
#include "boost/serialization/split_free.hpp"
#include "boost/serialization/export.hpp"
#include "boost/serialization/utility.hpp"
#include <boost/serialization/string.hpp>
#include <boost/serialization/binary_object.hpp>

class Base
{
public:
    bool isEnabled;
    Base();
    virtual ~Base(){}
};
Base::Base()
{
    isEnabled = 0;
}

class Derived : public Base
{

public:
    Derived();
    virtual ~Derived(){}
    int layerHeight;
};
Derived::Derived():Base()
{}

然后我确保他们的特质是我需要的：

BOOST_CLASS_EXPORT_GUID(Base, "Base")
BOOST_SERIALIZATION_SPLIT_FREE(Base)
BOOST_CLASS_IS_WRAPPER(Base)
BOOST_CLASS_TRACKING(Base, boost::serialization::track_selectively)
BOOST_CLASS_IMPLEMENTATION(Base, boost::serialization::object_class_info)

BOOST_SERIALIZATION_SPLIT_FREE(Derived)
BOOST_CLASS_EXPORT_GUID(Derived, "Derived")
BOOST_CLASS_IS_WRAPPER(Derived)
BOOST_CLASS_IMPLEMENTATION(Derived, boost::serialization::object_class_info)
BOOST_CLASS_TRACKING(Derived, boost::serialization::track_selectively)

接下来我定义了实际的保存/加载功能：

namespace boost {

    namespace serialization {

    template<class Archive>
    void save(Archive & ar,const Base& obj, const unsigned int version)
    {
        bool isEnabled = obj.isEnabled;
        ar << BOOST_SERIALIZATION_NVP(isEnabled);
    }
    template<class Archive>
    void load(Archive & ar, Base& obj, const unsigned int version)
    {
        bool isEnabled;
        ar >> BOOST_SERIALIZATION_NVP(isEnabled);
    }
    } // namespace serialization
} // namespace boost

namespace boost {
template<>
struct is_virtual_base_of<Base, Derived>: public mpl::true_ {};

namespace serialization {

template<class Archive>
void save(Archive & ar,const Derived& obj, const unsigned int version)
{
    ar & boost::serialization::base_object<Base>(obj);
    int height =obj.layerHeight;
    ar << BOOST_SERIALIZATION_NVP(height);
}
template<class Archive>
void load(Archive & ar, Derived& obj, const unsigned int version)
{
    ar.template register_type<Base>();
    ar.template register_type<Derived>();
    ar & boost::serialization::base_object<Base>(obj);
    int height;
    ar >> BOOST_SERIALIZATION_NVP(height);
}
} // namespace serialization
} // namespace boost

我从Docs借来的2个保存/加载助手

template <typename T>
void save_schedule(const T& s, const char * filename){
    // make an archive
    std::ofstream ofs(filename);
    assert(ofs.good());
    boost::archive::xml_oarchive oa(ofs);
    oa << BOOST_SERIALIZATION_NVP(s);
}

template <typename T>
void restore_schedule(T &s, const char * filename)
{
    // open the archive
    std::ifstream ifs(filename);
    assert(ifs.good());
    boost::archive::xml_iarchive ia(ifs);
    // restore the schedule from the archive
    ia >> BOOST_SERIALIZATION_NVP(s);
}

最后 - 这是我尝试使用它的方式

int main(int argc, char *argv[])
{
    Base* basePointer = new Base();
    Base* objectPointer = new Derived();
    Derived * secondObjectPointer = new Derived();
    Derived justObject;

    save_schedule(basePointer, "C:\\basePointer.xml");
    save_schedule(objectPointer, "C:\\objectPointer.xml");
    save_schedule(secondObjectPointer , "C:\\secondObjectPointer.xml");
    save_schedule(justObject, "C:\\justObject.xml");

    //this works OK
    restore_schedule(basePointer, "C:\\basePointer.xml");

    //this gives "Input Stream Error"
    restore_schedule(objectPointer, "C:\\objectPointer.xml");

    //this gives "Unregistered class"
    restore_schedule(secondObjectPointer, "C:\\secondObjectPointer.xml");

    //This works >__< But I need to serialize pointers so I cannot use this
    restore_schedule(justObject, "C:\\justObject.xml");
}

我做错了什么？为什么我不能反序列化除基类的指针之外的任何东西？

Answer 1

UPD ::经过多次搜索后，我能够将问题追溯到这个答案：

boost serialization exception: unregistered class, serializing polymorphic base problem

替换

//original taken from Boost Docs
ar & boost::serialization::base_object<Base>(obj);

与

// taken from the link above (macro expanded)
ar & boost::serialization::make_nvp( BOOST_PP_STRINGIZE(obj),boost::serialization::base_object<Base >(obj));

确实解决了这个问题。

作为旁注 - 我发现了另一种可能出现的奇怪错误并导致“流输入错误”。它的工作原理如下：

如果你的层次结构中甚至有一个构造函数可以初始化一个变量（任何变量）但是没有 - 你会在尝试反序列化时遇到流输入错误。

如果一个类中没有变量 - 一切都OK。但如果有一个 - 你必须在该类的构造函数中初始化至少一个变量！我不知道为什么这很重要但这对我来说是一个重大问题。

Answer 2

我不是Boost序列化的专家。我只经历了两天。我遇到了与您相同的问题，并且在阅读了完整的文档后，仍然无法成功解决该问题。但是，对我有用的您的解决方案使我想到了以下几点。

如文档在Special Considerations/XML Archives一章中所述：

XML与其他格式的不同之处在于，它需要一个名称每个数据成员。我们的目标是将此信息添加到班级中序列化规范，同时仍然允许要与任何存档一起使用的序列化代码。这是通过实现要求将序列化为XML存档的所有数据序列化为一个名称/值对。

这意味着在使用XML归档文件时，每个字段都必须保存一个名称。这就是为什么我们总是需要使用BOOST_SERIALIZATION_NVP宏的原因，该宏在XML文件中添加了参数名称的字符串化转换。

您的解决方案使我认为，即使对于基类的序列化，XML也需要与之关联的名称。 boost::serialization::base_object<Base>不能像BOOST_SERIALIZATION_NVP那样提供自动名称，因此我们需要为它明确提供以下功能：

template<class T> const nvp< T > boost::serialization::make_nvp(const char * name, T & t)

BOOST_PP_STRINGIZE(obj)将参数obj字符串化。就我而言，我更喜欢乱扔字符串：

ar & boost::serialization::make_nvp("MyBase", boost::serialization::base_object<Base>(obj));

这是我的理解。如果我是假的，请纠正我。

使用Boost反序列化指向派生类的指针的问题：serialize

2 个答案: