c++ - 如何通过指向基类的指针序列化派生类？ Derived::serialize 未调用

Question

我正在尝试使用指向基类的指针通过 boost 序列化来使派生类可序列化。

Base::序列化调用。 Derived::serialization 未调用。

我做错了什么？

#include <sstream>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/assume_abstract.hpp>

struct Base
{
    int x;
    Base() { x = 0; }
    virtual ~Base() {}

    template<class Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        ar & x;
    }
};

BOOST_SERIALIZATION_ASSUME_ABSTRACT(Base)

struct Derived : Base
{
    int y;
    Derived() { x = 1; y = 2; }
    virtual ~Derived() {}

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & boost::serialization::base_object<Base>(*this);
        ar & y;
    }
};

int main()
{
    Derived derived;
    Base *basePtr = &derived;

    std::string s;
    std::stringstream ss(s);
    boost::archive::binary_oarchive oa(ss);

    oa << *basePtr;
}

Answer 1

首先，您没有通过指针序列化，修复它:

oa << basePtr;

其次，您需要注册派生类型:

oa.register_type<Derived>();

或者，在序列化函数中:

ar.template register_type<Derived>();

您可能还想查看注册类信息以进行序列化:http://www.boost.org/doc/libs/1_57_0/libs/serialization/doc/special.html#export

---

更新评论/编辑的问题:

您的问题代码序列化一个 Base* 并反序列化一个 Derived。类型不相关，这永远行不通。它们必须相同。

此外，注册读取输入存档的派生类型。

Live On Coliru

#include <sstream>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/assume_abstract.hpp>

struct Derived;

struct Base
{
    int x;
    Base() { x = 0; }
    virtual ~Base() {}

    template<class Archive>
    void serialize(Archive &ar, const unsigned int version)
    {
        ar.template register_type<Derived>();
        ar & x;
    }
};

BOOST_SERIALIZATION_ASSUME_ABSTRACT(Base)

struct Derived : Base
{
    int y;
    Derived() { x = 1; y = 2; }
    virtual ~Derived() {}

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & boost::serialization::base_object<Base>(*this);
        ar & y;
    }
};

int main()
{
    std::stringstream ss;

    {
        Derived derived;
        Base *basePtr = &derived;

        boost::archive::binary_oarchive oa(ss);
        oa.register_type<Derived>();

        oa << basePtr;
        ss.flush();
    }

    {
        boost::archive::binary_iarchive ia(ss);
        ia.register_type<Derived>();

        Base *basePtr = nullptr;

        ia >> basePtr;
        std::cout << "basePtr->x = " << basePtr->x << "\n";
        if (Derived* derivedPtr = dynamic_cast<Derived*>(basePtr))
            std::cout << "derivedPtr->y = " << derivedPtr->y << "\n";
    }
}