nlohmann/json 深度解析之如何让 C++ 解析 JSON 像喝水一样简单

// 全库只需要这一行引入，就是这么简单
#include <nlohmann/json.hpp>
using nlohmann::json;   // 取个短名字，后面写起来省事

// cmake 三种最常用的引入方式（任选其一）
// 方式一：fetchcontent（推荐，自动下载）
// include(fetchcontent)
// fetchcontent_declare(nlohmann_json url https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
// fetchcontent_makeavailable(nlohmann_json)
// target_link_libraries(你的目标 private nlohmann_json::nlohmann_json)
// 方式二：vcpkg
// vcpkg install nlohmann-json
// 方式三：把 json.hpp 直接放进 include 目录
// #include <nlohmann/json.hpp> 即可

std::vector<int> nums = {1, 2, 3};
json j = nums;              // 容器 -> json，一行搞定
std::vector<int> back = j;  // json -> 容器，还是返回 std::vector<int>

try {
    auto j = json::parse(r"({"a": 1, )");  // 故意写个语法错误
} catch (const json::parse_error& e) {
    std::cout << "解析失败: " << e.what() << std::endl;
    // 输出会包含 byte 位置，方便定位
}

#include <nlohmann/json.hpp>
#include <fstream>
#include <iostream>
using nlohmann::json;
int main() {
    // 假设 config.json 内容: {"server": {"host": "127.0.0.1", "port": 8080}, "debug": true}
    std::ifstream f("config.json");
    json cfg = json::parse(f);   // 直接吃流对象，不用先读成字符串
    std::string host = cfg["server"]["host"].get<std::string>();
    int port = cfg["server"]["port"].get<int>();
    bool debug = cfg["debug"].get<bool>();
    std::cout << "连接 " << host << ":" << port
              << (debug ? " (调试模式)" : "") << std::endl;
    return 0;
}

// 伪代码示意：真实网络请求请用 libcurl / httplib 等
json request;
request["action"] = "login";
request["user"] = "alice";
request["tags"] = {"cpp", "json"};       // 数组直接塞
// 序列化发送
std::string body = request.dump();       // {"action":"login","user":"alice","tags":["cpp","json"]}
// 假设收到响应字符串，反序列化
std::string response_str = r"({"code":0,"data":{"token":"abc123","expire":3600}})";
json resp = json::parse(response_str);
if (resp.at("code").get<int>() == 0) {
    auto token = resp["data"]["token"].get<std::string>();
    std::cout << "登录成功, token=" << token << std::endl;
}

#include <nlohmann/json.hpp>   // 结束，真的就这么简单

vcpkg install nlohmann-json
# 然后在 cmakelists.txt 里：
# find_package(nlohmann_json config required)
# target_link_libraries(你的目标 private nlohmann_json::nlohmann_json)

include(fetchcontent)
fetchcontent_declare(nlohmann_json
    url https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
fetchcontent_makeavailable(nlohmann_json)

#include <nlohmann/json.hpp>
#include <iostream>
using nlohmann::json;
int main() {
    json j = {{"hello", "world"}};
    std::cout << j.dump() << std::endl;   // 输出 {"hello":"world"}
    return 0;
}
// 编译（g++）: g++ -std=c++17 main.cpp -o main
// 编译（msvc）: cl /std:c++17 /ehsc main.cpp

// 1. 从字符串解析
auto j1 = json::parse(r"({"name": "alice", "age": 30})");
// 2. 从文件流解析
std::ifstream fin("data.json");
auto j2 = json::parse(fin);
// 3. 从 c 字符串指针 + 长度解析（跳过前 5 个字节的场景）
const char* raw = "xxxxx{\"k\": 1}";
auto j3 = json::parse(raw + 5, raw + 13);   // 传入起止迭代器，只解析 {"k": 1}
// 4. 宽容模式：允许注释、尾随逗号（对人工手写的配置非常友好）
auto j4 = json::parse(r"({
    "host": "localhost",   // 这是注释，标准 json 不允许
    "port": 8080,          // 尾逗号，标准 json 也不允许
})", nullptr, /*allow_exceptions=*/true, /*ignore_comments=*/true);
// 5. 更宽松：允许尾随逗号 + 非严格数字
auto j5 = json::parse("[1, 2, 3, ]", nullptr, true, true, /*ignore_trailing_comma=*/true);

json v;
v = 42;                 // 现在是 number
std::cout << v.is_number() << std::endl;   // 1 (true)
v = "hello";            // 现在是 string
std::cout << v.is_string() << std::endl;   // 1 (true)
std::cout << v.is_null() << std::endl;     // 0
// 常用类型判断全家桶
// is_object()  is_array()  is_string()  is_number()  is_boolean()  is_null()
// is_number_integer()  is_number_unsigned()  is_number_float()

json j;
j["name"] = "bob";              // 直接赋值，自动创建对象
j["age"] = 25;
j["skills"] = {"c++", "python", "sql"};            // 数组
j["address"]["city"] = "beijing";                  // 嵌套对象，自动创建中间层
// 更地道的写法：一条初始化列表全搞定
json profile = {
    {"name", "bob"},
    {"age", 25},
    {"skills", {"c++", "python", "sql"}},
    {"address", {{"city", "beijing"}, {"zip", "100000"}}},
    {"married", false},
    {"salary", nullptr}                            // null 也支持
};

json wrong = {{"a", 1}};        // 这是 object: {"a":1}
json right = json::array({{"a", 1}});  // 这才是数组: [{"a":1}]

json arr = json::array();      // 空数组
arr.push_back(1);
arr.push_back(2);
arr.emplace_back("three");     // 就地构造，避免拷贝
// 或者直接数组初始化
json arr2 = {1, 2, 3, 4, 5};

std::vector<std::uint8_t> blob = {0x01, 0x02, 0xff};
json j;
j["data"] = json::binary(blob);           // 存成 binary 扩展
// 取回
auto bin = j["data"].get_binary();

json j = {{"name", "alice"}, {"age", 30}, {"hobby", {"reading", "swimming"}}};
// 姿势一：operator[] —— 最方便，但有两个坑！
auto name1 = j["name"];            // ✅ 能取到
auto none1 = j["salary"];          // ❌ 不存在时不会报错，而是【自动创建一个 null 成员】！
                                   //    也就是说 j 现在多了个 "salary": null
// 姿势二：.at() —— 安全，键不存在抛 out_of_range 异常
try {
    auto age = j.at("age");
} catch (const json::out_of_range& e) {
    std::cout << "键不存在: " << e.what() << std::endl;
}
// 姿势三：.find() —— 先查再取，不抛异常也不改结构
auto it = j.find("hobby");
if (it != j.end()) {
    auto hobby = *it;              // 找到了，取值
}

// 写法一：items() + 结构化绑定（c++17）
for (const auto& [key, value] : j.items()) {
    std::cout << "key=" << key << ", value=" << value << std::endl;
}
// 写法二：传统迭代器
for (auto it = j.begin(); it != j.end(); ++it) {
    std::cout << it.key() << " => " << it.value() << std::endl;
}
// 遍历数组
json arr = {10, 20, 30};
for (const auto& item : arr) {
    std::cout << item << std::endl;
}
// 带下标遍历数组（c++20 甚至可以直接用带下标的 range-for 语法糖）
for (auto [idx, item] : arr.items()) {      // items() 对数组也有效！
    std::cout << idx << ": " << item << std::endl;
}

json j = {{"a", 1}, {"b", 2}, {"c", 3}};
j["b"] = 20;                // 修改：b 变成 20
j["d"] = 4;                 // 新增：d=4
j.erase("a");               // 删除：删掉键 a
j.clear();                  // 清空所有

json base = {{"name", "tom"}, {"age", 18}};
json patch = {{"age", 19}, {"city", "shanghai"}};
base.update(patch);         // 递归合并：age 被覆盖为 19，city 被加入

// vector <-> json 数组
std::vector<int> v = {1, 2, 3};
json jv = v;                            // [1,2,3]
auto v2 = jv.get<std::vector<int>>();   // 转回 vector
// map <-> json 对象（注意：key 必须是 string 类型）
std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}};
json jm = m;                            // {"apple":1,"banana":2}
auto m2 = jm.get<std::map<std::string, int>>();
// 更复杂的嵌套容器也没问题
std::vector<std::map<std::string, double>> data = {{{"x", 1.5}, {"y", 2.5}}, {{"x", 3.5}}};
json jd = data;                         // 直接整棵转
auto back = jd.get<decltype(data)>();   // 再整棵转回来

json j = "123";    // 注意这是字符串
try {
    int n = j.get<int>();   // 抛 type_error！字符串不会自动转数字
} catch (const json::type_error& e) {
    std::cout << "类型不匹配: " << e.what() << std::endl;
}
// 正确姿势：先转 string 再手动 std::stoi
int n = std::stoi(j.get<std::string>());

struct point {
    int x, y;
};
// 序列化：对象 -> json
void to_json(json& j, const point& p) {
    j = json{{"x", p.x}, {"y", p.y}};
}
// 反序列化：json -> 对象
void from_json(const json& j, point& p) {
    j.at("x").get_to(p.x);
    j.at("y").get_to(p.y);
}
int main() {
    point p{3, 4};
    json j = p;                    // 自动调用 to_json
    std::cout << j.dump() << std::endl;   // {"x":3,"y":4}
    point p2 = j.get<point>();     // 自动调用 from_json
    std::cout << p2.x << "," << p2.y << std::endl;
}

try {
    auto j = json::parse(r"({"a": 1)");
} catch (const json::parse_error& e) {
    // 1. 解析失败：语法错误、非法 utf-8 等
    std::cout << "解析错误 byte " << e.byte << ": " << e.what() << std::endl;
} catch (const json::out_of_range& e) {
    // 2. at() 越界 / 键不存在
    std::cout << "越界: " << e.what() << std::endl;
} catch (const json::type_error& e) {
    // 3. 类型错误：get<t>() 类型不匹配、操作符用法错误
    std::cout << "类型错误: " << e.what() << std::endl;
} catch (const json::other_error& e) {
    // 4. 其他错误
    std::cout << "其他: " << e.what() << std::endl;
} catch (const std::exception& e) {
    // 5. 兜底
    std::cout << "通用异常: " << e.what() << std::endl;
}

// 技巧 1：减少深拷贝 —— 用引用而不是值
// ❌ 慢：每次取值都拷贝整个子对象
json copied = j["big_object"];           // 深拷贝！如果 big_object 很大，非常伤
// ✅ 快：用引用只读访问
const json& ref = j["big_object"];       // 零拷贝
// 技巧 2：批量取值用 get_to，避免多次类型转换开销
int x = 0, y = 0;
j["point"]["x"].get_to(x);
j["point"]["y"].get_to(y);               // get_to 直接写入变量，省一次临时对象
// 技巧 3：重复解析同一字符串时，用 sax 接口（流式回调，不建整棵树）
// 适合"从超大 json 里只挑几个字段"的场景
struct myhandler : json::parser_callback_t {
    bool operator()(int depth, json::parse_event_t event, json& parsed) override {
        // 每遇到一个 key/value 就会回调，可以在这里挑需要的字段
        return true;   // 返回 false 可以提前终止解析
    }
};
json::parser_callback_t cb = myhandler();
// json::parse(str, cb, true, true);   // 传入回调开启 sax 模式
// 技巧 4：对大 json 提前 reserve 容量（v3.11+ 支持）
json::parser_callback_t cb2 = nullptr;
// 解析前如果知道大概大小，可调用 j.reserve(n) 减少重新分配
// 技巧 5：终极优化 —— 换用 rapidjson（见下文对比表）
// 如果解析吞吐量是硬指标，nlohmann/json 不是最快的，但它通常是"足够快"的。