get_ref<const Json::number_integer_t&> throws exception in 3.12.0 but not in 3.11.1

[marwanramadan]

Description

When i compile the following code with the 3.12.0 it will throw an exception, compiled with the 3.11.1 the expected result will be print out.
Is this a bug in 3.12.0 or is this a misuse of the API from my side?

Reproduction steps

Compiled with:
clang++ t1.cpp -o t1

Expected vs. actual results

The expected result is:
t2=3
With 3.12.0 i see this instead:
Exception: [json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number

Minimal code example

//#include "json-3.12.0.hpp"
#include "json-3.11.1.hpp"
#include <iostream>

using Json = nlohmann::basic_json<>;

int main() try
{
    const Json test_js = Json::parse(R"({ "t2":3 })");

    if(const auto iter{test_js.find("t2")}; iter != test_js.end())
    {
        auto ref = iter->get_ref<const Json::number_integer_t&>();
        std::cout << "t2=" << ref << '\n';
    }
    else
    {
        std::cerr << "Can't find 't2'\n";
    }
    return 0;
}
catch(const std::exception& e)
{
    std::cerr << "Exception: " << e.what() << '\n';
}

Error messages

Compiler and operating system

Linux Manjaro, clang 20.1.6 (Manjaro Repo), g++ 15.1.1 (Manjaro Repo)

Library version

3.11.1 and 3.12.0 both as single header version

Validation

• The bug also occurs if the latest version from the develop branch is used.
• I can successfully compile and run the unit tests.

[nlohmann]

This is related to this entry in the change log:

Fix return value of get_ptr for unsigned integers. #4525 #4475

In your example, 3 is parsed as an unsigned integer (number_unsigned_t), but you request a reference to a signed integer (number_integer_t). Doing this wrong, and in 3.12.0 we made sure to detect this and raise an exception.

[marwanramadan]

Thanks for the answer. Took me a while reading the links and trying something out.

For me that means, that i have to know at compile time if there is a signed or unsigned integer in the json text which is not possible. Checking the type before getting a reference is not a way i can go at the moment. For the time being i have to stay on the 3.11.1. Don't have the time to change our source code.

Please correct me if i am wrong but as i understand the json specification there is no explicit unsigned and signed for numbers. So the problem is on the C++ side. Even if this is not a good solution but an integer number should be always signed in C++ when read from a json source. That is the same with floating point numbers, there are no unsigned float in C++.

[nlohmann]

For me that means, that i have to know at compile time if there is a signed or unsigned integer in the json text which is not possible. Checking the type before getting a reference is not a way i can go at the moment. For the time being i have to stay on the 3.11.1. Don't have the time to change our source code.

Fair enough. Just be clear that you would access an unsigned integer via a reference of type signed integer which is not a good idea in the first place.

Please correct me if i am wrong but as i understand the json specification there is no explicit unsigned and signed for numbers. So the problem is on the C++ side. Even if this is not a good solution but an integer number should be always signed in C++ when read from a json source. That is the same with floating point numbers, there are no unsigned float in C++.

https://json.nlohmann.me/features/types/number_handling/ describes the number handling of the library.

What you could try (I have not tested it myself) is to set the type of the integer numbers in the template parameters to basic_json. Maybe it is possible to use std::int64_t for both integer types.

[gregmarr]

For me that means, that i have to know at compile time if there is a signed or unsigned integer in the json text which is not possible. Checking the type before getting a reference is not a way i can go at the moment.

As you described, that is a limitation of your current code, not a general limitation.

Even if this is not a good solution but an integer number should be always signed in C++ when read from a json source.

If this were true, this would limit the range of representable numbers compared to the current code. With the differentiation between signed and unsigned, the library can represent numbers from std::numeric_limits<std::int64_t>::min (-9223372036854775807 ) to std::numeric_limits<std::uint64_t>::max (18446744073709551615). If the library was limited to signed integers, the max would be std::numeric_limits<std:int64_t>::max (9223372036854775807).

[marwanramadan]

@gregmarr
You are absolute right, using always signed would limit the number rang. I understand that this would not be acceptable for a universal lib.

@nlohmann
Sooner or later i have to fix this in my code. The problem is that the access via reference is done from generalized templates. Need some time to go through all that and change this. Maybe using get_ref<>() as a default even for read only access the data from the json source was a bad idea from begin with. (The code base is > 10 years old :)

Maybe it is possible to use std::int64_t for both integer types
Could be worth a try as a workaround. Thanks for the idea.

Thanks for your responses and ideas.