json for modern c++的使用

(给CPP开发者加星标，提升C/C++技能)

来源：CSDN-Rotation.

导读：json是一种十分常见的数据交换格式，在接口中被广泛使用。很多高级语言如python等都对json有良好的支持，方便程序员的使用。

然而C++对json没有很好的内置支持，因此往往要引用一些第三方库。而网上很多json的包，形形色色种类繁多，但是要么功能不够强大，要么难以使用。

json for modern c++是一款非常好用的json库，具有语法直观和使用简单的特点，并且是用C++11标准编写的，此外还支持STL和json容器之间的转换，可谓集方便又强大。

本文推荐给广大C++程序员，相信学习完本文之后，在处理json时一定会得心应手。

————【以下是正文】————   

最近学习了json for modern c++的使用，在此总结一些常用功能使用方法。
老规矩，还是先简单介绍一下什么是json吧。

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。

今天介绍的json版本是在c++下使用的，是一个开源项目。

GitHub开源项的地址：https://github.com/nlohmann/json

json for modern c++是一个德国大牛nlohmann写的，该版本的json有以下特点：

1.直观的语法。
2.整个代码由一个头文件组成json.hpp，没有子项目，没有依赖关系，没有复杂的构建系统，使用起来非常方便。
3.使用c++11标准编写。
4.使用json 像使用STL容器一样。
5.STL和json容器之间可以相互转换。
…

如何使用？

将github上的src文件夹里的json.hpp头文件下载保存到当前目录中。
在代码中包含json.hpp头文件并引入json作用域

#include "json.hpp"
using json = nlohmann::json;

常用功能:

一.创建json对象

1.使用cin,cout输入输出流。
json提供了cin，cout的输入输出流的操作符。但需要注意的是，cin要有ctr + D结束输入。cin会把从标准输入的内容反序列化，cout会自动把json序列化，以string形式输出。

#include<iostream>
#include"json.hpp"
using namespace std;
using json=nlohmann::json;

int main()
{
    json j;  //创建json类
    cin>>j;   //从cin读入json对象
    cout<<j;  //输出序列化的json
    return 0;
}

/*
输入：
{
  "pi": 3.141,
  "happy": true,
  "name": "Niels",
  "nothing": null,
  "answer": {
    "everything": 42
  },
  "list": [1, 0, 2],
  "object": {
    "currency": "USD",
    "value": 42.99
  }
}
输出:
{"answer":{"everything":42},"happy":true,"list":[1,0,2],"name":"Niels","nothing":null,"object":{"currency":"USD","value":42.99},"pi":3.141}
*/

2.提供根据键直接生成键值对的方法。（类似于map，如果不存在该键的话，就生成一个这个键。）

#include <iostream>
#include "json.hpp"
using json = nlohmann::json;
using namespace std;

int main() {
    // 创建一个json对象(null)
    json j;

    //添加一个存储为double的数字
    j["pi"] = 3.141;

    // 添加一个布尔值 
    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}
        }}
    };
    cout << j << endl;
    cout << endl;
    cout << j2 << endl;
    return 0;
}

/*
输出:
{"answer":{"everything":42},"happy":true,"list":[1,0,2],"name":"Niels","nothing":null,"object":{"currency":"USD","value":42.99},"pi":3.141}


{"answer":{"everything":42},"happy":true,"list":[1,0,2],"name":"Niels","nothing":null,"object":{"currency":"USD","value":42.99},"pi":3.141}
*/

3.在所有上述情况下，你不需要“告诉”编译器要使用哪个JSON值。如果你想明确或表达一些边缘的情况下，可以使用json::array,json::object。

#include <iostream>
#include "json.hpp"
using json = nlohmann::json;
using namespace std;

int main() {
    //创建一个空数组
    json empty_array_explicit = json::array();

    // 创建一个空对象的两种方式
    json empty_object_implicit = json({});
    json empty_object_explicit = json::object();
}

4.几点注意
1).array是一个数组，可以用数字直接下标访问。

json array = {
        "a",6,"xin",8
    };
cout << array[0] << endl;

2）数组中包含一个数组

json array = {
        {"a",6},
        "xin",8
    };
cout << array[0][0] << endl;  //输出数组里的数组元素中的第一个元素的值

3）数组中包含一个对象

json array = {
        {{"a",6}},
        "xin",8
    };
//输出数组中第一个元素"a"对应的键值
cout << array[0]["a"] << endl;

4).对象中嵌套一个对象和一个数组

json object = {
        {"a",{{"feng",6}}},{"b",{1,2,3}}
    };
    cout << object << endl;
/*输出：
{"a":{"feng":6},"b":[1,2,3]}
*/

二.序列化

将json对象序列化，成为字符串

1.标准输出自动序列化

json j
std :: cout << j;
// setw操纵器被重载以设置漂亮打印的缩进 
std :: cout << std :: setw（ 4）<< j << std :: endl;

2.使用dump()函数

//显式转换为string 
std::string s = j.dump();    // {\"happy\":true,\"pi\":3.141}

//序列化与漂亮的打印
//传入空格的数量缩进 
std::cout << j.dump(4) << std::endl;
// 输出：
//{
//     "happy": true,
//     "pi": 3.141
// }

三.反序列化

将数据流转化为json对象

1.从标准输入反序列化

json j
std :: cin >> j;

2.通过附加_json到字符串文字来创建对象(反序列化):

//从字符串文字创建对象 
json j = " { \" happy \"：true，\" pi \"：3.141} " _json;

//或者原始字符串文字
auto j2 = R"（
   { 
    "happy":true，
    "pi":3.141 
  } 
）" _json;

请注意，没有附加_json后缀，传递的字符串文字不会被解析，而只是用作JSON字符串值。也就是说，json j = "{ \"happy\": true, \"pi\": 3.141 }"只存储字符串"{ "happy": true, "pi": 3.141 }"而不是解析实际的对象。

3.使用json::parse()函数

//明确解析
auto j3 = json::parse(" { \" happy \":true,\" pi \":3.141} ");

4.从迭代器范围读取

您还可以从迭代器范围读取JSON; 也就是说，可以从其内容存储为连续字节序列的迭代器访问的任何容器，例如std::vector

std :: vector < uint8_t > v = { ' t ',' r ',' u ',' e ' };
json j = json :: parse(v.begin(),v.end());

//或
std :: vector < uint8_t > v = { ' t ',' r ',' u ',' e ' };
json j = json :: parse(v);

四.与STL适应

nlohmann设计的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循环
for (auto& element : j) {
  std::cout << element << '\n';
}

// 赋值操作
const std::string tmp = j[0];
j[1] = 42;
bool foo = j.at(2);

// 比较操作
j == "[\"foo\", 1, true]"_json;  // true

// 其他函数
j.size();     // 3 
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";
}

// 使用find函数
if (o.find("foo") != o.end()) {
  // there is an entry with key "foo"
}

// count函数
int foo_present = o.count("foo"); // 1
int fob_present = o.count("fob"); // 0

// 删除条目 
o.erase("foo");

五.从STL容器转换

任何序列容器（std::array，std::vector，std::deque，std::forward_list，std::list），其值可以被用于构建JSON类型（例如，整数，浮点数，布尔值，字符串类型，或者再次在本节中描述STL容器）可被用于创建JSON阵列。这同样适用于类似的关联容器（std::set，std::multiset，std::unordered_set，std::unordered_multiset），但是在这些情况下，阵列的元素的顺序取决于元素是如何在各个STL容器排序。

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，std::multimap，std::unordered_map，std::unordered_multimap），其键可以构造一个std::string，并且其值可以被用于构建JSON类型（参见上文实施例）可用于创建一个JSON对象。请注意，在多重映射的情况下，JSON对象中仅使用一个键，该值取决于STL容器的内部顺序。

<br>
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}

六.隐式转换

JSON对象的类型由要存储的表达式自动确定。同样，存储的值被隐式转换。

<br>
// strings 
std :: string s1 = “ Hello，world！” ;
json js = s1;
std :: string s2 = js;

// Booleans 
bool b1 = true ;
json jb = b1;
bool b2 = jb;

// numbers 
int i = 42 ;
json jn = i;
double f = jn;

//...

还可以明确要求该值:

std :: string vs = js.get <std :: string>（）;
bool vb = jb.get < bool >（）;
int vi = jn.get < int >（）;

//...

七.任意类型转换

每个类型都可以以JSON序列化，而不仅仅是STL容器和标量类型。通常情况下，你会做这些事情：

namespace ns {
    struct person {
        std::string name;
        std::string address;
        int age;
    };
}

ns::person p = {"Ned Flanders", "744 Evergreen Terrace", 60};

// 转换为JSON：将每个值复制到JSON对象中
json j;
j["name"] = p.name;
j["address"] = p.address;
j["age"] = p.age;

// ...

// 从JSON转换：从JSON对象复制每个值
ns::person p {
    j["name"].get<std::string>(),
    j["address"].get<std::string>(),
    j["age"].get<int>()
};

或者，使用一种更简便的用法

// 创建一个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
ns::person p2 = j;

// 测试是否完全相同
assert(p == p2);

以上是对json for modern c++基本功能的使用总结，如有哪里有误，欢迎指出，相互学习交流。

- EOF -

推荐阅读  点击标题可跳转

觉得文章不错，请点赞和在看支持我继续分享好文。谢谢！

关注『CPP开发者』

看精选C++技术文章 . 加C++开发者专属圈子

↓↓↓

点赞和在看就是最大的支持❤️