如何用API返回的部分JSON信息高效初始化C++结构体A？

问题背景 #

给定如下C++结构体A：

struct A {
    bool m_a;
    std::string m_b, m_c;
    float m_d, m_e;
    double m_f;
    time_t m_g;

    A() = default;

    A(
        bool a, std::string b,
        std::string c, float d,
        float e, double f, time_t g
    )
        : m_a(a), m_b(b), m_c(c),
        m_d(d), m_e(e), m_f(f), m_g(g) {};
};

以及存储API返回数据的nlohmann::json对象（部分字段可能缺失）：

nlohmann::json j = {
    {"a", "true"},
    {"g", "1660228853"}
    // 可能缺失b、c、d、e、f等字段
};

需要实现高效初始化结构体A，支持API返回字段缺失的场景。

解决方案 #

方案1：利用nlohmann/json的value()方法处理默认值 #

nlohmann::json的value()方法可在键不存在时返回指定默认值，结合类型转换逻辑处理API返回的字符串类型数据：

A init_A_from_json(const nlohmann::json& j) {
    A obj;
    // 处理bool类型：API返回"true"/"false"字符串
    std::string a_str = j.value("a", "false");
    obj.m_a = (a_str == "true");
    
    // 字符串类型默认取空串
    obj.m_b = j.value("b", std::string{});
    obj.m_c = j.value("c", std::string{});
    
    // 数值类型默认设为0.0
    obj.m_d = j.value("d", 0.0f);
    obj.m_e = j.value("e", 0.0f);
    obj.m_f = j.value("f", 0.0);
    
    // 时间戳：字符串转time_t，默认值设为0
    std::string g_str = j.value("g", "0");
    obj.m_g = std::stoll(g_str);
    
    return obj;
}

该方案逻辑直观，无需修改结构体原有定义，逐个字段处理清晰可控。

方案2：重载结构体构造函数 #

为结构体A新增一个接收nlohmann::json参数的构造函数，内部封装字段缺失处理和类型转换：

struct A {
    bool m_a;
    std::string m_b, m_c;
    float m_d, m_e;
    double m_f;
    time_t m_g;

    A() = default;

    A(
        bool a, std::string b,
        std::string c, float d,
        float e, double f, time_t g
    )
        : m_a(a), m_b(b), m_c(c),
        m_d(d), m_e(e), m_f(f), m_g(g) {};
        
    // 新增：从JSON初始化的构造函数
    explicit A(const nlohmann::json& j) {
        std::string a_str = j.value("a", "false");
        m_a = (a_str == "true");
        
        m_b = j.value("b", std::string{});
        m_c = j.value("c", std::string{});
        
        m_d = j.value("d", 0.0f);
        m_e = j.value("e", 0.0f);
        m_f = j.value("f", 0.0);
        
        std::string g_str = j.value("g", "0");
        m_g = std::stoll(g_str);
    }
};

使用时直接通过A obj(j);完成初始化，符合面向对象封装思想，代码调用更简洁。

方案3：自定义nlohmann/json全局转换规则 #

如果需要全局复用结构体与JSON的转换逻辑，可自定义adl_serializer，让nlohmann/json自动处理转换：

namespace nlohmann {
    template<>
    struct adl_serializer<A> {
        static A from_json(const json& j) {
            A obj;
            std::string a_str = j.value("a", "false");
            obj.m_a = (a_str == "true");
            
            obj.m_b = j.value("b", std::string{});
            obj.m_c = j.value("c", std::string{});
            
            obj.m_d = j.value("d", 0.0f);
            obj.m_e = j.value("e", 0.0f);
            obj.m_f = j.value("f", 0.0);
            
            std::string g_str = j.value("g", "0");
            obj.m_g = std::stoll(g_str);
            
            return obj;
        }
    };
}

使用时直接调用A obj = j.get<A>();，字段缺失时自动用默认值填充，完全集成到nlohmann/json的序列化体系中。

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