含抽象类的Boost序列化循环依赖恢复失败问题咨询

问题背景 #

尝试为存在循环依赖的Geometry和Dimension类（均继承自抽象接口）实现Boost序列化：Geometry关联Dimension，Dimension也持有Geometry指针，同时有包含二者向量的DataModel类。移除抽象类后序列化正常，但保留抽象类时反序列化触发访问违例。

类定义 #

class IGeometry
{
public:
    virtual ~IGeometry() = default;
};

class IDimension
{
public:
    virtual ~IDimension() = default;
    virtual const std::vector<IGeometry*>& GetGeometries() const = 0;
};

class Dimension : public virtual IDimension
{
public:
    Dimension(std::vector<IGeometry*> f) : geometries{ std::move(f) } {}
    ~Dimension() override = default;

    const std::vector<IGeometry*>& GetGeometries() const override 
    {
        return geometries;
    }

private:
    std::vector<IGeometry*> geometries;
};

class Geometry : public virtual IGeometry
{
public:
    ~Geometry() override {}

    void AddDimension(IDimension* dimension)
    {
        dimensions.emplace_back(dimension);
    }
    const std::vector<IDimension*>& GetDimensions() const { return dimensions; }
private:
    std::vector<IDimension*> dimensions{};
};

struct DataModel
{
    std::vector<IGeometry*> geometries;
    std::vector<IDimension*> dimensions;
};

序列化实现代码 #

BOOST_SERIALIZATION_SPLIT_FREE(Geometry)

BOOST_CLASS_EXPORT(Dimension)
BOOST_CLASS_EXPORT(Geometry)

namespace boost
{
namespace serialization
{

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

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

template<class Archive>
void save(Archive& ar, const Geometry& g, const unsigned int version)
{
    ar& boost::serialization::base_object<IGeometry>(g);
    ar& g.GetDimensions();
}
template<class Archive>
void load(Archive& ar, Geometry& g, const unsigned int version)
{
    ar& boost::serialization::base_object<IGeometry>(g);

    std::vector<IDimension*> dimensions;
    ar& dimensions;
    for(auto* dimension : dimensions)
    {
        g.AddDimension(dimension);
    }
}

template<class Archive>
void serialize(Archive& ar, Dimension& d, unsigned int version)
{
    ar& boost::serialization::base_object<IDimension>(d);
}

template<class Archive>
void save_construct_data(Archive& ar, const Dimension* t, const unsigned int)
{
    ar& t->GetGeometries();
}

template<class Archive>
void load_construct_data(Archive& ar, Dimension* t, const unsigned int file_version)
{
    std::vector<IGeometry*> foos;
    ar& foos;
    ::new(t)Dimension(foos);
}

template<class Archive>
void serialize(Archive& ar, DataModel& model, const unsigned int version)
{
    ar& model.dimensions & model.geometries ;
}

}
}

void SaveModel(const DataModel& model)
{
    std::ofstream ofs("filename");
    boost::archive::text_oarchive oa(ofs);
    oa << model;
}

void RestoreModel(DataModel& model)
{
    std::ifstream ofs("filename");
    boost::archive::text_iarchive ia(ofs);
    ia >> model;
}

int main()
{
    {
        auto* p0 = new Geometry();
        auto* p1 = new Geometry();

        auto* d2 = new Dimension({ p0, p1 });

        p0->AddDimension(d2);
        p1->AddDimension(d2);

        DataModel model;

        model.geometries.emplace_back(p0);
        model.geometries.emplace_back(p1);
        model.dimensions.emplace_back(d2);

        SaveModel(model);
    }

    DataModel model2;
    RestoreModel(model2);

    return 0;
}

异常信息 #

Exception thrown at 0x00007FF7F62BA385 in boost.exe: 0xC0000005: Access violation reading location 0xFFFFFFFFFFFFFFFF.

问题解答 #

1. 此类包含循环依赖与抽象类的数据模型是否可进行序列化？ #

完全可以。Boost序列化原生支持循环引用和多态抽象类的序列化，只要正确配置类型注册、序列化顺序和指针追踪逻辑，就能正常工作。

2. 当前序列化代码（涉及接口等部分）是否整体正确？ #

不正确，存在多处关键错误：

• 抽象基类未标记为抽象：没有使用BOOST_SERIALIZATION_ASSUME_ABSTRACT宏告诉Boost这是抽象类，可能导致多态类型识别异常。
• Dimension的序列化逻辑错误：把成员变量geometries的序列化放在save_construct_data/load_construct_data中，这两个函数仅用于处理构造函数的必要参数，而geometries是对象的常规成员，且涉及循环引用，应该放在serialize函数中处理。
• DataModel序列化顺序倒置：先序列化dimensions再序列化geometries，反序列化时Dimension构造需要的Geometry指针还未被创建，Boost无法解析未初始化的指针。
• Dimension的serialize函数未处理成员变量：仅序列化了抽象基类，没有处理geometries成员，导致数据丢失或指针追踪失效。

3. 反序列化循环依赖时我存在哪些错误？ #

核心错误有三点：

• 构造顺序错误：DataModel反序列化时先处理dimensions，此时geometries中的对象还未被创建，Dimension构造函数收到的是未初始化的野指针（0xFFFFFFFFFFFFFFFF是典型的无效指针标记），直接触发访问违例。
• 循环引用的指针追踪未生效：Dimension的geometries通过构造数据序列化，绕过了Boost的指针追踪机制，无法处理循环引用中对象的依赖关系。
• 抽象类的多态配置不全：仅用BOOST_CLASS_EXPORT注册派生类，但未标记抽象基类，导致Boost无法正确识别多态类型的继承关系，序列化/反序列化时类型信息出错。

关键修正示例 #

1. 给抽象基类添加抽象标记：

class IGeometry
{
public:
    virtual ~IGeometry() = default;
};
BOOST_SERIALIZATION_ASSUME_ABSTRACT(IGeometry)

class IDimension
{
public:
    virtual ~IDimension() = default;
    virtual const std::vector<IGeometry*>& GetGeometries() const = 0;
};
BOOST_SERIALIZATION_ASSUME_ABSTRACT(IDimension)

2. 调整DataModel的序列化顺序：

template<class Archive>
void serialize(Archive& ar, DataModel& model, const unsigned int version)
{
    ar& model.geometries & model.dimensions ; // 先序列化/反序列化Geometry
}

3. 修改Dimension的序列化逻辑，移除save_construct_data/load_construct_data，改用默认构造+成员序列化：

class Dimension : public virtual IDimension
{
public:
    Dimension() = default; // 添加默认构造
    Dimension(std::vector<IGeometry*> f) : geometries{ std::move(f) } {}
    ~Dimension() override = default;

    const std::vector<IGeometry*>& GetGeometries() const override 
    {
        return geometries;
    }

private:
    std::vector<IGeometry*> geometries;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar& boost::serialization::base_object<IDimension>(*this);
        ar& geometries; // 直接序列化成员变量
    }
};

内容的提问来源于stack exchange，提问作者RoQuOTriX