nlohmann::json从入门到精通

nlohmann简介

nlohmann的起源与发展

与其他c++ json库的比较

nlohmann的架构与设计理

nlohmann在C++中的应用

nlohmann的安装与引用

基本语法

高级语法

一、nlohmann简介

1、nlohmann的起源与发展

nlohmann/json.hpp 的起源可以追溯到其创建者 Niels Lohmann 的个人需求。 Niels Lohmann 在使用其他 C++ JSON 库时，发现这些库要么过于复杂，要么性能不佳，要么使用起来不够直观。因此，他决定自己开发一个满足这些需求的 JSON 库。经过一段时间的开发和优化，nlohmann/json.hpp 逐渐成为了一个功能全面、性能卓越的 JSON 库。它支持 C++11 及更高版本的标准，充分利用了现代 C++ 的特性，如范围 for循环、结构化绑定等，使得操作 JSON 数据变得更加简单和直观。随着其在 GitHub 上的开源和发布，nlohmann/json.hpp 迅速获得了广泛的关注和认可。大量的用户和贡献者加入了这个项目，为其提供了丰富的功能和稳定的性能。如今， nlohmann/json.hpp 已经成为 C++ 社区中非常受欢迎的 JSON 库之一。

2、与其他c++ json库的比较

与其他 C++ JSON 库相比，nlohmann/json.hpp 有以下显著优势：易用性：nlohmann/json.hpp 提供了直观且易于使用的 API，使得开发者能够快速地理解和使用它。与其他库相比，它减少了学习成本，提高了开发效率。高性能：在解析和生成 JSON 数据方面，nlohmann/json.hpp 表现出色。它的性能优于许多其他 C++ JSON 库，使得在处理大量 JSON 数据时更加高效。单文件库：nlohmann/json.hpp 是一个单文件库，无需额外的链接或构建步骤。这使得它非常容易集成到任何 C++ 项目中，无论项目大小如何。

3、nlohmann的架构与设计理念

nlohmann/json.hpp 的架构和设计理念主要体现在以下几个方面：简洁性：库的设计力求简洁明了，避免不必要的复杂性和冗余。这使得代码易于阅读和维护，同时也降低了出错的可能性。面向对象：库采用了面向对象的设计思想，将 JSON 数据表示为对象或数组。这使得开发者能够以更直观的方式操作 JSON 数据，提高了代码的可读性和可维护性。灵活性：库提供了多种解析和生成 JSON 数据的方式，包括基于 SAX 和 DOM 的解析模式。这使得开发者能够根据自己的需求选择最合适的解析方式。安全性：库在设计时充分考虑了安全性因素，避免了潜在的安全漏洞和错误。它提供了严格的类型检查和错误处理机制，确保了在处理 JSON 数据时的安全性和可靠性。

SAX是一种基于事件的解析方式。解析器在读取JSON/XML文档时，每当遇到特定的元素（如开始标签、结束标签、字符数据等），就会触发相应的事件。开发者需要编写事件处理函数来响应这些事件。SAX解析器不需要将整个文档加载到内存中，因此它非常适合处理大型JSON/XML文档。 DOM是一种基于树的解析方式。解析器将整个JSON/XML文档加载到内存中，并构建出一个与文档结构对应的树形结构（DOM树）。开发者可以通过遍历DOM树来访问和操作JSON/XML数据。由于DOM需要将整个文档加载到内存中，因此它更适合处理较小的JSON/XML文档

 //SAX解析
struct MySax {
    bool null() {
        // 处理 null 值
        return true;
    }
 
    bool boolean(bool val) {
        // 处理 boolean 值
        return true;
    }
 
    bool number_integer(json::number_integer_t val) {
        // 处理整数
        return true;
    }
 
    bool number_unsigned(json::number_unsigned_t val) {
        // 处理无符号整数
        return true;
    }
 
    bool number_float(double val, const std::string& /*unused*/) {
        // 处理浮点数
        return true;
    }
 
    bool string(const std::string& val) {
        // 处理字符串
        std::cout << current_key << ": " << val << std::endl;
        return true;
    }
 
    bool start_object(size_t len) {
        // 处理对象开始
        return true;
    }
 
    bool key(const std::string& val) {
        // 处理对象的键
        current_key = val;
        return true;
    }
 
    bool end_object() {
        // 处理对象结束
        return true;
    }
 
    bool start_array(size_t len) {
        // 处理数组开始
        std::cout<<"array start"<<std::endl;
        return true;
    }
 
    bool end_array() {
        // 处理数组结束
        std::cout<<"array end"<<std::endl;
        return true;
    }
 
    bool parse_error(size_t len, std::string str, exception e)
    {
        return true;
    }
 
    bool binary(const std::vector<std::uint8_t>& data) {
        // 处理二进制数据
        // 例如，可以将数据转换为字符串或进行其他操作
        return true;
    }
 
private:
    std::string current_key; // 存储当前处理的键
    std::list<std::string> m_array;
};
 
#include "nlohmann/json.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
 
void main()
{
    std::string jsonStr = R"(
           {
               "name": "John",
               "age": 30,
               "city": "New York",
               "skills": ["C++", "Java", "Python"]
           }
       )";
    std::istringstream iss(jsonStr);
    MySax sax_handler;
    bool success = nlohmann::json::sax_parse(iss, &sax_handler);
    if (!success) {
       std::cerr << "SAX parsing failed!" << std::endl;
    } else {
       std::cout << "SAX parsing successful!" << std::endl;
    }
 
}复制

 //DOM解析
std::string jsonStr = R"(
           {
               "name": "John",
               "age": 30,
               "city": "New York",
               "skills": ["C++", "Java", "Python"]
           }
       )";
 
nlohmann::json j = nlohmann::json::parse(jsonStr);复制

 //类型检查
nlohmann::json j = nlohmann::json::parse(jsonStr);
    if(j.contains("age") && j.at("age").is_number_integer()){
        int _age = j.at("age").get<int>();
        cout<<"age:"<<_age<<endl;
    }
//错误处理
    try {
        int _age = j.at("age").get<bool>();
        cout<<"age1:"<<_age<<endl;
    } catch (json::exception& e) {
        cout<<e.what()<<endl;
    }复制

二、nlohmann在C++中的应用

1、nlohmann的安装与引用

安装nlohmann/json.hpp非常简单，只需将json.hpp头文件复制到项目的适当位置即可。在C++源文件中，通过包含#include "nlohmann/json.hpp"来引用该库。

2、基本语法

 //创建JSON对象
//可以使用nlohmann::json类来创建JSON对象，通过键值对的方式添加数据。
#include "nlohmann/json.hpp"  
  
int main() {  
    nlohmann::json j;  
    j["name"] = "John Doe";  
    j["age"] = 30;  
    j["is_student"] = false;  
    return 0;  
}
 
 
//解析JSON字符串
//nlohmann::json类还提供了从JSON字符串解析数据的功能。
int main() {  
    std::string json_str = R"({"name": "Jane Smith", "age": 25, "is_student": true})";  
    nlohmann::json j = nlohmann::json::parse(json_str);  
  
    std::cout << "Name: " << j["name"] << std::endl;  
    std::cout << "Age: " << j["age"] << std::endl;  
    std::cout << "Is Student: " << j["is_student"].get<bool>() << std::endl;  
    return 0;  
}
 
//生成JSON字符串
//可以使用dump()方法将nlohmann::json对象转换为JSON字符串。
int main() {  
    nlohmann::json j;  
    j["name"] = "Alice";  
    j["hobbies"] = nlohmann::json::array({ "reading", "painting", "swimming" });  
  
    std::string json_str = j.dump(4); // 4表示缩进空格数  
    std::cout << json_str << std::endl;  
  
    return 0;  
}
 复制

3、高级语法

 //遍历JSON对象 
 nlohmann::json j = {  
        {"name", "Bob"},  
        {"age", 28},  
        {"address", {  
            {"street", "123 Main St"},  
            {"city", "New York"},  
            {"state", "NY"}  
        }}  
 
//结构化绑定
    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 << "Key: " << it.key() << ", Value: " << it.value() << std::endl;
    }
//遍历值
    for (const auto& value : j) {
        std::cout << "value: " << value<<std::endl;
    }    
 
//    for(const auto& [key, value] : j.items()) {
//        std::cout << "Key: " << key << ", Value: " << value << std::endl;
//        if (value.is_object()) {
//            for (const auto& [uuid, board] : value.items()) {
//                std::cout << "  Board UUID: " << uuid << std::endl;
//                for (const auto& [board_key, board_value] : board.items()) {
//                    std::cout << "    " << board_key << ": " << board_value << std::endl;
//                }
//            }
//        }
//    }
 
//    for (const auto& item : j.items()) {
//        std::cout << "Key: " << item.key() << ", Value: " << item.value() << std::endl;
//        // 如果value是另一个json对象，递归遍历它
//        if (item.value().is_object()) {
//            for (const auto& inner_item : item.value().items()) {
//                std::cout << "  Inner Key: " << inner_item.key() << ", Inner Value: " << inner_item.value() << std::endl;
//            }
//        }
//    }
 
 
 
 
//JSON数组操作
//nlohmann::json还支持JSON数组的操作，可以添加、删除和修改数组元素。
int main() {  
    nlohmann::json arr = nlohmann::json::array();  
    arr.push_back("Apple");  
    arr.push_back("Banana");  
    arr.push_back("Cherry");  
  
    arr[1] = "Blueberry"; // 修改数组中的元素  
    arr.pop_back(); // 删除数组中的最后一个元素  
    for (const auto& value : arr) {  
        std::cout << value << std::endl;  
    }  
    return 0;  
}复制

 序列化和反序列化
#include "nlohmann/json.hpp"
class TestA
{
public:
    TestA(){}
    TestA(int v1, string v2):i(v1),s(v2) {}
 
    int i;
    string s;
 
void to_json(nlohmann::json& j) const {
             j = nlohmann::json{{"i", i}, {"s", s}};
         }
void from_json(const nlohmann::json& j) {
         i = j["i"];
         s = j["s"];
     }
//或者使用下面的宏来序列化和反序列化
//NLOHMANN_DEFINE_TYPE_INTRUSIVE(TestA, i, s)
};
 
void main()
{
 
    std::string json_str = R"({
        "i": 1,
        "s": "str"
    })";
    json j1 = json::parse(json_str);
    TestA B;
    //反序列化
    B.from_json(j1);
    cout<<B.i<<B.s<<endl;
}复制

注意：

j.at("name").get_to(p.name) 和 p.name = j["name"] 都是将 JSON 对象中的指定字段值赋给结构体 xxx 中的成员变量 name。然而，它们之间存在一些区别：异常处理：j.at("name").get_to(p.name) 使用 at() 函数来获取指定字段的值，并将其赋给 p.name。如果 JSON 对象中不存在指定的字段，或者字段的值类型与 p.name 的类型不匹配，将抛出 json::out_of_range 或 json::type_error 异常。这使得您可以在出现错误时进行适当的异常处理。容错性：p.name = j["name"] 使用索引运算符 [] 来获取指定字段的值，并将其赋给 p.name。如果 JSON 对象中不存在指定的字段，或者字段的值类型与 p.name 的类型不匹配，将引发未定义的行为。这意味着您需要确保 JSON 对象中存在指定的字段，并且字段的值类型与 p.name 的类型匹配，否则可能导致程序崩溃或产生不正确的结果。因此，如果您希望在 JSON 对象中不存在指定字段或字段类型不匹配时进行异常处理，并且更加安全和可靠，请使用 j.at("name").get_to(p.name)。如果您确定 JSON 对象中存在指定字段，并且字段的值类型与 p.name 的类型匹配，可以使用 p.name = j["name"] 来简化代码。

nlohmann::json从入门到精通

nlohmann简介

nlohmann的起源与发展

与其他c++ json库的比较

nlohmann的架构与设计理

nlohmann在C++中的应用

nlohmann的安装与引用

基本语法

高级语法

Postman导出JSON文件轻松转换为HTML或Markdown

python requests编写 api接收json

前端-javaScript:jquery补充

java中Object和json相互转换的方式

Flutter Dart Macro 宏简化 JSON 序列化

中国地区 code.json文件

JSONObject 使用对比 hutool、alibaba

PG数据库的Jsonb全文检索查询

【开发工具】IntelliJ IDEA插件推荐：Json Helper——让JSON处理更高效

JSON 的常见格式总结

前端哥

运行npm error code ENOENTnpm error syscall opennpm error path C:\Users\ultra\Desktop\Vue-Project\pac

前端提高篇（102）：jQuery高级方法callbacks、deferred

解决npm install 报错 “npm err code 1“

【常见错误】npm ERR! code CERT_HAS_EXPIRED & errno CERT_HAS_EXPIRED

vue前端页面弹出红色报错遮罩层 Uncaught runtime errors:at handleError (webpack-internal:///./node_modules/webpack

npm ERR! code CERT_HAS_EXPIRED npm ERR! errno CERT_HAS_EXPIRED npm ERR! request to https://registry.

JQuery中的load()、$

《WEB前端框架开发技术》HTML5响应式旅游景区网站——榆林子州HTML CSS JavaScript (1)

基于Java SpringBoot Vue HTML5药店管理系统(源码 LW 调试文档讲解等)/药店管理软件/药店进销存系统/药店库存管理系统/药店销售系统/药品管理系统/药店收银系统

基于Java SpringBoot Vue HTML5宠物健康顾问系统(源码 LW 调试文档讲解等)/宠物健康/顾问系统/宠物护理/宠物医疗/宠物保健/宠物咨询/宠物医生/宠物健康管理/宠物健康服务

1
【Echarts系列】—— 实现电池图、3D立体圆形柱状图

2024-03-03 11:03:011001

2
CSS常用属性（文本属性）

2024-11-04 09:11:111000

3
TypeScript 中的 Number 类型，Number 类型的特性、常见操作和注意事项

2024-09-30 23:09:061000

4
CSS写代码使页面划分为左右两个区域

2024-09-09 00:09:071000

5
vue使用datav echarts

2024-09-06 00:09:381000

6
使用TweenMax.js和CSS3创建冰球运动员动画效果教程

2024-09-04 23:09:411000

7
使用CDN提高jQuery加载速度

2024-08-24 23:08:211000

8
小兔鲜儿网页首页制作黑马程序员前端基础项目自学笔记

2024-08-19 22:08:161000

9
《Vue》你的弹窗能拖动吗？Vue自定义指令实现可拖动弹窗

2024-08-19 22:08:121000

10
npm的使用

2024-08-18 00:08:131000

	//SAX解析
	struct MySax {
	bool null() {
	// 处理 null 值
	return true;
	}

	bool boolean(bool val) {
	// 处理 boolean 值
	return true;
	}

	bool number_integer(json::number_integer_t val) {
	// 处理整数
	return true;
	}

	bool number_unsigned(json::number_unsigned_t val) {
	// 处理无符号整数
	return true;
	}

	bool number_float(double val, const std::string& /unused/) {
	// 处理浮点数
	return true;
	}

	bool string(const std::string& val) {
	// 处理字符串
	std::cout << current_key << ": " << val << std::endl;
	return true;
	}

	bool start_object(size_t len) {
	// 处理对象开始
	return true;
	}

	bool key(const std::string& val) {
	// 处理对象的键
	current_key = val;
	return true;
	}

	bool end_object() {
	// 处理对象结束
	return true;
	}

	bool start_array(size_t len) {
	// 处理数组开始
	std::cout<<"array start"<<std::endl;
	return true;
	}

	bool end_array() {
	// 处理数组结束
	std::cout<<"array end"<<std::endl;
	return true;
	}

	bool parse_error(size_t len, std::string str, exception e)
	{
	return true;
	}

	bool binary(const std::vector<std::uint8_t>& data) {
	// 处理二进制数据
	// 例如，可以将数据转换为字符串或进行其他操作
	return true;
	}

	private:
	std::string current_key; // 存储当前处理的键
	std::list<std::string> m_array;
	};

	#include "nlohmann/json.hpp"
	#include <iostream>
	#include <fstream>
	#include <sstream>

	void main()
	{
	std::string jsonStr = R"(
	{
	"name": "John",
	"age": 30,
	"city": "New York",
	"skills": ["C++", "Java", "Python"]
	}
	)";
	std::istringstream iss(jsonStr);
	MySax sax_handler;
	bool success = nlohmann::json::sax_parse(iss, &sax_handler);
	if (!success) {
	std::cerr << "SAX parsing failed!" << std::endl;
	} else {
	std::cout << "SAX parsing successful!" << std::endl;
	}

	}

	//DOM解析
	std::string jsonStr = R"(
	{
	"name": "John",
	"age": 30,
	"city": "New York",
	"skills": ["C++", "Java", "Python"]
	}
	)";

	nlohmann::json j = nlohmann::json::parse(jsonStr);

	//类型检查
	nlohmann::json j = nlohmann::json::parse(jsonStr);
	if(j.contains("age") && j.at("age").is_number_integer()){
	int _age = j.at("age").get<int>();
	cout<<"age:"<<_age<<endl;
	}
	//错误处理
	try {
	int _age = j.at("age").get<bool>();
	cout<<"age1:"<<_age<<endl;
	} catch (json::exception& e) {
	cout<<e.what()<<endl;
	}

	//创建JSON对象
	//可以使用nlohmann::json类来创建JSON对象，通过键值对的方式添加数据。
	#include "nlohmann/json.hpp"

	int main() {
	nlohmann::json j;
	j["name"] = "John Doe";
	j["age"] = 30;
	j["is_student"] = false;
	return 0;
	}


	//解析JSON字符串
	//nlohmann::json类还提供了从JSON字符串解析数据的功能。
	int main() {
	std::string json_str = R"({"name": "Jane Smith", "age": 25, "is_student": true})";
	nlohmann::json j = nlohmann::json::parse(json_str);

	std::cout << "Name: " << j["name"] << std::endl;
	std::cout << "Age: " << j["age"] << std::endl;
	std::cout << "Is Student: " << j["is_student"].get<bool>() << std::endl;
	return 0;
	}

	//生成JSON字符串
	//可以使用dump()方法将nlohmann::json对象转换为JSON字符串。
	int main() {
	nlohmann::json j;
	j["name"] = "Alice";
	j["hobbies"] = nlohmann::json::array({ "reading", "painting", "swimming" });

	std::string json_str = j.dump(4); // 4表示缩进空格数
	std::cout << json_str << std::endl;

	return 0;
	}

	//遍历JSON对象
	nlohmann::json j = {
	{"name", "Bob"},
	{"age", 28},
	{"address", {
	{"street", "123 Main St"},
	{"city", "New York"},
	{"state", "NY"}
	}}

	//结构化绑定
	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 << "Key: " << it.key() << ", Value: " << it.value() << std::endl;
	}
	//遍历值
	for (const auto& value : j) {
	std::cout << "value: " << value<<std::endl;
	}

	// for(const auto& [key, value] : j.items()) {
	// std::cout << "Key: " << key << ", Value: " << value << std::endl;
	// if (value.is_object()) {
	// for (const auto& [uuid, board] : value.items()) {
	// std::cout << " Board UUID: " << uuid << std::endl;
	// for (const auto& [board_key, board_value] : board.items()) {
	// std::cout << " " << board_key << ": " << board_value << std::endl;
	// }
	// }
	// }
	// }

	// for (const auto& item : j.items()) {
	// std::cout << "Key: " << item.key() << ", Value: " << item.value() << std::endl;
	// // 如果value是另一个json对象，递归遍历它
	// if (item.value().is_object()) {
	// for (const auto& inner_item : item.value().items()) {
	// std::cout << " Inner Key: " << inner_item.key() << ", Inner Value: " << inner_item.value() << std::endl;
	// }
	// }
	// }




	//JSON数组操作
	//nlohmann::json还支持JSON数组的操作，可以添加、删除和修改数组元素。
	int main() {
	nlohmann::json arr = nlohmann::json::array();
	arr.push_back("Apple");
	arr.push_back("Banana");
	arr.push_back("Cherry");

	arr[1] = "Blueberry"; // 修改数组中的元素
	arr.pop_back(); // 删除数组中的最后一个元素
	for (const auto& value : arr) {
	std::cout << value << std::endl;
	}
	return 0;
	}

	序列化和反序列化
	#include "nlohmann/json.hpp"
	class TestA
	{
	public:
	TestA(){}
	TestA(int v1, string v2):i(v1),s(v2) {}

	int i;
	string s;

	void to_json(nlohmann::json& j) const {
	j = nlohmann::json{{"i", i}, {"s", s}};
	}
	void from_json(const nlohmann::json& j) {
	i = j["i"];
	s = j["s"];
	}
	//或者使用下面的宏来序列化和反序列化
	//NLOHMANN_DEFINE_TYPE_INTRUSIVE(TestA, i, s)
	};

	void main()
	{

	std::string json_str = R"({
	"i": 1,
	"s": "str"
	})";
	json j1 = json::parse(json_str);
	TestA B;
	//反序列化
	B.from_json(j1);
	cout<<B.i<<B.s<<endl;
	}

nlohmann::json从入门到精通

nlohmann简介

nlohmann的起源与发展

与其他c++ json库的比较

nlohmann的架构与设计理

nlohmann在C++中的应用

nlohmann的安装与引用

基本语法

高级语法

微信扫一扫：分享