json/api/basic_json/operator_ge/index.md

nlohmann::basic_json::operator>=

// 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;  // (2)

template<typename ScalarType>
bool operator>=(ScalarType lhs, const const_reference rhs) noexcept;  // (2)

1. Compares whether one JSON value lhs is greater than or equal to another JSON value rhs according to the following rules:

   • The comparison always yields false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.
   • Otherwise, returns the result of !(lhs < rhs) (see operator<).

2. Compares whether a JSON value is greater than or equal to a scalar or a scalar is greater than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.

Template parameters

ScalarType : a scalar type according to std::is_scalar<ScalarType>::value

Parameters

lhs (in) : first value to consider

rhs (in) : second value to consider

Return value

whether lhs is greater than or equal to rhs

Exception safety

No-throw guarantee: this function never throws exceptions.

Complexity

Linear.

Notes

Comparing NaN

NaN values are unordered within the domain of numbers. The following comparisons all yield false:

1. Comparing a NaN with itself.
2. Comparing a NaN with another NaN.
3. Comparing a NaN and any other number.

Operator overload resolution

Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.

Deprecation

If JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON is defined to 1, the library declares a member bool operator>=(const_reference rhs) const noexcept in C++20 mode to emulate the legacy comparison of discarded values. This member is deprecated since version 3.11.0, together with the legacy comparison behavior.

See the migration guide for how to update existing code.

Examples

Example

The example demonstrates comparing several JSON types.

#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:

[1,2,3] >= [1,2,4] false
{"A":"a","B":"b"} >= {"A":"a","B":"b"} true
17 >= 17.0000000000001 false
"foo" >= "bar" true

See also

• operator<=> comparison: 3-way

Version history

1. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.
2. Added in version 1.0.0. Conditionally removed since C++20 in version 3.11.0.