nlohmann::basic_json::operator==¶

// until C++20
booloperator==(const_referencelhs,const_referencerhs)noexcept;// (1)
template<typenameScalarType>
booloperator==(const_referencelhs,constScalarTyperhs)noexcept;// (2)
template<typenameScalarType>
booloperator==(ScalarTypelhs,constconst_referencerhs)noexcept;// (2)
// since C++20
classbasic_json{
booloperator==(const_referencerhs)constnoexcept;// (1)
template<typenameScalarType>
booloperator==(ScalarTyperhs)constnoexcept;// (2)
};

Compares two JSON values for equality according to the following rules:
- Two JSON values are equal if (1) neither value is discarded, and (2) they are of the same type and their stored values are the same according to their respective operator==.
- Integer and floating-point numbers are automatically converted before comparison.
Compares a JSON value and a scalar or a scalar and a JSON value for equality 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 the values lhs/*this and rhs are equal

Exception safety¶

No-throw guarantee: this function never throws exceptions.

Complexity¶

Linear.

Notes¶

Comparing special values

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.
JSON null values are all equal.
Discarded values never compare equal to themselves.

Comparing floating-point numbers

Floating-point numbers inside JSON values numbers are compared with json::number_float_t::operator== which is double::operator== by default. To compare floating-point while respecting an epsilon, an alternative comparison function could be used, for instance

template<typenameT,typename=typenamestd::enable_if<std::is_floating_point<T>::value,T>::type>
inlineboolis_same(Ta,Tb,Tepsilon=std::numeric_limits<T>::epsilon())noexcept
{
returnstd::abs(a-b)<=epsilon;
}

Or you can define your own equality function like this:

boolmy_equal(const_referencelhs,const_referencerhs)
{
constautolhs_type=lhs.type();
constautorhs_type=rhs.type();
if(lhs_type==rhs_type)
{
switch(lhs_type)
// self_defined case
casevalue_t::number_float:
returnstd::abs(lhs-rhs)<=std::numeric_limits<float>::epsilon();
// other cases remain the same with the original
...
}
...
}

Comparing different basic_json specializations

Comparing different basic_json specializations can have surprising effects. For instance, the result of comparing the JSON objects

{
"version":1,
"type":"integer"
}

and

{
"type":"integer",
"version":1
}

depends on whether nlohmann::json or nlohmann::ordered_json is used:

#include<iostream>
#include<iomanip>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
nlohmann::jsonuj1={{"version",1},{"type","integer"}};
nlohmann::jsonuj2={{"type","integer"},{"version",1}};
nlohmann::ordered_jsonoj1={{"version",1},{"type","integer"}};
nlohmann::ordered_jsonoj2={{"type","integer"},{"version",1}};
std::cout<<std::boolalpha<<(uj1==uj2)<<'\n'<<(oj1==oj2)<<std::endl;
}

Output:

true
false

Examples¶

Example

The example demonstrates comparing several JSON types.

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create several JSON values
jsonarray_1={1,2,3};
jsonarray_2={1,2,4};
jsonobject_1={{"A","a"},{"B","b"}};
jsonobject_2={{"B","b"},{"A","a"}};
jsonnumber_1=17;
jsonnumber_2=17.000000000000001L;
jsonstring_1="foo";
jsonstring_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.0true
"foo"=="bar"false

Example

The example demonstrates comparing several JSON types against the null pointer (JSON null).

#include<iostream>
#include<nlohmann/json.hpp>
usingjson=nlohmann::json;
intmain()
{
// create several JSON values
jsonarray={1,2,3};
jsonobject={{"A","a"},{"B","b"}};
jsonnumber=17;
jsonstring="foo";
jsonnull;
// output values and comparisons
std::cout<<std::boolalpha;
std::cout<<array<<" == nullptr "<<(array==nullptr)<<'\n';
std::cout<<object<<" == nullptr "<<(object==nullptr)<<'\n';
std::cout<<number<<" == nullptr "<<(number==nullptr)<<'\n';
std::cout<<string<<" == nullptr "<<(string==nullptr)<<'\n';
std::cout<<null<<" == nullptr "<<(null==nullptr)<<'\n';
}

Output:

[1,2,3]==nullptrfalse
{"A":"a","B":"b"}==nullptrfalse
17==nullptrfalse
"foo"==nullptrfalse
null==nullptrtrue

Version history¶

Added in version 1.0.0. Added C++20 member functions in version 3.11.0.
Added in version 1.0.0. Added C++20 member functions in version 3.11.0.

nlohmann::basic_json::operator==¶

Template parameters¶

Parameters¶

Return value¶

Exception safety¶

Complexity¶

Notes¶

Examples¶

See also¶

Version history¶