C++開(kāi)源庫(kù)nlohmann/json的介紹和使用詳解
前言
該庫(kù)的地址：github.com/nlohmann/json，到目前已經(jīng)擁有38.5K的star，可以說(shuō)是被大家廣泛贊同，經(jīng)過(guò)簡(jiǎn)單探究，確實(shí)發(fā)現(xiàn)非常不錯(cuò)，可以在項(xiàng)目中使用。
該庫(kù)的集成非常容易，只有1個(gè)hpp文件，拿來(lái)即用，完全不需要任何復(fù)雜的編譯，尤其是剛?cè)腴T(mén)的C++開(kāi)發(fā)來(lái)說(shuō)，編譯一些開(kāi)源庫(kù)是永遠(yuǎn)的噩夢(mèng)。
同時(shí)該庫(kù)使用C++11代碼編譯，使用了不少特性，也是值得學(xué)習(xí)其原理，學(xué)習(xí)C++的不錯(cuò)選擇。
下面安裝其readme，簡(jiǎn)單介紹，以及自己的使用體驗(yàn)。
1. JSON as first-class data type
中文翻譯為json作為一等數(shù)據(jù)類(lèi)型，即我們可以將json數(shù)據(jù)類(lèi)型作為一等公民(first-class citizen)，并且支持相應(yīng)的操作和語(yǔ)法。
關(guān)于某種語(yǔ)言是否把某個(gè)特性或者功能作為一等公民看待，我個(gè)人有2點(diǎn)感受比較深刻。第一個(gè)是Java到Kotlin的編程語(yǔ)言變化，同為JVM語(yǔ)言，Kotlin把函數(shù)和lambda表達(dá)式看成一等公民，在Kotlin中可以將函數(shù)作為參數(shù)、作為返回值等，在Kotlin官方實(shí)例和源碼中大量使用，極大地提高代碼簡(jiǎn)潔性。第二個(gè)是學(xué)習(xí)C++時(shí)，C++沒(méi)有把原生數(shù)組類(lèi)型看成一等公民，比如數(shù)組不支持直接拷貝賦值，原因很多，比如必須固定長(zhǎng)度，缺乏高級(jí)操作以及語(yǔ)法糖支持，指針語(yǔ)義容易混淆(C++中，數(shù)組名實(shí)際上是一個(gè)指向數(shù)組首元素的指針)等，所以推薦使用std::vector來(lái)替代原生數(shù)組。
在C++中并沒(méi)有直接將json看成一等公民，與此對(duì)應(yīng)的Python就有非常好的支持，而該庫(kù)想實(shí)現(xiàn)這一目的，就必須得提供足夠簡(jiǎn)潔的使用方式，以及足夠豐富的操作。比如我想創(chuàng)建一個(gè)json對(duì)象，如下：
//想創(chuàng)建的json對(duì)象，標(biāo)準(zhǔn)json格式
{
"pi": 3.141,
"happy": true,
"name": "Niels",
"nothing": null,
"answer": {
"everything": 42
},
"list": [1, 0, 2],
"object": {
"currency": "USD",
"value": 42.99
}
}
?
//代碼如下
//創(chuàng)建一個(gè)空對(duì)象
json j;
//增加一個(gè)數(shù)字，使用double類(lèi)型存儲(chǔ)，
j["pi"] = 3.141;
//增加一個(gè)布爾值，使用bool類(lèi)型存儲(chǔ)
j["happy"] = true;
//增加一個(gè)字符串，使用std::string類(lèi)型存儲(chǔ)
j["name"] = "Niels";
//通過(guò)傳遞一個(gè)nullptr增加一個(gè)空對(duì)象
j["nothing"] = nullptr;
//在對(duì)象內(nèi)部增加一個(gè)對(duì)象
j["answer"]["everything"] = 42;
//增加一個(gè)數(shù)組，使用std::vector
j["list"] = {1, 0, 2};
//增加另一個(gè)對(duì)象
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}
}}
};
std::cout << j2.dump(4) << std::endl;
//運(yùn)行結(jié)果
{
"answer": {
"everything": 42
},
"happy": true,
"list": [
1,
0,
2
],
"name": "Niels",
"nothing": null,
"object": {
"currency": "USD",
"value": 42.99
},
"pi": 3.141
}
這里看似非常簡(jiǎn)單，但是有一些原理我們是需要知道的。我們對(duì)比一下給定的json中list的結(jié)構(gòu)，它是一個(gè)數(shù)組，使用[1, 0, 2]，我們?cè)?code>j和j2的構(gòu)造中，都是使用的{}來(lái)進(jìn)行賦值的，這一點(diǎn)就和把json看成一等公民的Python語(yǔ)言有較大區(qū)別，下面是Python代碼：
import sys
import os
import json
?
# 定義一個(gè) Python 對(duì)象
person = {
"name": "Alice",
"age": 25,
"hobby": ["reading", "music"]
}
?
# 將 Python 對(duì)象轉(zhuǎn)換為 json 字符串
json_str = json.dumps(person)
?
# 輸出轉(zhuǎn)換后的 JSON 字符串
print(json_str)
?
//輸出結(jié)果
{"name": "Alice", "age": 25, "hobby": ["reading", "music"]}
可以發(fā)現(xiàn)在Python構(gòu)建對(duì)象時(shí)，對(duì)于數(shù)組結(jié)構(gòu)，可以直接使用[]，更符合常識(shí)，C++為什么不可以，因?yàn)?code>j["list"] = {1, 0, 2};是通過(guò)重載[]運(yùn)算符對(duì)j進(jìn)行賦值，默認(rèn)的數(shù)據(jù)成員對(duì)象類(lèi)型是std::vector，對(duì)std::vector的初始化使用列表初始化時(shí)，不能使用[]，即如下：
//C++11可以使用列表初始化
std::vector list = {0, 1, 2};
//錯(cuò)誤
std::vector list1 = [0, 1, 2];
因?yàn)樵搸?kù)只能利用重載運(yùn)算符等方式來(lái)讓json操作看起來(lái)像是操作json，而非C++語(yǔ)言支持這種操作。
搞清楚這個(gè)之后，我們?cè)賮?lái)看看object，在原始的json中，我們可以清晰地知道它對(duì)應(yīng)的類(lèi)型是一個(gè)類(lèi)類(lèi)型：
"object": {
"currency": "USD",
"value": 42.99
}
但是在使用對(duì)j的object的賦值如下：
j["object"] = { {"currency", "USD"}, {"value", 42.99}};
這不是和前面所說(shuō)的數(shù)組賦值沖突了嗎，依據(jù)列表初始化規(guī)則，這個(gè)完全可以解析為數(shù)組類(lèi)型，即[["currency", "USD"],["value", 42.99]]，也就是二維數(shù)組，這時(shí)我們又可以對(duì)比一下Python可以怎么寫(xiě)：
import sys
import os
import json
?
# 定義一個(gè) Python 對(duì)象
person = {
"name": "Alice",
"age": 25,
"object": {
"currency":"USD",
"value":"42.99"
}
}
?
# 將 Python 對(duì)象轉(zhuǎn)換為 JSON 字符串
json_str = json.dumps(person)
?
# 輸出轉(zhuǎn)換后的 JSON 字符串
print(json_str)
?
#輸出結(jié)果
{"name": "Alice", "age": 25, "object": {"currency": "USD", "value": "42.99"}}
可以發(fā)現(xiàn)在Python中可以使用:，這樣對(duì)應(yīng)的鍵和值非常容易識(shí)別，那C++為什么不可以呢？還是一樣的問(wèn)題，在代碼j["object"] = { {"currency", "USD"}, {"value", 42.99}};中，是使用std::map數(shù)據(jù)結(jié)構(gòu)來(lái)作為其默認(rèn)的成員數(shù)據(jù)類(lèi)型，而C++11中可以使用列表初始化來(lái)初始化std::map，同時(shí)沒(méi)有:的語(yǔ)法：
//C++11可以使用列表初始化
std::map map = { {"currency", "USD"}, {"value", 42.99} };
//錯(cuò)誤
std::map map1 = { {"currency":"USD"}, {"value":42.99} };
搞明白為什么之后，我們就要回答前面的問(wèn)題，為什么object沒(méi)有被解析為std::vector類(lèi)型呢？原因是默認(rèn)規(guī)則就是這樣的，即一層和2層{}的默認(rèn)處理邏輯是不一樣的。
假如有一些極限情況，我就是想用數(shù)組形式來(lái)保存對(duì)象格式，這時(shí)可以顯示地聲明json值的類(lèi)型，使用json::array()和json::object()函數(shù)：
//C++11可以使用列表初始化
std::map map = { {"currency", "USD"}, {"value", 42.99} };
//錯(cuò)誤
std::map map1 = { {"currency":"USD"}, {"value":42.99} };
搞明白為什么之后，我們就要回答前面的問(wèn)題，為什么object沒(méi)有被解析為std::vector類(lèi)型呢？原因是默認(rèn)規(guī)則就是這樣的，即一層和2層{}的默認(rèn)處理邏輯是不一樣的。
假如有一些極限情況，我就是想用數(shù)組形式來(lái)保存對(duì)象格式，這時(shí)可以顯示地聲明json值的類(lèi)型，使用json::array()和json::object()函數(shù)：
//顯示聲明是一個(gè)數(shù)組，而非對(duì)象
json empty_array_explicit = json::array();
//對(duì)于沒(méi)有構(gòu)造函數(shù)或者這種，默認(rèn)隱式類(lèi)型是對(duì)象
json empty_object_implicit = json({});
json empty_object_explicit = json::object();
//是一個(gè)數(shù)組，而非對(duì)象
json array_not_object = json::array({ {"currency", "USD"}, {"value", 42.99} });
std::cout << empty_array_explicit.dump(4) << std::endl;
std::cout << empty_object_implicit.dump(4) << std::endl;
std::cout << empty_object_explicit.dump(4) << std::endl;
std::cout << array_not_object.dump(4) << std::endl;
//運(yùn)行結(jié)果
[]
{}
{}
[
[
"currency",
"USD"
],
[
"value",
42.99
]
]
搞清楚默認(rèn)類(lèi)型，以及如何顯示聲明非常重要。
2. 序列化/反序列化
既然想把json打造為一等公民，序列化和反序列化是必須要具備 ，而且要可以從不同的源來(lái)進(jìn)行序列化/反序列化，比如從文件、字符串等。
2.1 與字符串
我們可以從字符串字面量來(lái)創(chuàng)建一個(gè)json對(duì)象，注意和上面使用=進(jìn)行列表初始化的方式不同，這里的參數(shù)是字符串字面量：
json j = "{"happy":true,"pi":3.141}"_json;
std::cout << j.dump(4) << std::endl;
auto j2 = R"({
"happy": true,
"pi": 3.141
})"_json;
std::cout << j2.dump(4) << std::endl;
json j1 = "{"happy":true,"pi":3.141}";
std::cout << j1.dump(4) << std::endl;
//運(yùn)行結(jié)果
{
"happy": true,
"pi": 3.141
}
{
"happy": true,
"pi": 3.141
}
"{"happy":true,"pi":3.141}"
上面代碼都是通過(guò)字符串初始化一個(gè)json對(duì)象，但是需要注意的點(diǎn)很多。
2.1.1 原始字符串字面量(Raw String Literal)
首先就是j2的初始化，它使用了R"()"這種語(yǔ)法，這種表示字符串的方式叫做原始字符串字面量。在C++中，可以使用R"()"來(lái)表示原始字符串字面量，使用原始字符串字面量可以方便地包含特殊字符(比如反斜杠、引號(hào)等)或者多行文本的字符串，而無(wú)需對(duì)這些特殊字符進(jìn)行轉(zhuǎn)移。
比如如下代碼:
{
qDebug() << "Hello\tWorld!";
qDebug() << R"(Hello\tWorld
NEW LINE)";
}
運(yùn)行結(jié)果是：
可以發(fā)現(xiàn)普通字符串中\t被解釋為制表符，而在原始字符串字面量中，\t不會(huì)被解析，并且換行也被保留了下來(lái)。其實(shí)在其他語(yǔ)言中，使用這種方式更為簡(jiǎn)單，比如Kotlin使用"""進(jìn)行包裹字符串，或者Python使用```進(jìn)行包裹字符串。
通過(guò)這個(gè)小知識(shí)點(diǎn)的學(xué)習(xí)，我們明顯發(fā)現(xiàn)j2就比j的初始化方式更人性化，至少不用去在意字符串中的轉(zhuǎn)移字符。
2.1.2 自定義字面量操作符
然后我們關(guān)注點(diǎn)來(lái)到j和j1的區(qū)別，可以發(fā)現(xiàn)j多了一個(gè)_json的后綴，然后在輸出打印中就可以正常解析，而j1卻不可以。這里的核心點(diǎn)就是字符串字面量后面的_json，我們看一下它的源碼：
JSON_HEDLEY_NON_NULL(1)
inline nlohmann::json operator "" _json(const char* s, std::size_t n)
{
return nlohmann::json::parse(s, s + n);
}
看到operator就應(yīng)該想到自定義操作符，沒(méi)錯(cuò)，operator ""是C++11引入的自定義字面量操作符，通過(guò)重載operator ""可以為特定的后綴自定義語(yǔ)義，這種機(jī)制可以使得我們可以像使用內(nèi)置的字面量(如整數(shù)、浮點(diǎn)數(shù)、字符串等)一樣自然地使用自定義的字面量，從而提高代碼的可讀性和表達(dá)力。
舉個(gè)簡(jiǎn)單的例子：
//為long long類(lèi)型定義一個(gè)_km后綴
constexpr long long operator "" _km(unsigned long long x) {
return x * 1000;
}
long long distance = 20_km;
std::cout << "distance:" << distance << "meters\n";
//輸出結(jié)果
distance:20000meters
從這個(gè)例子我們來(lái)看上面_json的含義，它就是給const char*類(lèi)型即字符串類(lèi)型添加一個(gè)_json后綴，作用就是調(diào)用nlohmann::json::parse(s, s + n)返回一個(gè)json對(duì)象，理解了這個(gè)之后，我們也就可以理解為什么j1不能被解析，因?yàn)闆](méi)有_json后綴，根本不會(huì)調(diào)用parse函數(shù)進(jìn)行解析成json對(duì)象。
因?yàn)?code>_json這種用法就是語(yǔ)法糖，所以其實(shí)想解析一個(gè)字符串成json，就可以直接調(diào)用json::parse()函數(shù)：
json j3 = json::parse(R"({"happy": true,"pi": 3.141})");
從前面的錯(cuò)誤用法打印來(lái)看，一般情況下我們認(rèn)為json對(duì)象要不表示一個(gè)對(duì)象，要不表示一個(gè)數(shù)組，但是從打印j1來(lái)看：
json j1 = "{"happy":true,"pi":3.141}";
std::cout << j1.dump(4) << std::endl;
//運(yùn)行結(jié)果
"{"happy":true,"pi":3.141}"
這里居然返回一個(gè)字符串。所以這里一定要區(qū)分序列化和賦值的區(qū)別，對(duì)于序列化，在前面我們說(shuō)了2種方式，一種是使用列表初始化，一種是使用字符串字面量，而直接賦值的話，json內(nèi)部會(huì)直接保存一個(gè)字符串。
2.2 與file
從文件中反序列化一個(gè)json對(duì)象可以說(shuō)是在配置文件時(shí)非常常用了，這里使用也非常簡(jiǎn)單，代碼如下：
std::string dirPath = QApplication::applicationDirPath().toStdString();
std::string file = dirPath + "/file.json";
//使用ifstream讀取file
std::ifstream i(file);
json j_file;
//把輸入流中的信息放入json中
i >> j_file;
std::cout << j_file.dump(4) << std::endl;
json j_file_bak = {
{"pi", 3.141},
{"happy", true},
{"name", "Niels"},
{"nothing", nullptr},
{
"answer", {
{"everything", 42}
}
},
{"list", {1, 0, 2}},
{
"object", {
{"currency", "USD"},
{"value", 42.99}
}
}
};
std::string file_bak = dirPath + "/file_bak.json";
std::ofstream o(file_bak);
o << std::setw(4) << j_file_bak << std::endl;
可以發(fā)現(xiàn)只要獲取到標(biāo)準(zhǔn)的輸入輸出流之后，我們就可以使用>>和<<符號(hào)來(lái)進(jìn)行文件序列化和反序列化了，這里的原理非常簡(jiǎn)單，也是操作符重載，在源碼中重載了>>和<<：
friend std::istream& operator>>(std::istream& i, basic_json& j)
{
parser(detail::input_adapter(i)).parse(false, j);
return i;
}
friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
{
// read width member and use it as indentation parameter if nonzero
const bool pretty_print = o.width() > 0;
const auto indentation = pretty_print ? o.width() : 0;
// reset width to 0 for subsequent calls to this stream
o.width(0);
// do the actual serialization
serializer s(detail::output_adapter<char>(o), o.fill());
s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
return o;
}
對(duì)于C++開(kāi)發(fā)來(lái)說(shuō)，左移和右移符號(hào)已經(jīng)非常熟悉了。
3. STL-like access
STL-like access是STL風(fēng)格訪問(wèn)的意思，在C++中可以為一些類(lèi)定義STL風(fēng)格訪問(wèn)的API，可以提高類(lèi)型的靈活性和易用性，這樣我們就可以像STL容器一樣使用迭代器、算法等功能，從而可以簡(jiǎn)化很多操作，提高了代碼的可讀性和可維護(hù)性。
3.1 STL風(fēng)格API
由于json本身就是由標(biāo)準(zhǔn)庫(kù)中的類(lèi)型進(jìn)行解析的，所以為其設(shè)計(jì)一套STL風(fēng)格訪問(wèn)的API也就很有必要，使用如下：
//創(chuàng)建一個(gè)數(shù)組， 使用push_back
json j;
j.push_back("foo");
j.push_back(1);
j.push_back(true);
//可以使用emplace_back
j.emplace_back(1.78);
//使用迭代器遍歷數(shù)組
for (json::iterator it = j.begin(); it != j.end(); it++) {
std::cout << *it << std::endl;
}
//快速for循環(huán)
for (auto& element : j) {
std::cout << element << std::endl;
}
//getter/setter
const auto tmp = j[0].template get<std::string>();
j[1] = 42;
bool foo = j.at(2);
//比較運(yùn)算符
j == R"(["foo", 1, true, 1.78])"_json;
j.size();
j.empty();
j.type();
j.clear();
//快捷類(lèi)型判斷
j.is_null();
j.is_boolean();
j.is_number();
j.is_object();
j.is_array();
j.is_string();
//創(chuàng)建一個(gè)對(duì)象
json o;
o["foo"] = 23;
o["bar"] = false;
o["baz"] = 3.14;
//特殊的成員迭代器函數(shù)
for (json::iterator it = o.begin(); it != o.end(); it++) {
std::cout << it.key() << " : " << it.value() << std::endl;
}
//快速for循環(huán)
for (auto& el : o.items()) {
std::cout << el.key() << " : " << el.value() << std::endl;
}
//c++17特性，結(jié)構(gòu)化綁定
for (auto& [key, value] : o.items()) {
std::cout << key << " : " << value << std::endl;
}
//判斷有沒(méi)有某個(gè)鍵值對(duì)
if (o.contains("foo")) {
std::cout << "contain foo" << std::endl;
}
這種使用方式可以讓我們操作json像操作標(biāo)準(zhǔn)容器一樣，非常方便。
3.2 從STL容器構(gòu)造
同理，我們可以從STL容器構(gòu)造出json對(duì)象，任何序列容器，比如std::array、std::vector、std::deque、std::forward_list和std::list，其中保存值可以構(gòu)造json的值，比如int，float、boolean、字符串類(lèi)型等，這些容器均可以用來(lái)構(gòu)造json數(shù)組。對(duì)于類(lèi)似的關(guān)聯(lián)容器(std::set、std::multiset、std::unordered_set、std::unordered_multiset)也是一樣，但是在這種情況下，數(shù)組元素的順序取決于元素在數(shù)組中的排序方式。
使用代碼如下：
std::vector<int> c_vector {1, 2, 3, 4};
json j_vec(c_vector);
std::deque<double> c_deque {1,2, 2.3, 3.4, 5.6};
json j_deque(c_deque);
std::list<bool> c_list {true, true, false, true};
json j_list(c_list);
std::forward_list<int64_t> c_flist {12345678909876, 23456789098765, 34567890987654, 45678909876543};
json j_flist(c_flist);
std::array<unsigned long, 4> c_array{{1, 2, 3, 4}};
json j_array(c_array);
std::set<std::string> c_set {"one", "two", "three", "four", "one"};
json j_set(c_set);
std::unordered_set<std::string> c_uset {"one", "two", "three", "four", "one"};
json j_uset(c_uset);
std::multiset<std::string> c_mset {"one", "two", "one", "four"};
json j_mset(c_mset);
std::unordered_multiset<std::string> c_umset {"one", "two", "one", "four"};
json j_umset(c_umset);
關(guān)于這幾種STL容器，可以做個(gè)簡(jiǎn)單的概述：
| 容器類(lèi)型 | 底層實(shí)現(xiàn) | 特點(diǎn) | 適用場(chǎng)景 |
|---|---|---|---|
| std::vector | 動(dòng)態(tài)數(shù)組 | 可變大小的連續(xù)存儲(chǔ)空間，支持隨機(jī)訪問(wèn)，尾部插入和刪除效率高。 | 需要在末尾進(jìn)行頻繁插入和刪除操作，以及隨機(jī)訪問(wèn)元素的情況。 |
| std::array | 靜態(tài)數(shù)組 | 固定大小的連續(xù)的靜態(tài)數(shù)組，在編譯期就確定了大小，并且不會(huì)改變。 | 替代原生數(shù)組，有更多的成員函數(shù)與操作API。 |
| std::list | 雙向鏈表 | 支持雙向迭代器，插入和刪除元素效率高，不支持隨機(jī)訪問(wèn)。 | 需要頻繁在中間位置進(jìn)行插入和刪除操作，不需要隨機(jī)訪問(wèn)元素。 |
| std::deque | 雙端隊(duì)列 | 支持隨機(jī)訪問(wèn)，支持在兩端插入和刪除元素，動(dòng)態(tài)地分配存儲(chǔ)空間。 | 需要在兩端插入和刪除元素，并且需要隨機(jī)訪問(wèn)元素的情況。 |
| std::set | 紅黑樹(shù) | 自動(dòng)排序元素，不允許重復(fù)元素，插入和刪除的時(shí)間復(fù)雜度為O(logN)。 | 需要自動(dòng)排序且不允許重復(fù)元素的情況。 |
| std::multiset | 紅黑樹(shù) | 自動(dòng)排序元素，允許重復(fù)元素，插入和刪除的時(shí)間復(fù)雜度為O(1)。 | 需要自動(dòng)排序且允許重復(fù)元素的情況。 |
| std::unordered_set | 哈希表 | 無(wú)序存儲(chǔ)元素，不允許重復(fù)元素，插入和查找的時(shí)間復(fù)雜度為O(1)。 | 不需要排序，并且不允許重復(fù)元素的情況。 |
| std::unordered_multiset | 哈希表 | 無(wú)序存儲(chǔ)元素，允許重復(fù)元素，插入和查找的時(shí)間復(fù)雜度為O(1)。 | 不需要排序，并且允許重復(fù)元素的情況。 |
類(lèi)似的，STL的鍵值對(duì)容器，只要鍵可以構(gòu)造std::string對(duì)象，值可以構(gòu)造json對(duì)象的，也可以用來(lái)構(gòu)造json對(duì)象類(lèi)型，測(cè)試代碼如下：
std::map<std::string, int> c_map { {"one", 1}, {"two", 2}, {"three", 3} };
json j_map(c_map);
std::unordered_map<const char*, double> c_umap { {"one", 1.2}, {"two", 2.3}, {"three", 3.4} };
json j_umap(c_umap);
std::multimap<std::string, bool> c_mmap { {"one", true}, {"two", false}, {"three", false}, {"three", true} };
json j_mmap(c_mmap);
std::unordered_multimap<std::string, bool> c_ummap { {"one", true}, {"two", true}, {"three", false}, {"three", true} };
json j_ummap(c_ummap);
這幾種容器也做個(gè)概述，和std::set類(lèi)似，也是從是否自動(dòng)排序和重復(fù)(一鍵多值)這兩個(gè)維度來(lái)擴(kuò)展，和Java還是有一點(diǎn)區(qū)別的，在Java中使用最多的是HashMap，類(lèi)似C++的std::unordered_set：
| 容器類(lèi)型 | 底層 | 特點(diǎn) |
|---|---|---|
| std::map | 紅黑樹(shù) | 根據(jù)key進(jìn)行自動(dòng)排序；每個(gè)key只能出現(xiàn)一次；由于紅黑樹(shù)的平衡性，查找、插入和刪除的時(shí)間復(fù)雜度均為O(logn)；不支持高效的隨機(jī)訪問(wèn)。 |
| std::unordered_map | 哈希表 | 不會(huì)自動(dòng)排序；每個(gè)key只能出現(xiàn)一次；查找、插入和刪除的時(shí)間復(fù)雜度為O(1)，支持高效的隨機(jī)訪問(wèn)。 |
| std::multimap | 紅黑樹(shù) | 根據(jù)key自動(dòng)排序；每個(gè)key支持對(duì)應(yīng)多個(gè)value，即可以插入多個(gè)key一樣的鍵值對(duì)；查找、插入和刪除的時(shí)間復(fù)雜度為O(logn)。 |
| std::unorder_multimap | 哈希表 | 不會(huì)自動(dòng)排序；支持每個(gè)key對(duì)應(yīng)對(duì)個(gè)value；操作的時(shí)間復(fù)雜度為O(1)。 |
4. JSON指針和補(bǔ)丁
該庫(kù)還支持JSON指針，是一種作為尋址結(jié)構(gòu)化值的替代方法。并且，JSON補(bǔ)丁(Patch)允許描述2個(gè)JSON值之間的差異。這兩點(diǎn)我覺(jué)得非常不錯(cuò)，有助于在版本迭代時(shí)進(jìn)行合并配置文件，直接看代碼：
//原始json對(duì)象
json j_1 = R"({
"baz": ["one", "two", "three"],
"foo": "bar"
})"_json;
std::cout << "j_1:" << j_1.dump(4) << std::endl;
std::cout << j_1["/baz/1"_json_pointer] << std::endl;
//補(bǔ)丁也是一個(gè)json對(duì)象
json j_patch = R"([
{ "op": "replace", "path": "/baz", "value": "boo" },
{ "op": "add", "path": "/hello", "value": ["world"] },
{ "op": "remove", "path": "/foo"}
])"_json;
std::cout << "j_patch:" << j_patch.dump(4) << std::endl;
//合并補(bǔ)丁
json j_result = j_1.patch(j_patch);
std::cout << "j_result:" << j_result.dump(4) << std::endl;
//計(jì)算出差值補(bǔ)丁，差值是第一個(gè)參數(shù)如何操作成為第二個(gè)參數(shù)的差值
json j_diff = json::diff(j_result, j_1);
std::cout << "j_diff:" << j_diff.dump(4) << std::endl;
//使用插值進(jìn)行合并
json j_result_1 = j_result.patch(j_diff);
std::cout << "j_result_1:" << j_result_1.dump(4) << std::endl;
//輸出結(jié)果
j_1:{
"baz": [
"one",
"two",
"three"
],
"foo": "bar"
}
"two"
j_patch:[
{
"op": "replace",
"path": "/baz",
"value": "boo"
},
{
"op": "add",
"path": "/hello",
"value": [
"world"
]
},
{
"op": "remove",
"path": "/foo"
}
]
j_result:{
"baz": "boo",
"hello": [
"world"
]
}
j_diff:[
{
"op": "replace",
"path": "/baz",
"value": [
"one",
"two",
"three"
]
},
{
"op": "remove",
"path": "/hello"
},
{
"op": "add",
"path": "/foo",
"value": "bar"
}
]
j_result_1:{
"baz": [
"one",
"two",
"three"
],
"foo": "bar"
}
上面代碼很容易理解，首先就是json指針的使用j_1["/baz/1"_json_pointer]，在這里和前面_json的自定義操作符一樣，_json_pointer也是對(duì)字符串的自定義操作，其中通過(guò)/符號(hào)來(lái)找到j(luò)son對(duì)象中深層次的內(nèi)容。
接著就是補(bǔ)丁，補(bǔ)丁自己也是一個(gè)json對(duì)象，每個(gè)操作對(duì)應(yīng)一個(gè)對(duì)象，分別是op表示操作，path是json指針，表示需要操作的地方，value就是新的值。調(diào)用json::patch方法就可以把補(bǔ)丁合并，生成一個(gè)新的json對(duì)象，可以看上面例子中的j_result對(duì)象。
最后就是json::diff方法，它是用來(lái)計(jì)算2個(gè)json對(duì)象的差值，生成補(bǔ)丁。傳遞進(jìn)該函數(shù)的2個(gè)json對(duì)象，補(bǔ)丁就是第一個(gè)json對(duì)象到第二個(gè)json對(duì)象的補(bǔ)丁，所以在上面例子中，我們對(duì)j_result合并j_diff補(bǔ)丁，又可以回到最開(kāi)始的json對(duì)象。
或許你可能覺(jué)得json指針有點(diǎn)太難用了，在前面我們也看見(jiàn)了，其實(shí)patch也是一個(gè)json對(duì)象，所以該庫(kù)還支持直接使用json對(duì)象來(lái)進(jìn)行合并補(bǔ)丁，這種場(chǎng)景非常適合配置文件的迭代，比如下面代碼：
//多了一個(gè)配置項(xiàng)head，已有的配置項(xiàng)的值為默認(rèn)值
json j_new_config = {
{"name", "modbus"},
{"config",{
{"type", ""},
{"startIndex", 0}}
},
{"head", 10}
};
std::cout << "j_new_config:" << j_new_config.dump(4) << std::endl;
//舊的配置項(xiàng)，已經(jīng)有值了
json j_old_config = {
{"name", "modbus"},
{"config", {
{"type", "floatlh"},
{"startIndex", 17}}
}
};
std::cout << "j_old_config:" << j_old_config.dump(4) << std::endl;
j_new_config.merge_patch(j_old_config);
std::cout << "result:" << j_new_config.dump(4) << std::endl;
//輸出結(jié)果
j_new_config:{
"config": {
"startIndex": 0,
"type": ""
},
"head": 10,
"name": "modbus"
}
j_old_config:{
"config": {
"startIndex": 17,
"type": "floatlh"
},
"name": "modbus"
}
result:{
"config": {
"startIndex": 17,
"type": "floatlh"
},
"head": 10,
"name": "modbus"
}
在上面代碼中，假如j_old_config是已經(jīng)運(yùn)行的配置項(xiàng)，而j_new_config是這次版本升級(jí)后的新的配置項(xiàng)，其中多了一個(gè)字段head，且其他配置項(xiàng)都是默認(rèn)值，經(jīng)過(guò)把舊的配置文件合并到新的配置文件中，我們可以看到最終合并后的配置文件，即含有head字段，也有舊的配置，這樣就完成了配置文件的升級(jí)。
5. 任意類(lèi)型轉(zhuǎn)換
在前面說(shuō)過(guò)，對(duì)于支持的類(lèi)型可以隱式的轉(zhuǎn)換為json中的值，但是當(dāng)從json值獲取值時(shí)，不建議使用隱式轉(zhuǎn)換，建議使用顯示的方式。比如下面代碼：
//推薦寫(xiě)法
std::string s1 = "Hello World";
json js = s1;
auto s2 = js.template get<std::string>();
//不推薦寫(xiě)法
std::string s3 = js;
這里有一個(gè)寫(xiě)法是template get<std::string>()，其實(shí)也就是模板成員函數(shù)調(diào)用的寫(xiě)法。
5.1 直接寫(xiě)法
我們研究json序列化庫(kù)的最終目的是想把任何類(lèi)型都可以進(jìn)行序列化和反序列化，通過(guò)前面的學(xué)習(xí)，我們可以大概知道如何把任意一個(gè)類(lèi)類(lèi)型轉(zhuǎn)成json對(duì)象，以及從json對(duì)象轉(zhuǎn)變?yōu)轭?lèi)類(lèi)型對(duì)象。直接看代碼：
Student s = {"jack", 18};
//類(lèi)類(lèi)型對(duì)象轉(zhuǎn)換為json對(duì)象
json j;
j["name"] = s.name;
j["age"] = s.age;
//json對(duì)象轉(zhuǎn)換為類(lèi)類(lèi)型對(duì)象
Student s1 {j["name"].template get<std::string>(), j["age"].template get<int>()};
這里我們定義一個(gè)Student類(lèi)型，通過(guò)前面所學(xué)的json操作，很容易寫(xiě)出這樣代碼，但是這種代碼有點(diǎn)冗余。
5.2 from_json和to_json
其實(shí)我們可以把序列化和反序列化的操作寫(xiě)在類(lèi)中，也就是讓該類(lèi)擁有了該能力，這種寫(xiě)法如下：
#ifndef STUDENT_H
#define STUDENT_H
#include <string>
#include "json.hpp"
#include <iostream>
using json = nlohmann::json;
struct Student
{
std::string name;
int age;
};
void to_json(json& j, const Student& s) {
j = json{ {"name", s.name}, {"age", s.age} };
}
void from_json(const json& j, Student& s) {
j.at("name").get_to(s.name);
j.at("age").get_to(s.age);
}
#endif // STUDENT_H
直接在定義類(lèi)的頭文件中多定義2個(gè)方法，分別為to_json和from_json，然后使用如下：
Student s = {"jack", 18};
//類(lèi)類(lèi)型對(duì)象轉(zhuǎn)換為json對(duì)象
json j = s;
std::cout << "j:" << j.dump(4) << std::endl;
//json對(duì)象轉(zhuǎn)換為類(lèi)類(lèi)型對(duì)象
auto s2 = j.template get<Student>();
這里也是非常容易理解，當(dāng)調(diào)用json的構(gòu)造函數(shù)，參數(shù)是自定義類(lèi)型時(shí)，就會(huì)調(diào)用to_json方法；類(lèi)似的，當(dāng)調(diào)用template get<Type>()或者get_to(Type)時(shí)，這個(gè)from_json就會(huì)被調(diào)用。這里有幾點(diǎn)需要注意：
- 這些方法必須是公有的命名空間或者類(lèi)型的命令空間，否則庫(kù)無(wú)法定位它們。
- 這些方法必須是可訪問(wèn)的，不能是私有的等。
- 函數(shù)參數(shù)必須要注意，從上面例子可以看出，否則無(wú)法自動(dòng)定位它們。
- 自定義的類(lèi)型必須有且可以默認(rèn)構(gòu)造。
我們仔細(xì)思考一下這2個(gè)方法，其中to_json是根據(jù)類(lèi)對(duì)象構(gòu)造json對(duì)象，在前面我們說(shuō)了很多。但是from_json可能就會(huì)有問(wèn)題，比如json對(duì)象中缺少一些key，這時(shí)就會(huì)報(bào)錯(cuò)，因?yàn)樵L問(wèn)不到，比如下面代碼：
json j = {
{"name", "jack"}
};
//json對(duì)象轉(zhuǎn)換為類(lèi)類(lèi)型對(duì)象
auto s2 = j.template get<Student>();
這個(gè)j對(duì)象就沒(méi)有age，然后調(diào)用from_json時(shí)就會(huì)出錯(cuò)，這里會(huì)直接拋出異常，有沒(méi)有其他辦法不拋出異常呢？還是有的，可以通過(guò)value方法進(jìn)行：
void from_json(const json& j, Student& s) {
s.name = j.value("name", "");
s.age = j.value("age", 0);
}
當(dāng)json對(duì)象中沒(méi)有某個(gè)鍵時(shí)，可以通過(guò)該方法設(shè)置一個(gè)默認(rèn)值。
5.3 使用宏
上面代碼可能還不夠簡(jiǎn)潔，這里可以更加容易，如果想序列化后的字段和原來(lái)類(lèi)類(lèi)型字段一樣，可以使用宏來(lái)默認(rèn)實(shí)現(xiàn)，這里有2個(gè)宏，一個(gè)是NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE用于class或者struct對(duì)象其成員都是public的情況，還可以使用有侵入式的NLOHMANN_DEFINE_TYPE_INTRUSIVE來(lái)訪問(wèn)private成員。使用宏的話，整個(gè)使用就非常簡(jiǎn)單了，測(cè)試代碼如下：
struct Student
{
std::string name;
int age;
NLOHMANN_DEFINE_TYPE_INTRUSIVE(Student, name, age)
};
struct Teacher {
std::vector<Student> students;
std::string name;
std::string subject;
NLOHMANN_DEFINE_TYPE_INTRUSIVE(Teacher, students, name, subject)
};
//使用
Student s1 {"zs", 11};
Student s2 {"ls", 13};
Teacher t;
t.name = "wang";
t.subject = "math";
t.students.push_back(s1);
t.students.push_back(s2);
json j = t;
std::cout << "j:" << j.dump(4) << std::endl;
Teacher t1 = j.template get<Teacher>();
只需要在宏里面寫(xiě)好類(lèi)名，以及需要序列化的成員即可。
5.4 枚舉類(lèi)
在自定義類(lèi)型的序列化中，枚舉類(lèi)型需要額外關(guān)注，默認(rèn)情況下枚舉會(huì)被序列化為int值，因?yàn)槊杜e本身保存的也就是int值。但是，在序列化和反序列化中，這種邏輯可能出現(xiàn)問(wèn)題。比如現(xiàn)在有枚舉類(lèi)如下：
enum TaskState{
TS_STOPPED, //0
TS_RUNNING, //1
TS_COMPLETED, //2
TS_INVALID = -1
};
這里我們把TS_INVALID賦值為-1，表示無(wú)效，其他枚舉值會(huì)按照規(guī)范依次被賦值為0、1和2，不論我們打印還是默認(rèn)序列化，TS_STOPPED的值都是0：
std::cout << TS_STOPPED << std::endl; //輸出結(jié)果 0
假如后面項(xiàng)目變化，需要新增一種枚舉，如下：
enum TaskState{
TS_TEMP, //0
TS_STOPPED, //1
TS_RUNNING, //2
TS_COMPLETED, //3
TS_INVALID = -1
};
這時(shí)TS_TEMP就會(huì)變成0，假如我們有一個(gè)舊對(duì)象序列化后的json保存在文件里，舊的json中保存的還是0，經(jīng)過(guò)反序列化后0會(huì)被反序列化為T(mén)S_TEMP，而不是預(yù)期的TS_STOPPED了，這就是默認(rèn)使用int作為枚舉值的弊端。
在該庫(kù)中，我們可以更加精確地指定給定枚舉如何映射到j(luò)son以及如何從json映射，使用NLOHMANN_JSON_SERIALIZE_ENUM宏，代碼如下：
enum TaskState{
TS_STOPPED, //0
TS_RUNNING, //1
TS_COMPLETED, //2
TS_INVALID = -1
};
NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
{TS_INVALID, nullptr},
{TS_STOPPED, "stopped"},
{TS_RUNNING, "running"},
{TS_COMPLETED, "completed"}
})
該宏就是可以聲明在to_json()和from_json()時(shí)枚舉所對(duì)應(yīng)的字符串，這樣不使用默認(rèn)的int來(lái)保存，就大大提高了程序的穩(wěn)定性：
json j = TS_STOPPED;
assert(j == "stopped");
json j3 = "running";
assert(j3.template get<TaskState>() == TS_RUNNING);
上述代碼可以正常運(yùn)行，說(shuō)明TS_RUNNING在序列化時(shí)變成了running，假如我們新增了一種枚舉，只要使用宏包括進(jìn)來(lái)：
enum TaskState{
TS_TEMP,
TS_STOPPED, //0
TS_RUNNING, //1
TS_COMPLETED, //2
TS_INVALID = -1
};
NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
{TS_INVALID, nullptr},
{TS_STOPPED, "stopped"},
{TS_RUNNING, "running"},
{TS_COMPLETED, "completed"},
{TS_TEMP, "temp"}
})
上述代碼依舊可以執(zhí)行成功，不會(huì)出現(xiàn)反序列化錯(cuò)誤的情況。
這里有一點(diǎn)需要特別注意，就是在宏NLOHMANN_JSON_SERIALIZE_ENUM的定義中，我們把默認(rèn)的無(wú)效枚舉TS_INVALID定義在第一個(gè)，這個(gè)是有特殊意義的，假如json中的值未定義，無(wú)法反序列化為任何一種枚舉，就會(huì)被反序列化為這個(gè)默認(rèn)值，代碼如下：
json jPi = 3.14;
assert(jPi.template get<TaskState>() == TS_INVALID);
上面的3.14屬于未定義的枚舉值，在這種情況下會(huì)默認(rèn)反序列化為默認(rèn)值。
以上就是C++開(kāi)源庫(kù)nlohmann/json的介紹和使用詳解的詳細(xì)內(nèi)容，更多關(guān)于C++ nlohmann/json的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
C語(yǔ)言中atoi函數(shù)模擬實(shí)現(xiàn)詳析
atoi函數(shù)功能是將數(shù)字字符串轉(zhuǎn)換為整數(shù),比如數(shù)字字符串"12345"被atoi轉(zhuǎn)換為12345,數(shù)字字符串"-12345"被轉(zhuǎn)換為-12345,下面這篇文章主要給大家介紹了關(guān)于C語(yǔ)言中atoi函數(shù)模擬實(shí)現(xiàn)的相關(guān)資料,需要的朋友可以參考下2022-10-10
C語(yǔ)言數(shù)據(jù)結(jié)構(gòu)中二分查找遞歸非遞歸實(shí)現(xiàn)并分析
這篇文章主要介紹了C語(yǔ)言數(shù)據(jù)結(jié)構(gòu)中二分查找遞歸非遞歸實(shí)現(xiàn)并分析的相關(guān)資料,需要的朋友可以參考下2017-03-03
這篇文章主要為大家詳細(xì)介紹了C++調(diào)用Matlab函數(shù)求特征值，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2019-06-06
本篇文章對(duì)c++中默認(rèn)拷貝函數(shù)的使用進(jìn)行了詳細(xì)的分析介紹。需要的朋友參考下2013-05-05
本文主要介紹了C++菱形繼承和虛繼承的實(shí)現(xiàn)，文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2023-06-06
C++中如何將operator==定義為類(lèi)的成員函數(shù)
這篇文章主要介紹了C++中如何將operator==定義為類(lèi)的成員函數(shù)，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2023-01-01
C++通過(guò) public、protected、private 三個(gè)關(guān)鍵字來(lái)控制成員變量和成員函數(shù)的訪問(wèn)權(quán)限(也稱(chēng)為可見(jiàn)性),下面這篇文章主要給大家介紹了關(guān)于C++中訪問(wèn)權(quán)限的相關(guān)資料,需要的朋友可以參考下2021-07-07
用C語(yǔ)言實(shí)現(xiàn)一個(gè)掃雷小游戲
這篇文章主要為大家詳細(xì)介紹了用C語(yǔ)言實(shí)現(xiàn)一個(gè)掃雷小游戲，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2021-09-09
QT基于TCP實(shí)現(xiàn)文件傳輸系統(tǒng)
這篇文章主要為大家詳細(xì)介紹了QT基于TCP實(shí)現(xiàn)文件傳輸系統(tǒng)，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2022-08-08
在C++中，關(guān)鍵字const可以用來(lái)修飾任何作用域內(nèi)的變量、函數(shù)參數(shù)、函數(shù)本體、函數(shù)返回值、成員函數(shù)、迭代器，也可以用來(lái)修飾指針本身和指針目標(biāo)，可謂多才多藝，我們要詳細(xì)了解其內(nèi)部細(xì)節(jié)，以及邏輯奧秘，讓這把多功能瑞士軍刀盡情發(fā)揮其作用,需要的朋友可以參考一下2021-09-09