C++ JSON库 nlohmann::basic_json::at 的用法

最新推荐文章于 2024-05-28 17:59:08 发布
最新推荐文章于 2024-05-28 17:59:08 发布
阅读量1.4k 收藏 1
点赞数 2
文章标签： 开发语言 c++ c语言 qt6 C++11 嵌入式 linux
原文链接：https://json.nlohmann.me/api/basic_json/at
版权

简介

nlohmann::basic_json::at 是一个成员函数，用于访问 nlohmann::json 对象中的元素。这个函数提供了一种安全的方式来访问 JSON 对象的元素，如果试图访问不存在的元素，它会抛出一个类型为 nlohmann::json::out_of_range 的异常。

这个函数有两个版本：

  1. T& at(KeyT&& key): 这个版本用于非常量 JSON 对象，返回一个指向指定键的元素的引用。如果元素不存在，它会抛出一个 nlohmann::json::out_of_range 异常。

  2. const T& at(KeyT&& key) const: 这个版本用于常量 JSON 对象，返回一个指向指定键的元素的常量引用。如果元素不存在，它也会抛出一个 nlohmann::json::out_of_range 异常。

这里的 KeyT 是键的类型，对于 JSON 对象，它是一个字符串；对于 JSON 数组，它是一个大小类型的索引。

以下是一个使用 nlohmann::json::at 的例子：

#include <iostream>
#include <nlohmann/json.hpp>

int main() {
    // 创建一个 JSON 对象
    nlohmann::json j = {{"name", "John"}, {"age", 30}, {"city", "New York"}};

    try {
        // 使用 at() 访问元素
        std::string name = j.at("name");
        std::cout << "Name: " << name << std::endl;
    } catch (nlohmann::json::exception& e) {
        // 捕获并打印任何抛出的异常
        std::cout << "Exception: " << e.what() << std::endl;
    }

    return 0;
}

在这个例子中，我们创建了一个包含三个元素的 JSON 对象，然后使用 at() 函数来访问 “name” 键的元素。如果 “name” 键不存在，at() 函数会抛出一个异常，我们可以捕获这个异常并打印出错误信息。

nlohmann::basic_json::at 官网介绍

// (1)
reference at(size_type idx);
const_reference at(size_type idx) const;

// (2)
reference at(const typename object_t::key_type& key);
const_reference at(const typename object_t::key_type& key) const;

// (3)
template<typename KeyType>
reference at(KeyType&& key);
template<typename KeyType>
const_reference at(KeyType&& key) const;

// (4)
reference at(const json_pointer& ptr);
const_reference at(const json_pointer& ptr) const;

这个函数返回一个对指定位置 idx 的数组元素的引用，有边界检查。

返回一个对具有指定键 key 的对象元素的引用，有边界检查。

如果 KeyType 与 typename object_t::key_type 可比，并且 typename object_comparator_t::is_transparent 表示一种类型，那么这个重载就可用。

返回一个对指定 JSON 指针 ptr 指向的元素的引用，有边界检查。

模板参数

  • KeyType：除 json_pointer 之外的与 string_t 使用 object_comparator_t 可比的对象键的类型。这也可以是字符串视图（C++17）。

参数

  • idx（输入）：要访问的元素的索引
  • key（输入）：要访问的元素的对象键
  • ptr（输入）：指向所需元素的 JSON 指针

返回值

  • 对索引 idx 处的元素的引用
  • 对键 key 处的元素的引用
  • 对键 key 处的元素的引用
  • 对 ptr 指向的元素的引用

异常安全性

强异常安全：如果发生异常，原始值保持不变。

异常

函数可能抛出以下异常：

  • 如果 JSON 值不是数组，则抛出 type_error.304；在这种情况下，使用索引调用 at 没有意义。参见下面的示例。
  • 如果索引 idx 超出数组的范围，即 idx >= size()，则抛出 out_of_range.401。参见下面的示例。

函数可能抛出以下异常：

  • 如果 JSON 值不是对象，则抛出 type_error.304；在这种情况下，使用键调用 at 没有意义。参见下面的示例。
  • 如果对象中没有存储键 key，即 find(key) == end()，则抛出 out_of_range.403。参见下面的示例。

参见 2。

函数可能抛出以下异常：

  • 如果传递的JSON指针PTR中的数组索引以‘0’开头，则引发parse_error.106。请参见下面的示例。
  • 如果传递的JSON指针PTR中的数组索引不是数字，则抛出parse_error.109。请参见下面的示例。
  • 如果传递的JSON指针ptr中的数组索引超出范围，则抛出out_of_range.401。请参见下面的示例。
  • 如果在传递的JSON指针PTR中使用数组索引‘-’，则抛出out_of_range.402。由于AT提供了经过检查的访问(并且没有隐式插入任何元素)，因此索引‘-’总是无效的。请参见下面的示例。
  • 如果JSON指针描述了找不到的对象的键，则抛出out_of_range.403。请参见下面的示例。
  • 如果无法解析JSON指针PTR，则抛出Out_Of_range.404。请参见下面的示例。

复杂性

  • 一成不变。
  • 容器大小的对数。

示例

Example: (1) access specified array element with bounds checking

The example below shows how array elements can be read using at(). It also demonstrates the different exceptions that can be thrown.

#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main()
{
    // create JSON array
    const json array = {"first", "2nd", "third", "fourth"};

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


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

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

Output:

"third"
[json.exception.type_error.304] cannot use at() with string
[json.exception.out_of_range.401] array index 5 is out of range

Example: (2) access specified object element with bounds checking

The example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.

#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main()
{
    // create JSON object
    const 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") << '\n';


    // exception type_error.304
    try
    {
        // use at() on a non-object type
        const json str = "I am a string";
        std::cout << str.at("the good") << '\n';
    }
    catch (json::type_error& e)
    {
        std::cout << e.what() << '\n';
    }

    // exception out_of_range.401
    try
    {
        // try to read from a nonexisting key
        std::cout << object.at("the fast") << '\n';
    }
    catch (json::out_of_range)
    {
        std::cout << "out of range" << '\n';
    }
}

Output:

"il brutto"
[json.exception.type_error.304] cannot use at() with string
out of range

Example: (3) access specified object element using string_view with bounds checking

The example below shows how object elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.

#include <iostream>
#include <string_view>
#include <nlohmann/json.hpp>

using namespace std::string_view_literals;
using json = nlohmann::json;

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

    // output element with key "the ugly" using string_view
    std::cout << object.at("the ugly"sv) << '\n';

    // change element with key "the bad" using string_view
    object.at("the bad"sv) = "il cattivo";

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


    // exception type_error.304
    try
    {
        // use at() with string_view on a non-object type
        json str = "I am a string";
        str.at("the good"sv) = "Another string";
    }
    catch (json::type_error& e)
    {
        std::cout << e.what() << '\n';
    }

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


"il brutto"
{"the bad":"il cattivo","the good":"il buono","the ugly":"il brutto"}
[json.exception.type_error.304] cannot use at() with string
[json.exception.out_of_range.403] key 'the fast' not found
Example: (3) access specified object element using string_view with bounds checking
The example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.


#include <iostream>
#include <string_view>
#include <nlohmann/json.hpp>

using namespace std::string_view_literals;
using json = nlohmann::json;

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

    // output element with key "the ugly" using string_view
    std::cout << object.at("the ugly"sv) << '\n';


    // exception type_error.304
    try
    {
        // use at() with string_view on a non-object type
        const json str = "I am a string";
        std::cout << str.at("the good"sv) << '\n';
    }
    catch (json::type_error& e)
    {
        std::cout << e.what() << '\n';
    }

    // exception out_of_range.401
    try
    {
        // try to read from a nonexisting key using string_view
        std::cout << object.at("the fast"sv) << '\n';
    }
    catch (json::out_of_range)
    {
        std::cout << "out of range" << '\n';
    }
}

Output:

"il brutto"
[json.exception.type_error.304] cannot use at() with string
out of range

Example: (4) access specified element via JSON Pointer

The example below shows how object elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.

#include <iostream>
#include <nlohmann/json.hpp>

using json = nlohmann::json;
using namespace nlohmann::literals;

int main()
{
    // 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) << '\n';
    // output element with JSON pointer "/string"
    std::cout << j.at("/string"_json_pointer) << '\n';
    // output element with JSON pointer "/array"
    std::cout << j.at("/array"_json_pointer) << '\n';
    // output element with JSON pointer "/array/1"
    std::cout << j.at("/array/1"_json_pointer) << '\n';

    // writing access

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

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


    // 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() << '\n';
    }

    // 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() << '\n';
    }

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

    // 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() << '\n';
    }

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

    // 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() << '\n';
    }
}

Output:

1
"foo"
[1,2]
2
"bar"
[1,21]
[json.exception.parse_error.106] parse error: array index '01' must not begin with '0'
[json.exception.parse_error.109] parse error: array index 'one' is not a number
[json.exception.out_of_range.401] array index 4 is out of range
[json.exception.out_of_range.402] array index '-' (2) is out of range
[json.exception.out_of_range.403] key 'foo' not found
[json.exception.out_of_range.404] unresolved reference token 'foo'
nlohmann json：通过at读取及设置object和array
风静如云的博客
08-13 633
可以看到at可以通过键名读取object，通过索引读取array，并且也可以通过at对值进行设置。可以看到通过json_pointer可以通过路径直接进行访问，但是也要注意路径的有效性。
nlohmann json：通过items遍历object/array
风静如云的博客
08-12 3241
可以看到对于object可以通过key()和value()拿到键值对。key函数通过anchor返回的是const string类型的键值。通过结构化绑定，i直接被绑定到key，j直接被绑定到value的引用。value通过anchor返回的是json对象的引用。对于array来说key是索引，value为值。1.items返回的是代理的迭代器。可以看到age的值被成功修改了。age也被成功的修改了。
c++11:nlohmann::json进阶使用(三)使用basic_json模板类
10km的专栏
11-26 3425
nlohmann::json是非常好用的一个json开源解析库.nlohmann/json的源码是基于C++11标准写的，整个源码就是一个文件 nlohmann/json.hpp,引用非常方便。 关于nlohmann/json的基本使用官网(https://github.com/nlohmann/json)上有比较详细的介绍。这里不再赘述，本文主要是介绍在nlohmann/json的基本使用之外一些我在使用 nlohmann/json 用到的一些扩展功能和重要但不太被了解的特性。 我的上一篇博客里解决了第三
nlohmann::json用json[“xxx“]方式无法抛出异常，建议用json.at(“xxx“)（json.at()）
Dontla的博客
06-05 1826
nlohmann::json用json[“xxx”]方式无法抛出异常，建议用json.at(“xxx”)
C++ JSON库 nlohmann::basic_json::contains的用法
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-28 2505
`nlohmann::basic_json::contains` 是一个成员函数，用于检查 `nlohmann::json` 对象是否包含特定的键。`nlohmann::json` 是一个流行的 C++ JSON 库，由 Niels Lohmann 开发，用于处理 JSON 数据。
JSON basics
weixin_34221112的博客
06-14 104
2019独角兽企业重金招聘Python工程师标准>>> ...
nlohmann json C++ 解析
fuyouzhiyi的博客
05-28 1140
联合体用于高效存储不同类型的 JSON 值。定义一个枚举来表示 JSON 值的类型。
visual C++2015报错：error LNK2019: unresolved external symbol “public: __thiscall Json::Value::Value等
weixin_43803955的博客
08-12 1660
1>InfoAccessControl.obj : error LNK2019: unresolved external symbol "public: __thiscall Json::Value::Value(enum Json::ValueType)" (??0Value@Json@@QAE@W4ValueType@1@@Z) referenced in function "public: bool __thiscall AccessNode1::ReadJson(class std::basi
利用C++nlohmann库解析json文件
coder_Alger 的博客
08-10 823
利用C++nlohmann库解析json文件
C++ Boost JSON解析库使用,使用的是property_tree这个数据类型，它可以方便的解析XML和JSON
HanLongXia的博客
12-26 1638
C++ Boost JSON解析库的使用，Boost的JSON解析，使用的是property_tree这个数据类型，它可以方便的解析XML和JSON。
JSON_入门指南
07-22
资源名称：JSON_入门指南内容简介：      JSON 即 Javaｓｃｒｉｐｔ Object Natation，它是一种轻量级的数据交换格式，非常适合于服务器与 Javaｓｃｒｉｐｔ 的交互。本文将快速讲解 JSON 格式，并通过代码示例演示如何分别在客户端和服务器端进行 JSON 格式数据的处理。      JSON(Javaｓｃｒｉｐｔ Object Notation) 是一种轻量级的数 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
basic-json:一个非常简单、无依赖的 JSON 编码器
07-06
一个非常简单、无依赖的 JSON 编码器。 这个包实现了一个非常简单的 JSON 编码器，它对任何其他包的依赖为零，并且可以通过简单地将单个源文件放入您的项目并更改包名称来嵌入到您的应用程序中。 它也没有配置：只需将您的对象包装在 JSON 类中，并编码为字节。 这背后的动机是为需要发出 JSON 的各种日志框架实现日志记录“附加程序”，而不会在被检测的应用程序中引入更多依赖项，尤其是当包可能已经具有某些 JSON 处理器的冲突版本时。 现在它只是一个编码器； 如果您需要一个解码器，您可能正在做可以容纳“真实”JSON 处理器的事情。
C++ JSON库 nlohmann::basic_json::binary_t的用法
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-25 526
https://json.nlohmann.me/api/basic_json/binary_t/
C++ 调用json
sinat_41498648的博客
04-20 256
主要参考这篇：https://zhuanlan.zhihu.com/p/38105192 1、https://github.com/open-source-parsers/jsoncpp下载源码 2、跑里面的amalgamate.py文件，我这里是在anaconda的环境下跑的 3、将dist文件夹下的源码考出来放在新建vs工程就能用了，用的时候出现了问题 换成这样的写法 std::string filePath = "\\innerparam.json"; std::ofstream fout;
你所不知道的JSON.stringify
weixin_34268169的博客
08-17 156
译者按: 老司机们，你知道JSON.stringify还有第二个和第三个可选参数吗？它们是什么呢？ 原文: What you didn’t know about JSON.Stringify 译者: Fundebug 为了保证可读性，本文采用意译而非直译。另外，本文版权归原作者所有，翻译仅用于学习。 JSON...
JSON Basic Usage
弱菜学习记的博客
10-26 249
JSON Basic Usage 几个基本方法的docs翻译 json.dump() json.dumps() json.load() json.loads()
谷粒学院json at position 1
Begginxdd的博客
11-24 173
json at position 1错误的在第四步换成这个 this.loginInfo =response.data.data.userInfo this.loginInfo =JSON.stringify(response.data.data.userInfo)
C++ JSON库 nlohmann::basic_json::boolean_t 的用法
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-25 509
`nlohmann::basic_json::boolean_t` 是 `nlohmann::json` 库中的一个类型别名，用于表示 JSON 中的布尔值。
nlohmann json：类型检查
风静如云的博客
08-12 967
【代码】nlohmann json：类型检查。
nlohmann::json dump key值不排序
最新发布
01-18
### 使用 `nlohmann::json` 的 `dump` 方法保持键值顺序 为了确保 JSON 对象中的键值对按插入顺序保存，在使用 `nlohmann::json` 库时可以采用特定的数据结构来替代默认的无序映射。具体来说，可以通过自定义容器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值