C++最好用的 json库 nlohmann_nlohmann/json.hpp下载

C++最好用的 json库 nlohmann

1.安装

（GitHub）使用非常简单，只需要引入json.hpp即可：

#include "json.hpp"
// 为方便起见，设置命名空间
using json = nlohmann::json;
1
2
3

对于 GCC 和 Clang 编译器来说，别忘了打开 C++11 支持，例如 -std=c++11。

2.使用

2.1 创建json

// 创建一个空结构（null）
json j;
// 添加一个数值，存为 double
j["pi"] = 3.141;
// 添加一个布尔值，存为 bool
j["happy"] = true;
// 添加一个字符串，存为 std::string
j["name"] = "Niels";
// 添加另一个空对象，使用 nullptr
j["nothing"] = nullptr;
// 添加一个对象内的对象
j["answer"]["everything"] = 42;
// 添加一个数组，存为 std::vector (使用初始化器列表)
j["list"] = {1, 0, 2};
// 添加另一个对象 
j["object"] = {{"currency", "USD"}, {"value", 42.99}};
//相反,你也可以写(这看起来非常类似于上面的JSON)
json j2 = {
  {"pi", 3.141},
  {"happy", true},
  {"name", "Niels"},
  {"nothing", nullptr},
  {"answer", {
    {"everything", 42}
  }},
  {"list", {1, 0, 2}},
  {"object", {
    {"currency", "USD"},
    {"value", 42.99}
  }}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2.2 序列化和反序列化

//ps：注意,如果没有附加_json后缀,传递的字符串不解析,只是作为JSON字符串值。
//反序列化自字符串
//从字符串创建json对象
json j = "{ \"happy\": true, \"pi\": 3.141 }"_json;
//最好使用原始字面量创建json对象
auto j2 = R"(
  {
    "happy": true,
    "pi": 3.141
  }
)"_json;
1
2
3
4
5
6
7
8
9
10
11

上面的例子也可以显式地使用json::parse() 转成json

auto j3 = json::parse(R"({"happy": true, "pi": 3.141})");
1

你也可以一个JSON值的字符串表示（序列化）

//转换成字符串
std::string s = j.dump();    // {"happy":true,"pi":3.141}
//通过空间的缩进,序列化与漂亮的印刷
std::cout << j.dump(4) << std::endl;
// {
//     "happy": true,
//     "pi": 3.141
// }
1
2
3
4
5
6
7
8

2.3 任意类型的转换

任意类型都可以序列化至JSON

namespace ns {
    // a simple struct to model a person
    struct person {
        std::string name;
        std::string address;
        int age;
    };
}

ns::person p = {"Ned Flanders", "744 Evergreen Terrace", 60};
1
2
3
4
5
6
7
8
9
10

将每个值复制到JSON对象

json j;
j["name"] = p.name;
j["address"] = p.address;
j["age"] = p.age;
1
2
3
4

从JSON对象拷贝每个值

ns::person p {
    j["name"].get<std::string>(),
    j["address"].get<std::string>(),
    j["age"].get<int>()
};
1
2
3
4
5

上面这些这些赋值操作太繁琐了，幸运的是有更好的办法

// 创建 person 结构体
ns::person p {"Ned Flanders", "744 Evergreen Terrace", 60};

// person 结构体 转json
json j = p;

std::cout << j << std::endl;
// {"address":"744 Evergreen Terrace","age":60,"name":"Ned Flanders"}

// json 转person 结构体
auto p2 = j.get<ns::person>();

// that's it
assert(p == p2);
1
2
3
4
5
6
7
8
9
10
11
12
13
14

要使用以上方法，需要提供2个函数

using json = nlohmann::json;

namespace ns {
    void to_json(json& j, const person& p) {
        j = json{{"name", p.name}, {"address", p.address}, {"age", p.age}};
    }

    void from_json(const json& j, person& p) {
        j.at("name").get_to(p.name);
        j.at("address").get_to(p.address);
        j.at("age").get_to(p.age);
    }
} // namespace ns
1
2
3
4
5
6
7
8
9
10
11
12
13

就这样，当使用你的类型调用json构造函数时，你的自定义to_json方法将被自动调用。同样的， 当调用 get<your_type>() 或者 get_to(your_type&)，from_json 方法将被调用