nlohmann json for modern C++

【1】作者简介

【2】库

https://github.com/nlohmann/json

【3】应用示例

（1）工程配置

（2）示例代码

#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <iomanip>

// 为了调试中文显示
#pragma execution_character_set("utf-8")

#include "nlohmann/json.hpp"
// for convenience
using json = nlohmann::json;

void json_object()
{
    // create a JSON object
    json j =
    {
        {"pi", 3.141},
        {"happy", true},
        {"name", "Niels"},
        {"nothing", nullptr},
        {
            "answer", {
                {"everything", 42}
            }
        },
        {"list", {1, 0, 2}},
        {
            "object", {
                {"currency", "USD"},
                {"value", 42.99}
            }
        }
    };

    // add new values
    j["new"]["key"]["value"] = { "another", "list" };

    // count elements
    auto s = j.size();
    j["size"] = s;

    // pretty print with indent of 4 spaces
    std::cout << std::setw(4) << j << '
';

    // create JSON values
    json j_boolean = true;
    json j_number_integer = 17;
    json j_number_float = 23.42;
    json j_object = { {"one", 1}, {"two", 2} };
    json j_object_empty(json::value_t::object);
    json j_array = { 1, 2, 4, 8, 16 };
    json j_array_empty(json::value_t::array);
    json j_string = "Hello, world";

    // call back()
    std::cout << j_boolean.back() << '
';
    std::cout << j_number_integer.back() << '
';
    std::cout << j_number_float.back() << '
';
    std::cout << j_object.back() << '
';
    //std::cout << j_object_empty.back() << '
';  // undefined behavior
    std::cout << j_array.back() << '
';
    //std::cout << j_array_empty.back() << '
';   // undefined behavior
    std::cout << j_string.back() << '
';

    // back() called on a null value
    try
    {
        json j_null;
        j_null.back();
    }
    catch (json::invalid_iterator & e)
    {
        std::cout << e.what() << '
';
    }
}

void json_arry()
{
    // create JSON arrays
    json j_no_init_list = json::array();
    json j_empty_init_list = json::array({});
    json j_nonempty_init_list = json::array({ 1, 2, 3, 4 });
    json j_list_of_pairs = json::array({ {"one", 1}, {"two", 2} });

    // serialize the JSON arrays
    std::cout << j_no_init_list << '
';
    std::cout << j_empty_init_list << '
';
    std::cout << j_nonempty_init_list << '
';
    std::cout << j_list_of_pairs << '
';
}

void json_object_at_key()
{
    // create JSON object
    json object =
    {
        {"the good", "il buono"},
        {"the bad", "il cattivo"},
        {"the ugly", "il brutto"}
    };

    // output element with key "the ugly"
    std::cout << object.at("the ugly") << '
';

    // change element with key "the bad"
    object.at("the bad") = "liuy kaizen";
    object.at("the good") = 100;

    // output changed array
    std::cout << object << '
';

    // exception type_error.304
    try
    {
        // use at() on a non-object type
        json j_str = "I am a string";
        std::cout << j_str << '
';
        j_str.at("the good") = "Another string";

        const json jc_str = "I am a const json object";
        std::cout << jc_str << "
";
        // jc_str.at("the good") = "Const string"; const对象，禁止赋值
    }
    catch (json::type_error & e)
    {
        std::cout << e.what() << '
';
    }

    // exception out_of_range.401
    try
    {
        // try to write at a nonexisting key
        object.at("the fast") = "il rapido";
    }
    catch (json::out_of_range & e)
    {
        std::cout << e.what() << '
';
    }
}

void json_array_at_index()
{
    // create JSON array
    json array = { "first", "2nd", "third", "fourth" };

    // output element at index 2 (third element)
    std::cout << array.at(2) << '
';

    // change element at index 1 (second element) to "second"
    array.at(1) = "second";

    // output changed array
    std::cout << array << '
';

    // exception type_error.304
    try
    {
        // use at() on a non-array type
        json str = "I am a string";
        str.at(0) = "Another string";
    }
    catch (json::type_error & e)
    {
        std::cout << e.what() << '
';
    }

    // exception out_of_range.401
    try
    {
        // try to write beyond the array limit
        array.at(5) = "sixth";
    }
    catch (json::out_of_range & e)
    {
        std::cout << e.what() << '
';
    }
}

void json_at_pointer()
{
    // create a JSON value
    json j =
    {
        {"number", 1}, {"string", "foo"}, {"array", {1, 2}}
    };

    // read-only access

    // output element with JSON pointer "/number"
    std::cout << j.at("/number"_json_pointer) << '
';
    // output element with JSON pointer "/string"
    std::cout << j.at("/string"_json_pointer) << '
';
    // output element with JSON pointer "/array"
    std::cout << j.at("/array"_json_pointer) << '
';
    // output element with JSON pointer "/array/0"
    std::cout << j.at("/array/0"_json_pointer) << '
';
    // output element with JSON pointer "/array/1"
    std::cout << j.at("/array/1"_json_pointer) << '
';

    // writing access

    // change the string
    j.at("/string"_json_pointer) = "bar";
    // output the changed string
    std::cout << j["string"] << '
';

    // change an array element
    j.at("/array/1"_json_pointer) = 21;
    // output the changed array
    std::cout << j["array"] << '
';

    // out_of_range.106
    try
    {
        // try to use an array index with leading '0'
        json::reference ref = j.at("/array/01"_json_pointer);
    }
    catch (json::parse_error & e)
    {
        std::cout << e.what() << '
';
    }

    // out_of_range.109
    try
    {
        // try to use an array index that is not a number
        json::reference ref = j.at("/array/one"_json_pointer);
    }
    catch (json::parse_error & e)
    {
        std::cout << e.what() << '
';
    }

    // out_of_range.401
    try
    {
        // try to use a an invalid array index
        json::reference ref = j.at("/array/4"_json_pointer);
    }
    catch (json::out_of_range & e)
    {
        std::cout << e.what() << '
';
    }

    // out_of_range.402
    try
    {
        // try to use the array index '-'
        json::reference ref = j.at("/array/-"_json_pointer);
    }
    catch (json::out_of_range & e)
    {
        std::cout << e.what() << '
';
    }

    // out_of_range.403
    try
    {
        // try to use a JSON pointer to an nonexistent object key
        json::const_reference ref = j.at("/foo"_json_pointer);
    }
    catch (json::out_of_range & e)
    {
        std::cout << e.what() << '
';
    }

    // out_of_range.404
    try
    {
        // try to use a JSON pointer that cannot be resolved
        json::reference ref = j.at("/number/foo"_json_pointer);
    }
    catch (json::out_of_range & e)
    {
        std::cout << e.what() << '
';
    }
}

void json_compare()
{
    // create a JSON array
    json j1 = { "one", "two", 3, 4.5, false };

    // create a copy
    json j2(j1);

    // serialize the JSON array
    std::cout << j1 << " = " << j2 << '
';
    std::cout << std::boolalpha << (j1 == j2) << '
';
}

void json_list_init()
{
    // create JSON values
    json j_empty_init_list = json({});
    json j_object = { {"one", 1}, {"two", 2} };
    json j_array = { 1, 2, 3, 4 };
    json j_nested_object = { {"one", {1}}, {"two", {1, 2}} };
    json j_nested_array = { {{1}, "one"}, {{1, 2}, "two"} };

    // serialize the JSON value
    std::cout << j_empty_init_list << '
';    // {}
    std::cout << j_object << '
';             // {"one":1,"two":2}
    std::cout << j_array << '
';              // [1,2,3,4]
    std::cout << j_nested_object << '
';      // {"one":[1],"two":[1,2]}
    std::cout << j_nested_array << '
';       // [[[1],"one"],[1,2],"two"]
}

void json_move_constructor()
{
    // create a JSON value
    json a = 23;

    // move contents of a to b
    json b(std::move(a));

    // serialize the JSON arrays
    std::cout << a << '
';    // null
    std::cout << b << '
';    // 23
}

void json_copy_assignment()
{
    // create JSON values
    json a = 23;
    json b = 42;

    // copy-assign a to b
    b = a;

    // serialize the JSON arrays
    std::cout << a << '
';    // 23
    std::cout << b << '
';    // 23
}

void json_nullptr_t()
{
    // implicitly create a JSON null value
    json j1;

    // explicitly create a JSON null value
    json j2(nullptr);

    // serialize the JSON null value
    std::cout << j1 << '
' << j2 << '
';   // null    null s
}

void json_basic_type_value()
{
    // create a JSON object with different entry types
    json j =
    {
        {"integer", 1},
        {"floating", 42.23},
        {"string", "hello world"},
        {"boolean", true},
        {"object", {{"key1", 1}, {"key2", 2}}},
        {"array", {1, 2, 3}}
    };

    // access existing values
    int v_integer = j.value("integer", 0);
    double v_floating = j.value("floating", 47.11);

    // access nonexisting values and rely on default value
    std::string v_string = j.value("nonexisting", "oops");
    bool v_boolean = j.value("nonexisting", false);

    // output values
    std::cout << std::boolalpha << "
";     // 1
    std::cout << v_integer << "
";          // 1
    std::cout << v_floating << "
";         // 42.23
    std::cout << v_string << "
";           // oops
    std::cout << v_boolean << "
";          // false
}

void json_basic_value_t()
{
    // create the different JSON values with default values
    json j_null(json::value_t::null);
    json j_boolean(json::value_t::boolean);
    json j_number_integer(json::value_t::number_integer);
    json j_number_float(json::value_t::number_float);
    json j_object(json::value_t::object);
    json j_array(json::value_t::array);
    json j_string(json::value_t::string);

    // serialize the JSON values
    std::cout << j_null << '
';            // null
    std::cout << j_boolean << '
';         // false
    std::cout << j_number_integer << '
';  // 0
    std::cout << j_number_float << '
';    // 0.0
    std::cout << j_object << '
';          // {}
    std::cout << j_array << '
';           // []
    std::cout << j_string << '
';          // ""
}

void json_iterator()
{
    // create an array value
    json array = { 1, 2, 3, 4, 5 };

    // get am iterator to the first element
    json::iterator itor = array.begin();

    // serialize the element that the iterator points to
    std::cout << *itor << '
';    // 1

    // create an array using push_back
    json j;
    j.push_back("foo");
    j.push_back(1);
    j.push_back(true);

    // also use emplace_back
    j.emplace_back(1.78);

    // iterate the array
    for (json::iterator it = j.begin(); it != j.end(); ++it)
    {
        std::cout << *it << '
';
    }

    // range-based for
    for (auto& element : j) 
    {
        std::cout << element << '
';
    }

    // getter/setter
    const auto tmp = j[0].get<std::string>();
    j[1] = 42;
    bool foo = j.at(2);

    // comparison
    j == "["foo", 42, true]"_json;  // true

    // other stuff
    j.size();     // 3 entries
    j.empty();    // false
    j.type();     // json::value_t::array
    j.clear();    // the array is empty again

    // convenience type checkers
    j.is_null();
    j.is_boolean();
    j.is_number();
    j.is_object();
    j.is_array();
    j.is_string();

    // create an object
    json o;
    o["foo"] = 23;
    o["bar"] = false;
    o["baz"] = 3.141;

    // also use emplace
    o.emplace("weather", "sunny");

    // special iterator member functions for objects
    for (json::iterator it = o.begin(); it != o.end(); ++it) 
    {
        std::cout << it.key() << " : " << it.value() << "
";
    }

    // the same code as range for
    for (auto& el : o.items()) 
    {
        std::cout << el.key() << " : " << el.value() << "
";
    }

#if 0
    // even easier with structured bindings (C++17)
    for (auto& [key, value] : o.items()) 
    {
        std::cout << key << " : " << value << "
";
    }
#endif

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

    // or simpler using count()
    int foo_present = o.count("foo"); // 1
    int fob_present = o.count("fob"); // 0

    // delete an entry
    o.erase("foo");
}

void json_serialization_deserialization()
{
    // create object from string literal
    json j = "{ "happy": true, "pi": 3.141 }"_json;

    // or even nicer with a raw string literal
    auto j2 = R"(
    {
        "man": false,
        "love": 1314
     })"_json;

    std::string s = j.dump();
    std::cout << s << std::endl;
    std::cout << j.dump(4) << std::endl;

    std::string s2 = j2.dump();
    std::cout << s2 << std::endl;
    std::cout << j2.dump(4) << std::endl;

    auto j3 = json::parse("{ "happy": false, "pi": 3.141 }");
    std::cout << j3.dump() << std::endl;

    // store a string in a JSON value
    json j_string = "this is a string";

    // retrieve the string value
    auto cpp_string = j_string.get<std::string>();
    // retrieve the string value (alternative when an variable already exists)
    std::string cpp_string2;
    j_string.get_to(cpp_string2);

    // retrieve the serialized value (explicit JSON serialization)
    std::string serialized_string = j_string.dump();

    // output of original string
    std::cout << cpp_string << " == " << cpp_string2 << " == " << j_string.get<std::string>() << '
';
    // output of serialized value
    std::cout << j_string << " == " << serialized_string << std::endl;
}

void json_read_write_file()
{
    std::string json_read_path = "F:/study_nlohmanjson/nlohmannjson/nlohmannjson/json_demo.json";
    std::string json_write_path = "F:/study_nlohmanjson/nlohmannjson/nlohmannjson/json_write.json";

    std::ifstream ifile(json_read_path);
    json j;
    ifile >> j;

    std::cout << j.dump(4) << std::endl;

    std::ofstream ofile(json_write_path);
    ofile << std::setw(4) << j << std::endl;
}

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

    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);
    }
}

void json_custom_types_conversions()
{
    ns_person::person p = { "Ned Flanders", "744 Evergreen Terrace", 60 };

    // convert to JSON: copy each value into the JSON object
    json j;
    j["name"] = p.name;
    j["address"] = p.address;
    j["age"] = p.age;

    // convert from JSON: copy each value from the JSON object
    ns_person::person p2{
        j["name"].get<std::string>(),
        j["address"].get<std::string>(),
        j["age"].get<int>()
    };

    // create a person
    ns_person::person p3{ "Ned Flanders", "744 Evergreen Terrace", 60 };

    // conversion: person -> json
    json j3 = p3;

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

    // conversion: json -> person
    auto p4 = j3.get<ns_person::person>();
}

int main()
{
    // [1] json as first-class data type
    // json_object();

    // [2] json array
    // json_arry();

    // [3] json_object_at_key
    // json_object_at_key();

    // [4] json_array_at_index
    // json_array_at_index();

    // [5] json_at_pointer
    // json_at_pointer();

    // [6] json_compare
    // json_compare();

    // [7] json_list_init
    // json_list_init();

    // [8] json_move_constructor
    // json_move_constructor();

    // [9] json_copy_assignment
    // json_copy_assignment();

    // [10] json_nullptr_t
    // json_nullptr_t();

    // [11] json_basic_type_value
    // json_basic_type_value();

    // [12] json_basic_value_t
    // json_basic_value_t();

    // [13] json_iterator
    // json_iterator();

    // [14] serialization/deserialization
    // json_serialization_deserialization();

    // [15] json_read_write_file
    // json_read_write_file();

    // [16] json_custom_types_conversions
    json_custom_types_conversions();

    system("pause");
}

good good study, day day up.

顺序 选择 循环 总结