use polymorphic_allocator for json in embedded system

[yushb0602]

We are using C++20 in embedded system with 128MB memory, so we are worrying about the dynamical memory allocation/memory segmentation. And want to use pmr and customize json library as :

using json_pmr = nlohmann::basic_json<std::pmr::map, std::pmr::vector, std::pmr::string, bool, std::int64_t, std::uint64_t,
                         float, std::pmr::polymorphic_allocator>;

pmr::monotonic_buffer_resource res(10000);
pmr::string s1{&res};
json_pmr obj(&res);

It seems that this feature is not fully finished.

[nlohmann]

Can you share more information? Compiler errors?

[yushb0602]

@nlohmann Thanks for your quick reply. There is no constructor function like basic_json( Allocator& alloc )) , the alloc is not passed to children elements.

when using gcc 10.3, the compile error message is:

/root/.conan/data/nlohmann_json/3.11.2///package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/nlohmann/json.hpp:333:11: error: wrong number of template arguments (4, should be at least 2)
333 | using object_t = ObjectType<StringType,
| ^~~~~~~~
In file included from /opt/cloudlink_x86/cppsrc/base_includes.h:2,
from /opt/cloudlink_x86/cppsrc/main.cpp:3:
/usr/include/c++/11/map:78:13: note: provided for 'template<class _Key, class _Tp, class _Cmp> using map = std::map<_Key, _Tp, _Cmp, std::pmr::polymorphic_allocator<std::pair<const Key, Tp> > >'
78 | using map
| ^~~
In file included from /opt/cloudlink_x86/cppsrc/jsonext.h:14,
from /opt/cloudlink_x86/cppsrc/base_includes.h:17,
from /opt/cloudlink_x86/cppsrc/main.cpp:3:
/root/.conan/data/nlohmann_json/3.11.2///package/5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9/include/nlohmann/json.hpp:341:11: error: wrong number of template arguments (2, should be 1)
341 | using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
| ^~~~~~~
In file included from /opt/cloudlink_x86/cppsrc/base_includes.h:5,
from /opt/cloudlink_x86/cppsrc/main.cpp:3:
/usr/include/c++/11/vector:86:13: note: provided for 'template using vector = std::vector<_Tp, std::pmr::polymorphic_allocator<_CharT> >
86 | using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
| ^~~~~~
In file included from /opt/cloudlink_x86/cppsrc/jsonext.h:14,

when use Vistual studio 2022, the translated error message is:

Error C2977 “std::pmr::map”: too many tempalte paramters ConsoleApplication3 C:\Users\yushb\source\repos\ConsoleApplication3\packages\nlohmann.json.3.11.2\build\native\include\nlohmann\json.hpp 19511
Error C2977 “std::pmr::vector”: too many tempalte paramters ConsoleApplication3 C:\Users\yushb\source\repos\ConsoleApplication3\packages\nlohmann.json.3.11.2\build\native\include\nlohmann\json.hpp 19519

[yushb0602]

I have tried json 3.11.2 on Vistual studio and g++ 10.3 with C++20 standard

[ankitghevariya]

Hi @nlohmann,

I was trying to use the library with std::pmr support by replacing the internal containers with std::pmr::map and std::pmr::vector. Initially, I faced compilation errors because std::map and std::pmr::map have different template parameters (due to different allocators). To work around this, I created template aliases matching the expected signature, which allowed the code to compile.

However, when I tried adding values to the JSON object, I encountered a static assertion failure. After investigating, I found that basic_json does not provide a constructor that accepts an allocator, unlike other standard containers. As a result, the internal PMR containers are default-constructed without a proper allocator, which causes allocator mismatch errors during runtime operations like insertions.

Note: The full error message is quite large, so I'm not pasting it here. I've attached a screenshot showing the last lines of the error output for reference.

Minimal reproducible example:

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

// Template alias to pass polymorphic allocators to nlohmann::json
#if 1
template<typename Key, typename T, typename Ignored, typename Allocator>
using pmr_compatible_map = std::map<Key, T, std::less<Key>, Allocator>;

template<typename T, typename Allocator>
using pmr_compatible_vector = std::vector<T, Allocator>;

using pmr_string = std::basic_string<char, std::char_traits<char>, std::pmr::polymorphic_allocator<char>>;
#endif

using json_pmr = nlohmann::basic_json<
    pmr_compatible_map,
    pmr_compatible_vector,
    pmr_string,
    bool,
    int64_t,
    uint64_t,
    double,
    std::pmr::polymorphic_allocator>;

int main()
{
    std::pmr::monotonic_buffer_resource arena(10240);
    std::pmr::polymorphic_allocator<char> alloc(&arena);

    // Create a polymorphic string using the allocator
    pmr_string str(alloc);
    str = "Hello, PMR world!";
    std::cout << str << std::endl;

    json_pmr obj;
    obj["name"] = "Ankit Ghevariya";  // ❌ Static assertion failure here: no allocator was passed to the object

    return 0;
}

In summary:

• std::pmr::map and std::map differ due to allocator types, causing compatibility issues.
• Aliases help compilation but don’t fix allocator propagation.
• basic_json doesn’t support allocator-aware construction, leading to runtime issues with PMR.

Environment

• OS: Ubuntu 24.04.2 LTS
• nlohmann/json version: 3.12.0
• Compiler: GCC 13.3.0 (g++ (Ubuntu 13.3.0-6ubuntu2~24.04))

@nlohmann — is there currently any recommended or supported way to safely use polymorphic allocators (std::pmr) with basic_json?
PMR support would be very helpful for controlling memory usage more precisely, especially in performance-critical or embedded applications. Having a clear path or official support for std::pmr with basic_json would make integration much smoother.

Thank You!