// until C++20 bool operator>(const_reference lhs, const_reference rhs) noexcept; // (1) template<typename ScalarType> bool operator>(const_reference lhs, const ScalarType rhs) noexcept(/* see below */); // (2) template<typename ScalarType> bool operator>(ScalarType lhs, const const_reference rhs) noexcept(/* see below */); // (2)
Compares whether one JSON value lhs is greater than another JSON value rhs according to the following rules:
#!cpp false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.#!cpp !(lhs <= rhs) (see operator<=).Compares whether a JSON value is greater than a scalar or a scalar is greater than a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
ScalarType : a scalar type according to std::is_scalar<ScalarType>::value
lhs (in) : first value to consider
rhs (in) : second value to consider
whether lhs is greater than rhs
#!cpp nullptr; the function is #!cpp noexcept exactly in that case. Otherwise, it throws what the conversion throws, for example std::bad_alloc when converting a string, or out_of_range.410 for an enum value not mapped by NLOHMANN_JSON_SERIALIZE_ENUM_STRICT.Linear.
!!! note “Comparing NaN”
`NaN` values are unordered within the domain of numbers. The following comparisons all yield `#!cpp false`: 1. Comparing a `NaN` with itself. 2. Comparing a `NaN` with another `NaN`. 3. Comparing a `NaN` and any other number.
!!! note “Operator overload resolution”
Since C++20 overload resolution will consider the _rewritten candidate_ generated from [`operator<=>`](operator_spaceship.md).
??? example
The example demonstrates comparing several JSON types.
```cpp
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create several JSON values
json array_1 = {1, 2, 3};
json array_2 = {1, 2, 4};
json object_1 = {{"A", "a"}, {"B", "b"}};
json object_2 = {{"B", "b"}, {"A", "a"}};
json number_1 = 17;
json number_2 = 17.0000000000001L;
json string_1 = "foo";
json string_2 = "bar";
// output values and comparisons
std::cout << std::boolalpha;
std::cout << array_1 << " > " << array_2 << " " << (array_1 > array_2) << '\n';
std::cout << object_1 << " > " << object_2 << " " << (object_1 > object_2) << '\n';
std::cout << number_1 << " > " << number_2 << " " << (number_1 > number_2) << '\n';
std::cout << string_1 << " > " << string_2 << " " << (string_1 > string_2) << '\n';
}
```
Output:
```json
[1,2,3] > [1,2,4] false
{"A":"a","B":"b"} > {"A":"a","B":"b"} false
17 > 17.0000000000001 false
"foo" > "bar" true
```
#!cpp noexcept in version 3.13.0; before, a throwing conversion called std::terminate.