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 inequality 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) (until C++20) or !(*this==rhs) (since C++20).
Compares a JSON value and a scalar or a scalar and a JSON value for inequality 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 not equal

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.

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]true
{"A":"a","B":"b"}!={"A":"a","B":"b"}false
17!=17.0false
"foo"!="bar"true

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]!=nullptrtrue
{"A":"a","B":"b"}!=nullptrtrue
17!=nullptrtrue
"foo"!=nullptrtrue
null!=nullptrfalse

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.