【3rd Party】nlohmann json 基础用法
参考链接：Here
什么是nlohman json ?
nlohman json GitHub - nlohmann/json: JSON for Modern C++ 是一个为现代C++（C++11）设计的JSON解析库，主要特点是
- 易于集成，仅需一个头文件，无需安装依赖
- 易于使用，可以和STL无缝对接，使用体验近似python中的json
Minimal Example
CMakeLists.txt 编写教程：Here
# CMakeLists.txt
cmake_minimum_required(VERSION 3.24)
project(nlohmannJson)
set(CMAKE_CXX_STANDARD 17)
include_directories("include")
add_executable(${PROJECT_NAME} src/main.cpp)
// main.cpp
#include <iostream>
#include "nlohmann/json.hpp"
using namespace std;
using namespace nlohmann;
int main() {
auto config_json = json::parse(R"({"Happy": true, "pi": 3.1415})");
cout << config_json << endl;
return 0;
}
Advanced Sample
示范用法
nlohman::json 库操作的基本对象是 json Object，全部操作围绕此展开
引入代码
#include <fstream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
读取 JSON 文件
#include <fstream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
// ...
// std::ifstream f("example.json");
std::ifstream f("../config/example.json")
json data = json::parse(f);
从JSON文本创建JSON对象
假设您要在文件中创建此文本 JSON 值作为对象：
{
"pi": 3.141,
"happy": true
}
有多种选择：
// 用原始字符串和json::parse进行初始化
json ex1 = json::parse(R"(
{
"pi": 3.1415,
"happy": true
}
)");
// 用原始字符串和literals进行初始化
using namespace nlohmann::literals;
json ex2 = R"(
{
"pi": 3.141,
"happy": true
}
)"_json;
// 使用初始化列表
json ex3 = {
{"happy", true},
{"pi", 3.141},
};
JSON 作为第一类数据类型
下面是一些示例，可让您了解如何使用该类。
假设您要创建 JSON 对象
{
"pi": 3.141,
"happy": true,
"name": "Koshkaaa",
"nothing": null,
"answer": {
"everything": 42
},
"list": [1, 0, 2],
"object": {
"currency": "USD",
"value": 42.99
}
}
使用此库，您可以编写：
// 创建一个空 json 对象 (null)
json j;
// 添加一个 double 类型成员
j["pi"] = 3.141;
// 添加一个 bool 类型的成员
j["happy"] = true;
// 添加一个字符串类型的成员
j["name"] = "Koshkaaa";
// 添加一个空成员
j["nothing"] = nullptr;
// 添加一个对象中的对象成员 {"answer":{"everything":42}}
j["answer"]["everything"] = 42;
// 添加一个数组对象, 使用 vector
j["list"] = {1,0,2};
// 添加一个对象，使用初始化列表 {"object":{"currency": "USD","value":42.99}}
j["object"] = { {"currency", "USD"}, {"value", 42.99} };
// 也可以一次性写完
json j2 = {
{"pi", 3.141},
{"happy", true},
{"name", "Koshkaaa"},
{"nothing", nullptr},
{"answer", {
{"everything", 42}
}},
{"list", {1, 0, 2}},
{"object", {
{"currency", "USD"},
{"value", 42.99}
}}
};
请注意，在所有这些情况下，您永远不需要“告诉”编译器要使用哪种 JSON 值类型。如果你想明确或表达一些边缘情况，函数json::array（）和json::object（）会有所帮助：
// 初始化一个空数组对象
json empty_array_explicit = json::array();
// 初始化一个对象
json empty_object_implicit = json({});
json empty_object_explicit = json::object();
// 初始化数组键值对 [["currency", "USD"], ["value", 42.99]]
json array_not_object = json::array({ {"currency", "USD"}, {"value", 42.99} });
序列化/反序列化
json对象和string互转JSON对象和string互转
您可以通过追加到字符串文本来创建 JSON 值（反序列化）：_json
// 从字符串创建json对象
json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;
// 使用原始字符串创建json对象
auto j2 = R"(
{
"happy": true,
"pi": 3.141
}
)"_json;
请注意，如果不附加后缀，则传递的字符串文字不会被解析，而只是用作 JSON 字符串 价值。也就是说，只会存储字符串而不是解析实际对象。_jsonjson j = "{ \"happy\": true, \"pi\": 3.141 }""{ "happy": true, "pi": 3.141 }"
上面的例子也可以用json::parse()显式表示：
auto j3 = json::parse(R"({"happy": true, "pi": 3.141})");
获取 JSON 字符串（序列化）：
std::string s = j.dump(); // {"happy":true,"pi":3.141}
// 序列化美化json形式
// 传入数字指定缩进空格数
std::cout << j.dump(4) << std::endl;
// {
// "happy": true,
// "pi": 3.141
// }
流输入输出（例如文件读写、字符串流）
您还可以使用流来序列化和反序列化：
// 从标准输入中反序列化
json j;
std::cin >> j;
// 序列化到标准输出
std::cout << j;
// 美化输出
std::cout << std::setw(4) << j << std::endl;
文件读写json：std::istream，std::ostream
// 读取json文件
std::ifstream i("file.json");
json j;
i >> j;
//json对象美化输出到文件
std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;
从迭代器范围读取json
可以从迭代器范围解析 JSON;也就是说，从迭代器可访问的任何容器中，迭代器是 1、2 或 4 个字节的整数类型，将分别解释为 UTF-8、UTF-16 和 UTF-32。例如，std::vector<std::uint8_t>,std::list<std::uint16_t>
std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v.begin(), v.end());
std::vector<std::uint8_t> v = {'t', 'r', 'u', 'e'};
json j = json::parse(v);
自定义数据源
由于 parse 函数接受任意迭代器范围，因此您可以通过实现概念来提供自己的数据源。LegacyInputIterator
struct MyContainer {
void advance();
const char& get_current();
};
struct MyIterator {
using difference_type = std::ptrdiff_t;
using value_type = char;
using pointer = const char*;
using reference = const char&;
using iterator_category = std::input_iterator_tag;
MyIterator& operator++() {
MyContainer.advance();
return *this;
}
bool operator!=(const MyIterator& rhs) const {
return rhs.target != target;
}
reference operator*() const {
return target.get_current();
}
MyContainer* target = nullptr;
};
MyIterator begin(MyContainer& tgt) {
return MyIterator{&tgt};
}
MyIterator end(const MyContainer&) {
return {};
}
void foo() {
MyContainer c;
json j = json::parse(c);
}
类似 STL 的访问
我们将 JSON 类设计为类似于 STL 容器的行为。事实上，它满足可逆容器的要求。
// 用push_back创建一个数组对象
json j;
j.push_back("foo");
j.push_back(1);
j.push_back(true);
// 使用 emplace_back
j.emplace_back(1.78);
// 迭代访问
for (json::iterator it = j.begin(); it != j.end(); ++it) {
std::cout << *it << '\n';
}
// 范围迭代
for (auto& element : j) {
std::cout << element << '\n';
}
// getter/setter接口
const auto tmp = j[0].get<std::string>();
j[1] = 42;
bool foo = j.at(2);
// 比较
j == R"(["foo", 1, true, 1.78])"_json; // true
// 其他
j.size(); // 4 个对象
j.empty(); // 是否为空：false
j.type(); // 获取类型：json::value_t::array
j.clear(); // 清空
// 检查类型
j.is_null();
j.is_boolean();
j.is_number();
j.is_object();
j.is_array();
j.is_string();
// 创建一个对象
json o;
o["foo"] = 23;
o["bar"] = false;
o["baz"] = 3.141;
// 使用 emplace
o.emplace("weather", "sunny");
// 迭代访问
for (json::iterator it = o.begin(); it != o.end(); ++it) {
std::cout << it.key() << " : " << it.value() << "\n";
}
// 循环访问
for (auto& el : o.items()) {
std::cout << el.key() << " : " << el.value() << "\n";
}
// 匿名对象迭代器(C++17)
for (auto& [key, value] : o.items()) {
std::cout << key << " : " << value << "\n";
}
// 查找key
if (o.contains("foo")) {
// 找到foo的键值
}
// 通过迭代器查找
if (o.find("foo") != o.end()) {
// 找到foo的键值
}
// 用count()统计是否有键值
int foo_present = o.count("foo"); // 1
int fob_present = o.count("fob"); // 0
// 删除foo对象
o.erase("foo");
从 STL 容器转换
从STL容器转换到json，std::list转json，std::vector转json
std::vector<int> c_vector {1, 2, 3, 4};
json j_vec(c_vector);
// [1, 2, 3, 4]
std::deque<double> c_deque {1.2, 2.3, 3.4, 5.6};
json j_deque(c_deque);
// [1.2, 2.3, 3.4, 5.6]
std::list<bool> c_list {true, true, false, true};
json j_list(c_list);
// [true, true, false, true]
std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
json j_flist(c_flist);
// [12345678909876, 23456789098765, 34567890987654, 45678909876543]
std::array<unsigned long, 4> c_array {{1, 2, 3, 4}};
json j_array(c_array);
// [1, 2, 3, 4]
std::set<std::string> c_set {"one", "two", "three", "four", "one"};
json j_set(c_set); // only one entry for "one" is used
// ["four", "one", "three", "two"]
std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
json j_uset(c_uset); // only one entry for "one" is used
// maybe ["two", "three", "four", "one"]
std::multiset<std::string> c_mset {"one", "two", "one", "four"};
json j_mset(c_mset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]
std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
json j_umset(c_umset); // both entries for "one" are used
// maybe ["one", "two", "one", "four"]
std::map 转 json 、std::unordered 转 json
std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
json j_map(c_map);
// {"one": 1, "three": 3, "two": 2 }
std::unordered_map<const char*, double> c_umap { {"one", 1.2}, {"two", 2.3}, {"three", 3.4} };
json j_umap(c_umap);
// {"one": 1.2, "two": 2.3, "three": 3.4}
std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_mmap(c_mmap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}
std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_ummap(c_ummap); // only one entry for key "three" is used
// maybe {"one": true, "two": true, "three": true}
