C++ JSON处理实战：nlohmann/json库从入门到精通-尧图网络科技

1. 项目概述：为什么C++开发者需要关注JSON处理？

在C++项目里，处理配置文件、网络API响应或者数据序列化时，JSON格式几乎成了绕不开的一环。早些年，C++标准库对JSON的支持几乎为零，大家要么手写解析器，要么用一些笨重的第三方库，代码写起来又长又容易出错。直到nlohmann/json这个库的出现，情况才彻底改变。我第一次在项目里用它替换掉一堆手写的rapidjson代码时，感觉就像从手动挡换成了自动挡——代码量直接砍半，可读性还大幅提升。

简单来说，nlohmann/json是一个用现代C++（C++11及以上）写的单头文件JSON库。它的核心设计哲学是“直观”，让你操作JSON对象的感觉就像在操作原生的C++容器（比如std::map,std::vector）一样自然。无论是从字符串解析JSON，还是将内存中的结构体序列化成JSON字符串，它都提供了极其简洁的API。对于C++开发者，尤其是需要频繁进行数据交换的Web后端、游戏开发、物联网设备或工具链开发者来说，掌握这个库能极大提升开发效率和代码质量。

2. 环境准备与库的集成

2.1 获取nlohmann/json库

集成nlohmann/json简单到令人发指，这也是它广受欢迎的重要原因。官方推荐的方式是通过包管理器，比如vcpkg或Conan。但最直接、最通用的方法，还是直接下载其单头文件。

你可以从它的GitHub仓库（github.com/nlohmann/json）的Release页面下载名为json.hpp的文件。把这个文件直接放到你的项目目录里，然后在源代码中#include它就行了。没有复杂的链接步骤，没有额外的依赖，真正的“开箱即用”。

注意：虽然直接包含头文件很方便，但在大型项目中，我建议还是使用包管理器。以vcpkg为例，安装命令是vcpkg install nlohmann-json，然后在你的CMakeLists.txt里用find_package(nlohmann_json REQUIRED)和target_link_libraries(your_target PRIVATE nlohmann_json::nlohmann_json)来关联。这样做的好处是版本管理清晰，并且能更好地与项目的构建系统集成。

2.2 编译器与标准要求

这个库严重依赖现代C++特性，因此要求编译器必须支持C++11或更高标准。主流的GCC (>= 4.9)、Clang (>= 3.4) 和 MSVC (>= VS2015) 都完全没问题。

在你的CMakeLists.txt中，务必显式地设置C++标准，这是一个好习惯，能避免很多因编译器默认标准不同导致的奇怪问题：

cmake_minimum_required(VERSION 3.10) project(MyJsonProject) set(CMAKE_CXX_STANDARD 11) # 或14、17、20，根据你的需求 set(CMAKE_CXX_STANDARD_REQUIRED ON) add_executable(main main.cpp) # 如果用了vcpkg，加上find_package和target_link_libraries

在源代码文件里，包含头文件之后，你就可以开始使用了：

#include “json.hpp” // 如果头文件在项目目录 // 或者 #include <nlohmann/json.hpp> // 如果通过包管理器安装 // 为了方便，通常会给命名空间起个别名 using json = nlohmann::json;

3. 核心操作：从零开始玩转JSON数据

3.1 创建JSON对象

nlohmann/json库的核心类是json。创建一个JSON对象非常直观，它支持多种初始化方式。

最直接的方式是使用C++11的初始化列表语法，这让你能一眼看出JSON的结构：

json j; j[“pi”] = 3.141; j[“happy”] = true; j[“name”] = “Niels”; j[“nothing”] = nullptr; j[“answer”][“everything”] = 42; // 嵌套对象 j[“list”] = { 1, 0, 2 }; // 数组 j[“object”] = { {“currency”, “USD”}, {“value”, 42.99} }; // 对象数组 // 或者一步到位 json j2 = { {“pi”, 3.141}, {“happy”, true}, {“name”, “Niels”}, {“nothing”, nullptr}, {“answer”, { {“everything”, 42} }}, {“list”, {1, 0, 2}}, {“object”, { {“currency”, “USD”}, {“value”, 42.99} }} };

这两种方式创建的j和j2是完全等价的。我更喜欢第一种渐进式构建的方式，在动态生成复杂JSON时逻辑更清晰。

3.2 解析与序列化：数据进出之道

这是库最常用的功能：把字符串变成内存对象，或者把内存对象变成字符串。

从字符串解析（反序列化）：

std::string json_string = R“( { “name”: “Alice”, “age”: 30, “courses”: [“Math”, “Physics”] } )”; try { json j = json::parse(json_string); std::cout << “解析成功！” << std::endl; } catch (json::parse_error& e) { std::cerr << “解析JSON失败: ” << e.what() << std::endl; std::cerr << “错误位置: ” << e.byte << std::endl; }

这里用了C++11的原始字符串字面量（R“()”），避免在字符串里到处转义引号，写起来清爽很多。一定要用try-catch包裹parse操作，因为输入的字符串可能来自不可靠的网络或文件，格式错误是常有的事。

序列化为字符串：

json j = {{“name”, “Bob”}, {“score”, 95.5}}; // 紧凑格式，用于网络传输或存储 std::string compact_string = j.dump(); // 输出：{“name”:”Bob”,”score”:95.5} // 美化格式，带缩进，用于调试或给人看 std::string pretty_string = j.dump(4); // 缩进4个空格 // 输出： // { // “name”: “Bob”, // “score”: 95.5 // }

dump()方法非常强大。参数4指定了缩进空格数。你还可以传入特殊参数，比如dump(-1, ‘ ‘, false, json::error_handler_t::ignore)来生成最紧凑且忽略UTF-8错误的格式，这在某些对空间和速度要求极高的场景下有用。

3.3 访问与修改数据

访问JSON数据有多种方式，各有优劣，用错了轻则效率低下，重则程序崩溃。

1. 键值访问（针对对象类型）：

json j = {{“name”, “Charlie”}, {“age”, 25}}; // 方式一：operator[] (不推荐用于读取，因为会创建键) std::string name1 = j[“name”]; // 如果“name”不存在，会创建一个null值！ int age1 = j[“age”]; // 方式二：at() 方法 (推荐，安全) try { std::string name2 = j.at(“name”); int age2 = j.at(“age”); } catch (json::out_of_range& e) { // 键不存在时会抛出异常 } // 方式三：value() 方法 (更安全，可提供默认值) std::string name3 = j.value(“name”, “Unknown”); // 如果“name”不存在，返回“Unknown” int age3 = j.value(“age”, 0);

实操心得：永远不要用operator[]来读取一个可能不存在的键！这是新手最容易踩的坑。j[“maybe_exist”]如果键不存在，它不会报错，而是会悄无声息地在JSON对象中插入一个“maybe_exist”: null的键值对。这会导致对象被意外修改，引发难以调试的BUG。读取时，优先使用at()（需要严格检查时）或value()（想要默认值时）。

2. 索引访问（针对数组类型）：

json j_array = {“apple”, “banana”, “cherry”}; // 类似std::vector std::string first = j_array[0]; // apple j_array[1] = “blueberry”; // 修改第二个元素 // 安全访问，带边界检查 try { std::string elem = j_array.at(5); // 会抛出out_of_range异常 } catch (json::out_of_range& e) { std::cout << “数组越界！” << std::endl; }

3. 迭代器访问（遍历）：

json j = {{“a”, 1}, {“b”, 2}, {“c”, 3}}; // 基于范围的for循环 (C++11) for (auto& element : j.items()) { std::cout << “key: ” << element.key() << “, value: ” << element.value() << std::endl; } // 或者直接遍历值（如果只关心值） for (auto& val : j) { std::cout << val << std::endl; } // 遍历JSON数组 json arr = {1, 2, 3}; for (auto& num : arr) { std::cout << num << std::endl; }

迭代器的方式在处理未知结构的JSON时特别有用，你可以动态地探查其内容。

3.4 类型检查与转换

JSON是动态类型的，但C++是静态类型的。因此，在从json对象提取值到C++原生类型（如int,std::string）时，必须进行类型检查或转换。

json j = {{“number”, 42}, {“text”, “hello”}, {“flag”, true}}; // 方法一：显式类型检查 + 转换 if (j[“number”].is_number_integer()) { int num = j[“number”]; // 隐式转换，库提供了转换运算符 // 或者显式转换 int num2 = j[“number”].get<int>(); } // 方法二：使用 get() 并捕获异常（更简洁） try { std::string text = j.at(“text”).get<std::string>(); bool flag = j.at(“flag”).get<bool>(); } catch (json::type_error& e) { std::cerr << “类型错误: ” << e.what() << std::endl; } // 方法三：使用 get_to() (C++17后推荐，用于自定义类型，见后文)

is_xxx()系列方法（is_object(),is_array(),is_string(),is_number(),is_boolean(),is_null()）是进行运行时类型判断的工具。在解析外部数据时，养成先判断类型再操作的习惯，能让程序更健壮。

4. 高级特性与实战技巧

4.1 JSON与STL容器的无缝转换

这是nlohmann/json库的一大亮点，它让你能在JSON和C++标准容器之间轻松转换，几乎不需要写胶水代码。

从STL容器到JSON：

std::vector<int> vec = {1, 2, 3, 4, 5}; std::map<std::string, double> scores = {{“Alice”, 95.5}, {“Bob”, 87.0}}; json j_vec = vec; // 自动转换为JSON数组: [1,2,3,4,5] json j_map = scores; // 自动转换为JSON对象: {“Alice”:95.5, “Bob”:87.0} // 反过来也一样 auto vec_back = j_vec.get<std::vector<int>>(); auto map_back = j_map.get<std::map<std::string, double>>();

这种隐式转换的魔法是通过模板和特化实现的。对于std::vector,std::list,std::array这类序列式容器，库会自动将其处理为JSON数组；对于std::map,std::unordered_map这类关联式容器，则自动处理为JSON对象。

4.2 自定义类型序列化（核心进阶）

在实际项目中，我们操作的都是具体的业务类（如User,Product），而不是原始的map或vector。nlohmann/json提供了两种优雅的方式将自定义类型与JSON相互转换。

方法一：使用nlohmann_json宏（最简单）在C++17及以上，你可以为你自定义的struct或class添加一个简单的宏NLOHMANN_DEFINE_TYPE_INTRUSIVE或NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE。

#include “json.hpp” using json = nlohmann::json; struct Person { std::string name; int age; std::vector<std::string> hobbies; }; // 在全局命名空间为Person定义JSON序列化（非侵入式） NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Person, name, age, hobbies) int main() { Person p{“David”, 28, {“Reading”, “Hiking”}}; // 自动转换 json j = p; std::cout << j.dump(4) << std::endl; // 输出： // { // “age”: 28, // “hobbies”: [“Reading”, “Hiking”], // “name”: “David” // } // 从JSON自动还原 auto p2 = j.get<Person>(); }

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE要求你的类成员是公有的（public）。如果成员是私有的，或者你想更精细地控制序列化过程，就需要用侵入式宏NLOHMANN_DEFINE_TYPE_INTRUSIVE，并把它放在类的定义内部。

方法二：特化nlohmann::adl_serializer（最灵活）这是更传统、也更强大的方法，允许你完全控制序列化和反序列化的逻辑。你需要特化一个叫adl_serializer的模板类。

namespace nlohmann { template <> struct adl_serializer<Person> { // 序列化：Person -> json static void to_json(json& j, const Person& p) { j = json{{“name”, p.name}, {“age”, p.age}, {“hobbies”, p.hobbies}}; // 你可以在这里添加任何自定义逻辑，比如计算派生字段 j[“is_adult”] = (p.age >= 18); } // 反序列化：json -> Person static void from_json(const json& j, Person& p) { j.at(“name”).get_to(p.name); j.at(“age”).get_to(p.age); j.at(“hobbies”).get_to(p.hobbies); // 你可以在这里处理版本兼容性，或者忽略某些字段 } }; }

这种方式代码量稍多，但胜在绝对的控制权。例如，你的JSON字段名和类成员名不一样（比如JSON里叫”user_name”，类里叫name），或者你需要根据旧版JSON数据格式进行升级时，就只能用这种方法。

注意事项：小心循环引用！如果你的类A包含指向类B的指针，类B又包含指向类A的指针，直接序列化会导致无限递归。你需要手动处理这种复杂关系，比如序列化时只存ID，而不是整个对象。

4.3 高效遍历与查询

对于大型或嵌套很深的JSON文档，直接访问路径可能不够高效或不够灵活。库提供了json_pointer和迭代器来应对复杂场景。

使用json_pointer： JSON Pointer是一种标准的字符串表示法（RFC 6901），用于指向JSON文档中的特定位置。

json j = { {“foo”, {“bar”, “baz”}}, {“”, 0}, {“a/b”, 1}, {“c%d”, 2}, {“e^f”, 3}, {“g|h”, 4}, {“i\\j”, 5}, {“k\”l”, 6}, {“ “, 7}, {“m~n”, 8} }; // 使用json_pointer访问 auto& bar = j[json::json_pointer(“/foo/1”)]; // 访问 “baz” std::cout << bar.get<std::string>() << std::endl; // 输出: baz // 它自动处理了路径中的特殊字符转义 auto& value = j[json::json_pointer(“/c%d”)]; // 正确访问到键为“c%d”的值

这在处理动态生成的、路径不确定的JSON时非常有用，比如根据用户输入查询某个嵌套很深的值。

使用find和contains：

json j = {{“name”, “Eve”}, {“age”, 32}}; // 检查键是否存在（比用at()捕获异常更高效） if (j.contains(“name”)) { // 键存在 } // 查找迭代器 auto it = j.find(“age”); if (it != j.end()) { std::cout << “找到age: ” << it.value() << std::endl; }

5. 性能调优与最佳实践

5.1 理解内存管理与解析性能

nlohmann/json默认使用std分配器来管理内存。对于绝大多数应用，这已经足够。但如果你在处理非常大的JSON文件（几十MB甚至上百MB），或者在高频解析的场景下，就需要关注性能。

1. 使用json::parse的重载版本：标准的json::parse(json_string)会先复制一遍字符串。如果你已经有一个字符串，并且确定在解析期间它的生命周期是稳定的，可以使用接受迭代器版本的parse，避免复制。

std::string big_json_string = …; // 一个非常大的JSON字符串 json j = json::parse(big_json_string.begin(), big_json_string.end());

2. 使用sax接口处理巨型JSON：如果你只需要从一个大JSON文件中提取少量数据，完全将其解析到内存中会非常浪费。这时可以使用SAX（Simple API for XML/JSON）风格的解析器。你需要定义一个事件处理器，库会在解析时回调你的函数。

struct sax_handler { bool null() { return true; } bool boolean(bool val) { return true; } bool number_integer(number_integer_t val) { return true; } bool number_unsigned(number_unsigned_t val) { return true; } bool number_float(number_float_t val, const string_t& s) { return true; } bool string(string_t& val) { // 例如，只处理特定的字符串值 if (val == “target_value”) { // 做点什么 } return true; } bool start_object(std::size_t elements) { return true; } bool end_object() { return true; } bool start_array(std::size_t elements) { return true; } bool end_array() { return true; } bool key(string_t& val) { // 例如，只关心特定的键 if (val == “target_key”) { m_in_target = true; } return true; } bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) { return false; } bool m_in_target = false; }; sax_handler handler; json::sax_parse(big_json_string, &handler);

SAX接口是流式的，它不会在内存中构建完整的DOM树，因此内存消耗是常数级的，非常适合处理日志文件、网络流等场景。

5.2 避免常见的性能陷阱

不要频繁序列化/反序列化：如果一段数据需要在多个函数间传递，尽量传递json对象的引用或指针，而不是反复进行dump()和parse()。字符串操作的成本很高。
谨慎使用operator[]进行读取：如前所述，它会创建不存在的键。在循环或高频路径中使用，会导致JSON对象不断膨胀，影响性能和内存。
对于已知结构的JSON，优先使用get<T>()：相比隐式转换，get<T>()在调试版本中会有更多的类型安全检查，但在发布版本中，两者性能差异很小。显式调用get<T>()能让代码意图更清晰。

5.3 错误处理与调试

健壮的程序必须处理错误。nlohmann/json主要抛出两种异常：

json::parse_error：在parse()时，输入的字符串不是合法的JSON。
json::type_error：在类型转换时，JSON值的实际类型与请求的C++类型不匹配（比如试图把字符串get<int>()）。
json::out_of_range：访问不存在的键或数组越界时（使用at()方法）。

我的建议是，在解析外部输入时，一定要用try-catch包裹。在访问已知结构的数据时，可以结合使用contains()和is_xxx()进行防御性编程。

调试时，dump()方法是你最好的朋友。在VS Code、CLion等IDE中设置条件断点，或者在代码中插入std::cout << some_json.dump(4) << std::endl;，可以清晰地看到任何时刻JSON对象的状态。

6. 实战案例：一个简单的配置文件管理器

让我们用一个完整的例子来串联以上知识点。假设我们要开发一个游戏，需要读取一个JSON格式的配置文件，其中包含玩家设置、图形选项等。

config.json:

{ “player”: { “name”: “Hero”, “level”: 10, “inventory”: [“sword”, “shield”, “potion”] }, “graphics”: { “resolution”: {“width”: 1920, “height”: 1080}, “fullscreen”: true, “shadow_quality”: “high” }, “sound”: { “volume”: 75, “mute”: false } }

C++代码 (config_manager.cpp):

#include <iostream> #include <fstream> #include “json.hpp” using json = nlohmann::json; using namespace std; // 定义配置对应的结构体 struct Resolution { int width; int height; NLOHMANN_DEFINE_TYPE_INTRUSIVE(Resolution, width, height) // 侵入式宏，放在结构体内部 }; struct GraphicsConfig { Resolution resolution; bool fullscreen; std::string shadow_quality; NLOHMANN_DEFINE_TYPE_INTRUSIVE(GraphicsConfig, resolution, fullscreen, shadow_quality) }; struct SoundConfig { int volume; bool mute; NLOHMANN_DEFINE_TYPE_INTRUSIVE(SoundConfig, volume, mute) }; struct PlayerConfig { std::string name; int level; std::vector<std::string> inventory; NLOHMANN_DEFINE_TYPE_INTRUSIVE(PlayerConfig, name, level, inventory) }; struct GameConfig { PlayerConfig player; GraphicsConfig graphics; SoundConfig sound; NLOHMANN_DEFINE_TYPE_INTRUSIVE(GameConfig, player, graphics, sound) }; class ConfigManager { private: GameConfig m_config; std::string m_filepath; public: ConfigManager(const std::string& filepath) : m_filepath(filepath) {} bool load() { try { std::ifstream file(m_filepath); if (!file.is_open()) { std::cerr << “无法打开配置文件: ” << m_filepath << std::endl; return false; } json j; file >> j; // 直接从文件流解析JSON，比先读成string再parse更高效 m_config = j.get<GameConfig>(); // 一键反序列化到复杂结构体 std::cout << “配置文件加载成功。玩家: ” << m_config.player.name << std::endl; return true; } catch (const json::parse_error& e) { std::cerr << “JSON解析错误: ” << e.what() << “ at byte ” << e.byte << std::endl; } catch (const json::type_error& e) { std::cerr << “数据类型错误: ” << e.what() << std::endl; } catch (const std::exception& e) { std::cerr << “未知错误: ” << e.what() << std::endl; } return false; } bool save() { try { json j = m_config; // 一键序列化 std::ofstream file(m_filepath); file << j.dump(4); // 美化输出，方便人工阅读 std::cout << “配置文件保存成功。” << std::endl; return true; } catch (const std::exception& e) { std::cerr << “保存配置失败: ” << e.what() << std::endl; return false; } } // 提供配置的访问和修改接口 GameConfig& getConfig() { return m_config; } const GameConfig& getConfig() const { return m_config; } // 示例：动态修改配置项 void setPlayerName(const std::string& name) { m_config.player.name = name; } void addInventoryItem(const std::string& item) { m_config.player.inventory.push_back(item); } }; int main() { ConfigManager configMgr(“config.json”); if (!configMgr.load()) { std::cerr << “加载初始配置失败，使用默认值。” << std::endl; // 可以在这里初始化一个默认的m_config } // 修改一些配置 auto& config = configMgr.getConfig(); config.graphics.resolution.width = 2560; config.graphics.resolution.height = 1440; configMgr.addInventoryItem(“magic_ring”); // 保存回文件 configMgr.save(); // 快速查看某个嵌套值（使用json_pointer） json j = configMgr.getConfig(); // 结构体隐式转换为json std::cout << “库存第一项: ” << j[json::json_pointer(“/player/inventory/0”)].get<std::string>() << std::endl; return 0; }

这个案例展示了如何将nlohmann/json用于一个实际的、结构清晰的场景。通过定义与JSON结构对应的C++结构体，并使用宏实现自动序列化，我们得到了类型安全、易于维护的代码。ConfigManager类封装了加载、保存和访问逻辑，是项目中处理配置文件的典型模式。

7. 常见问题与排查技巧实录

在实际使用中，你肯定会遇到一些坑。下面是我和同事们踩过之后总结出来的经验。

问题1：解析失败，错误信息是parse error at line 1, column 1: syntax error while parsing value - invalid literal; last read: ‘<‘

原因：这几乎总是意味着你尝试解析的不是JSON文本，而可能是HTML或其它内容。常见于从网络API获取数据时，没有检查HTTP响应头Content-Type，服务器可能返回了一个错误页面（HTML）。
排查：在调用parse()之前，先打印或记录一下原始字符串的前几十个字符。如果是<html>…，那就说明你请求的URL不对，或者服务器端出错了。

问题2：访问键时程序崩溃，但键明明在JSON里。

原因：大概率是大小写问题、空格问题或者编码问题。JSON的键是大小写敏感的。“UserName”和“username”是两个不同的键。另外，有些不可见的Unicode字符（如零宽空格）也可能导致键名看起来一样，但实际上不同。
排查：
1. 使用j.dump()输出整个JSON对象，仔细核对键名。
2. 使用for (auto& el : j.items()) { std::cout << el.key() << std::endl; }遍历所有键，看看实际有哪些。
3. 考虑在解析前对字符串做标准化处理（如去除首尾空格，但需谨慎，可能破坏数据）。

问题3：get<T>()抛出type_error，但我觉得类型是对的。

原因：JSON数字类型和C++数字类型并非严格一一对应。JSON只有一种“数字”类型，但C++有int,unsigned int,double,float等。库会尝试转换，但可能失败。例如，一个JSON数字3.14可以get<double>()，但不能get<int>()。同样，一个很大的整数（超过int32_t范围）在get<int>()时也可能溢出或报错。
排查：
1. 先用is_number_integer()或is_number_float()判断具体类型。
2. 对于不确定的数字，可以先get<json::number_float_t>（通常是double）或get<json::number_integer_t>（通常是int64_t），它们是库内部使用的宽类型。
3. 考虑使用get_to()，它结合了类型检查和转换。

问题4：序列化自定义对象时，某些字段丢失了。

原因：如果你使用NLOHMANN_DEFINE_TYPE_*宏，请检查宏的参数列表是否包含了所有你想序列化的成员变量。漏写一个，它就不会被序列化。
排查：确保宏调用紧跟在类定义之后，并且所有要序列化的公有成员变量都列在了宏的参数里。对于私有成员，必须使用侵入式宏NLOHMANN_DEFINE_TYPE_INTRUSIVE，并确保为这个类特化了adl_serializer或者提供了to_json/from_json函数。

问题5：处理包含中文字符的JSON时，显示乱码。

原因：nlohmann/json库完全支持UTF-8。乱码通常发生在输入/输出环节，而不是库本身。比如，你的源代码文件保存的编码不是UTF-8，或者控制台/终端不支持UTF-8输出。
排查：
1. 确保你的C++源代码文件以UTF-8编码保存（在VS Code、CLion等编辑器中可以设置）。
2. 在Windows命令行（cmd）默认是GBK编码，直接输出UTF-8字符串会乱码。可以尝试在程序开始时设置本地化，或者使用能处理UTF-8的终端（如Windows Terminal）。
3. 将字符串输出到文件，然后用支持UTF-8的文本编辑器（如VS Code、Notepad++）打开检查。

性能问题：解析一个10MB的JSON文件太慢了。

排查与优化：
1. 衡量：先用工具（如Linux的time命令或C++的<chrono>库）确定瓶颈确实在JSON解析，而不是文件IO。
2. 换用SAX接口：如果你只需要文件中的一小部分数据，SAX解析器可以避免将整个DOM树载入内存，速度会快很多，内存占用也极低。
3. 检查编译器优化：确保在Release模式下编译，并开启优化（如GCC/Clang的-O2或-O3，MSVC的/O2）。
4. 考虑替代方案：如果经过 profiling 确认nlohmann/json的DOM解析确实是瓶颈，并且你的场景对性能有极致要求，可以考虑其他更注重性能的库，如simdjson（它使用SIMD指令加速解析）。但simdjson的API与nlohmann/json不同，通常更底层一些。nlohmann/json的优势在于其无与伦比的易用性和与C++标准库的契合度，在大多数场景下，其性能是完全足够的。