Should json obj assignment to parent object work for emplace vs. []

[billpriest]

While running clang-tidy on my code that uses the excellent nlohmann Json it complains that using [] is unsafe
"possibly unsafe operator[]', consider bounds-safe alternatives
Below is test case showing what I am seeing. For simple json primitives emplace compiles and works equivalently to operator[].
Apologies if I am incorrectly expecting it to work or using the wrong method.

compiled with g++ -Wall -o jsontest jsontest.cpp
jsontest.cpp

#include <nlohmann/json.hpp>
#include <iostream>
int main(void)
{
    using Json = nlohmann::ordered_json;
    Json parentObj{};
    Json childObj{};

    childObj.emplace("key1", 1234);
#define fails
#ifdef fails
    parentObj.emplace("child", childObj);
#else
    parentObj["child"] = childObj;
#endif
    std::cout << parentObj.dump() << std::endl;

    return 0;
}

==============

[nlohmann]

Here is an overview of your options: https://json.nlohmann.me/features/element_access/

[1soka]

The [] version works because it copies, and emplace fails because of ordered_json specifically. With ordered_json the object is an nlohmann::ordered_map, and its emplace is declared as

std::pair<iterator, bool> emplace(const key_type& key, T&& t);

where T is the map's value type, not a template parameter. So T&& is a plain rvalue reference and only binds temporaries. childObj.emplace("key1", 1234) works because 1234 becomes a temporary ordered_json, but childObj is an lvalue, hence "cannot bind rvalue reference ... to lvalue". With plain nlohmann::json (std::map underneath) your exact code compiles, because std::map::emplace is variadic and copies.

So either pass an rvalue:

parentObj.emplace("child", std::move(childObj)); // childObj is moved from after this
parentObj.emplace("child", Json(childObj));      // explicit copy

or keep parentObj["child"] = childObj;. One behavior difference to keep in mind: emplace does nothing if the key already exists (it returns {it, false}), while operator[] overwrites.

[nlohmann]

Thanks @1soka, that's exactly right for 3.12.0 and earlier. This has since been fixed on develop in #5685 (closes #5673): ordered_map::emplace now forwards its value argument, so parentObj.emplace("child", childObj) compiles for ordered_json too and copies childObj, like std::map does. The fix will be in the next release. Until then, use std::move(childObj) / Json(childObj) as suggested above.

About the original clang-tidy warning: it comes from the check cppcoreguidelines-pro-bounds-avoid-unchecked-container-access, which flags every operator[] call on a container-like type, regardless of whether it is actually unsafe for that type. For a non-const json object, operator[] with a key is well-defined: it inserts a null value if the key is missing. So the warning is not about a bug in your code. If you want to silence it, you can use emplace/insert (no overwrite) or at() (throws if the key is missing; read/modify only), add a // NOLINT(cppcoreguidelines-pro-bounds-avoid-unchecked-container-access), or disable the check. See https://json.nlohmann.me/features/element_access/ for the trade-offs between the access functions.

(Written by Claude Code.)