C++ 如何通过指向基类的指针序列化派生类？派生：：未调用序列化

我试图通过使用指向基类的指针进行boost序列化，使派生类可序列化

已调用Base:：序列化。派生：：未调用序列化

我做错了什么

#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;
}

#包括
#包括
#包括
#包括
结构基
{
int x；
Base（）{x=0；}
虚拟~Base（）{}
模板
无效序列化（存档和ar，常量未签名整数版本）
{
ar&x；
}
};
BOOST\u序列化\u假设\u抽象（基本）
派生结构：基
{
int-y；
派生（）{x=1；y=2；}
虚~Derived（）{}
模板
无效序列化（存档和ar，常量未签名整数版本）
{
ar&boost:：serialization:：base_对象（*this）；
ar&y；
}
};
int main（）
{
派生的；
Base*basePtr=&派生的；
std：：字符串s；
标准：：stringstream ss（s）；
boost：：archive：：binary_oarchive oa（ss）；
oa首先，您没有通过指针序列化，请修复它：

oa << basePtr;

已编辑。仍然不起作用。如果您谈论void serialize：成员函数模板不能是虚拟的。事实上，允许RTTI必须将涉及的类型设置为虚拟的（请注意，Boost Any in在Boost 1.57.0中不再需要RTTI，也许将来Boost序列化也可以采用这种技术）输入不起作用。你能帮我吗？问题已编辑。请稍等。是吗，只是想问一个不同的问题/？你应该发布一个新问题。如果你问我，这是一个非常愚蠢的举动。
oa.register_type<Derived>();

ar.template register_type<Derived>();

#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";
    }
}