C++ 在C++；

我将基本代码块和它们之间的控制流表示为循环图，希望能够将该图序列化为XML或类似格式，然后将其反序列化并在另一个应用程序中使用该图。当尝试序列化数据结构时，我会收到数千次对序列化函数的调用，即使我用来测试应用程序的图形包含的节点不到50个，这让我相信循环引用存在问题

当我运行或调试应用程序时，它会成功地反复输入

void serialize（Archive&，std:：vector&，const unsigned）

函数，直到它因分段错误而崩溃。输出文件已创建，但未写入任何内容

下面是我用来表示基本块的数据结构

struct __attribute__ ((visibility ("default"))) BasicBlock {
    unsigned int id;
    unsigned int start_address;
    unsigned int end_address;
    std::vector<BasicBlock*>* outgoing;
    std::vector<BasicBlock*>* incoming;
};

struct\uuuuu属性（可见性（“默认”））基本块{
无符号整数id；
无符号整数起始地址；
无符号整数结束地址；
std：：矢量*输出；
std：：矢量*输入；
};

这是序列化类和函数

class Serialize {
public:

    static void marshal(const std::vector<BasicBlock*>& basic_blocks, std::string filename) {
        std::ofstream ofstream(filename.c_str(), std::ios::out | std::ios::binary);
        boost::archive::text_oarchive archive(ofstream);
        archive << basic_blocks;
    }

    static void unmarshal(const std::string filename, std::vector<BasicBlock*>& basic_blocks) {
        std::ifstream ifstream(filename.c_str());
        boost::archive::text_iarchive archive(ifstream);
        archive >> basic_blocks;
    }

};

namespace boost {
    namespace serialization {

    template<class Archive>
    void save(Archive & archive, const BasicBlock& basic_block, const unsigned int version) {
        archive & basic_block.id;
        archive & basic_block.start_address;
        archive & basic_block.end_address;
        archive & basic_block.incoming;
        archive & basic_block.outgoing;
    }

    template<class Archive>
    void load(Archive & archive, BasicBlock& basic_block, const unsigned int version) {
        archive & basic_block.id;
        archive & basic_block.start_address;
        archive & basic_block.end_address;
        archive & basic_block.incoming;
        archive & basic_block.outgoing;
    }

    template<typename Archive>
    void serialize(Archive& archive, std::vector<BasicBlock>& basic_blocks, const unsigned version) {
        archive & basic_blocks;
    }

    template<typename Archive>
    void serialize(Archive& archive, std::vector<BasicBlock*>& basic_blocks, const unsigned version) {
        archive & basic_blocks; // Triggered thousands of times...
    }

    }
}

BOOST_SERIALIZATION_SPLIT_FREE(BasicBlock)

类序列化{
公众：
静态无效封送处理（const std:：vector&basic_块，std:：string文件名）{
流的std:：of流（filename.c_str（），std:：ios:：out | std:：ios:：binary）；
boost:：archive:：text_oarchive归档（of Stream）；
存档>基本块；
}
};
名称空间提升{
命名空间序列化{
模板
无效保存（存档和存档、常量基本块和基本块、常量未签名整数版本）{
存档和基本块id；
存档和基本块开始地址；
存档和基本块结束地址；
存档和基本块输入；
存档和基本块输出；
}
模板
无效加载（存档和存档、基本块和基本块、常量无符号整数版本）{
存档和基本块id；
存档和基本块开始地址；
存档和基本块结束地址；
存档和基本块输入；
存档和基本块输出；
}
模板
无效序列化（存档和存档，标准：：向量和基本块，常量未签名版本）{
存档和基本块；
}
模板
无效序列化（存档和存档，标准：：向量和基本块，常量未签名版本）{
存档&basic_blocks；//已触发数千次。。。
}
}
}
增强序列化分离自由（基本块）

我的第一个怀疑是，

vector

s的“save”重载实际上会毁掉你的东西

template<typename Archive>
    void serialize(Archive& archive, std::vector<BasicBlock*>& basic_blocks, const unsigned version) {
        archive & basic_blocks; // Triggered thousands of times...
    }

---

我的第一个怀疑是，

vector

s的“save”重载实际上会毁掉你的东西

template<typename Archive>
    void serialize(Archive& archive, std::vector<BasicBlock*>& basic_blocks, const unsigned version) {
        archive & basic_blocks; // Triggered thousands of times...
    }

---

你说得对，非常感谢。当你（我）在一个项目中包含一个巨大的框架，并且仅仅接受突然提供的所有神奇的东西时，这会有点问题。。别以为我自己会发现这是一个递归调用。你是对的，非常感谢。当你（我）在一个项目中包含一个巨大的框架，并且仅仅接受突然提供的所有神奇的东西时，这会有点问题。。我想我永远也不会发现这是我自己的递归调用。