C++中nlohmann/json序列化含Layer指针的Network类方法咨询

原可正常工作的代码结构 #

类定义 #

class Layer {
public:
    std::string name;
    LayerType type;
    // 其他成员
};

class Network {
public:
    std::string name;
    std::vector<Layer> layers;
    // 其他成员
};

序列化/反序列化方法 #

void to_json(json& j, const Layer& layer) {
    j = json{
            {"name", layer.name},
            {"type", layer.type}
    };
}
void from_json(const json& j, Layer& layer) {
    j.at("name").get_to(layer.name);
    j.at("type").get_to(layer.type);
}

void to_json(json& j, const Network& network) {
    j = json{
        {"name", network.name},
        {"layers", network.layers}
    };
}
void from_json(const json& j, Network& network) {
    j.at("name").get_to(network.name);
    j.at("layers").get_to(network.layers);
}

修改后的Network类结构 #

class Network {
public:
    std::string name;
    std::vector<Layer*> layers;
    // 其他成员
};

重写后的序列化/反序列化方法 #

序列化（to_json） #

JSON只存储数据不保存内存地址，所以需要序列化指针指向的实际对象，遍历指针容器逐个解引用即可：

void to_json(json& j, const Network& network) {
    j = json{
        {"name", network.name},
        {"layers", json::array()}
    };
    for (const auto* layer_ptr : network.layers) {
        if (layer_ptr != nullptr) { // 避免空指针访问崩溃
            j["layers"].push_back(*layer_ptr);
        }
    }
}

反序列化（from_json） #

反序列化时需要从JSON数据创建新的Layer对象，再把指针存入容器。注意要先清理原有指针避免内存泄漏：

void from_json(const json& j, Network& network) {
    j.at("name").get_to(network.name);
    
    // 先释放原有对象内存，防止泄漏
    for (auto* layer_ptr : network.layers) {
        delete layer_ptr;
    }
    network.layers.clear();
    
    const auto& layers_json = j.at("layers");
    for (const auto& layer_json : layers_json) {
        Layer* new_layer = new Layer();
        layer_json.get_to(*new_layer);
        network.layers.push_back(new_layer);
    }
}

关键注意事项 #

• 内存泄漏风险：用原始指针的话，反序列化创建的对象需要你手动在合适的时机（比如Network析构时）调用delete释放所有layers里的指针。更推荐用std::vector<std::unique_ptr<Layer>>替代原始指针，nlohmann/json支持智能指针的序列化，还能自动管理内存，不用手动处理释放。
• 空指针检查：序列化时一定要判断指针是否为空，不然解引用空指针会直接崩溃。
• Layer类无需修改：原有的Layer序列化/反序列化方法可以直接复用，因为我们操作的是指针指向的Layer对象。

参考思路 #

nlohmann/json的核心逻辑是对数据内容进行序列化，而非内存地址。你可以基于自定义类型的序列化规则，扩展到指针容器的遍历处理——本质就是把指针转换成实际对象再序列化，反序列化时则从数据重建对象再存指针。

内容的提问来源于stack exchange，提问作者Kérdezősködő Indián