This commit is contained in:
nlohmann committed 2026-10-21 10:31:00 +00:00
1 parent be4d0a6f4b
commit 90f0c9d411
714 files changed
+22067 -622

No files matched your search

@@ -0,0 +1,40 @@
<!doctype html><html lang=en class=no-js> <head><meta charset=utf-8><meta name=viewport content="width=device-width,initial-scale=1"><meta name=author content="Niels Lohmann"><link href="https://json.nlohmann.me/api/basic_json_view/operator_eq/" rel="canonical"><link href=../operator%5B%5D/ rel=prev><link href=../operator_ne/ rel=next><link rel=icon href=../../../assets/images/favicon.png><meta name=generator content="mkdocs-1.6.1, mkdocs-material-9.7.7"><title>operator== - JSON for Modern C++</title><link rel=stylesheet href=../../../assets/stylesheets/main.ec1eaa64.min.css><link rel=stylesheet href=../../../assets/stylesheets/palette.ab4e12ef.min.css><link rel="stylesheet" href="../../../assets/external/fonts.googleapis.com/css.61a430c9.css"><style>:root{--md-text-font:"Roboto";--md-code-font:"JetBrains Mono"}</style><link rel=stylesheet href=../../../css/custom.css><script>__md_scope=new URL("../../..",location),__md_hash=e=>[...e].reduce(((e,_)=>(e<<5)-e+_.charCodeAt(0)),0),__md_get=(e,_=localStorage,t=__md_scope)=>JSON.parse(_.getItem(t.pathname+"."+e)),__md_set=(e,_,t=localStorage,a=__md_scope)=>{try{t.setItem(a.pathname+"."+e,JSON.stringify(_))}catch(e){}}</script></head> <body dir=ltr data-md-color-scheme=default data-md-color-primary=indigo data-md-color-accent=indigo> <input class=md-toggle data-md-toggle=drawer type=checkbox id=__drawer autocomplete=off> <input class=md-toggle data-md-toggle=search type=checkbox id=__search autocomplete=off> <label class=md-overlay for=__drawer></label> <div data-md-component=skip> <a href=#nlohmannbasic_json_viewoperator class=md-skip> Skip to content </a> </div> <div data-md-component=announce> </div> <header class=md-header data-md-component=header> <nav class="md-header__inner md-grid" aria-label=Header> <a href=../../.. title="JSON for Modern C++" class="md-header__button md-logo" aria-label="JSON for Modern C++" data-md-component=logo> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M12 8a3 3 0 0 0 3-3 3 3 0 0 0-3-3 3 3 0 0 0-3 3 3 3 0 0 0 3 3m0 3.54C9.64 9.35 6.5 8 3 8v11c3.5 0 6.64 1.35 9 3.54 2.36-2.19 5.5-3.54 9-3.54V8c-3.5 0-6.64 1.35-9 3.54"/></svg> </a> <label class="md-header__button md-icon" for=__drawer> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M3 6h18v2H3zm0 5h18v2H3zm0 5h18v2H3z"/></svg> </label> <div class=md-header__title data-md-component=header-title> <div class=md-header__ellipsis> <div class=md-header__topic> <span class=md-ellipsis> JSON for Modern C++ </span> </div> <div class=md-header__topic data-md-component=header-topic> <span class=md-ellipsis> operator== </span> </div> </div> </div> <form class=md-header__option data-md-component=palette> <input class=md-option data-md-color-media="(prefers-color-scheme: light)" data-md-color-scheme=default data-md-color-primary=indigo data-md-color-accent=indigo aria-label="Switch to dark mode" type=radio name=__palette id=__palette_0> <label class="md-header__button md-icon" title="Switch to dark mode" for=__palette_1 hidden> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M12 8a4 4 0 0 0-4 4 4 4 0 0 0 4 4 4 4 0 0 0 4-4 4 4 0 0 0-4-4m0 10a6 6 0 0 1-6-6 6 6 0 0 1 6-6 6 6 0 0 1 6 6 6 6 0 0 1-6 6m8-9.31V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12z"/></svg> </label> <input class=md-option data-md-color-media="(prefers-color-scheme: dark)" data-md-color-scheme=slate data-md-color-primary=indigo data-md-color-accent=indigo aria-label="Switch to light mode" type=radio name=__palette id=__palette_1> <label class="md-header__button md-icon" title="Switch to light mode" for=__palette_0 hidden> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6a6 6 0 0 1 6 6 6 6 0 0 1-6 6m8-9.31V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12z"/></svg> </label> </form> <script>var palette=__md_get("__palette");if(palette&&palette.color){if("(prefers-color-scheme)"===palette.color.media){var media=matchMedia("(prefers-color-scheme: light)"),input=document.querySelector(media.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");palette.color.media=input.getAttribute("data-md-color-media"),palette.color.scheme=input.getAttribute("data-md-color-scheme"),palette.color.primary=input.getAttribute("data-md-color-primary"),palette.color.accent=input.getAttribute("data-md-color-accent")}for(var[key,value]of Object.entries(palette.color))document.body.setAttribute("data-md-color-"+key,value)}</script> <label class="md-header__button md-icon" for=__search> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M9.5 3A6.5 6.5 0 0 1 16 9.5c0 1.61-.59 3.09-1.56 4.23l.27.27h.79l5 5-1.5 1.5-5-5v-.79l-.27-.27A6.52 6.52 0 0 1 9.5 16 6.5 6.5 0 0 1 3 9.5 6.5 6.5 0 0 1 9.5 3m0 2C7 5 5 7 5 9.5S7 14 9.5 14 14 12Line truncated
<span class=kt>bool</span><span class=w> </span><span class=k>operator</span><span class=o>==</span><span class=p>(</span><span class=k>const</span><span class=w> </span><span class=n>basic_json_view</span><span class=o>&amp;</span><span class=w> </span><span class=n>lhs</span><span class=p>,</span><span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>basic_json_view</span><span class=o>&amp;</span><span class=w> </span><span class=n>rhs</span><span class=p>);</span>
<span class=c1>// (2)</span>
<span class=kt>bool</span><span class=w> </span><span class=k>operator</span><span class=o>==</span><span class=p>(</span><span class=k>const</span><span class=w> </span><span class=n>basic_json_view</span><span class=o>&amp;</span><span class=w> </span><span class=n>lhs</span><span class=p>,</span><span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>BasicJsonType</span><span class=o>&amp;</span><span class=w> </span><span class=n>rhs</span><span class=p>);</span>
<span class=kt>bool</span><span class=w> </span><span class=k>operator</span><span class=o>==</span><span class=p>(</span><span class=k>const</span><span class=w> </span><span class=n>BasicJsonType</span><span class=o>&amp;</span><span class=w> </span><span class=n>lhs</span><span class=p>,</span><span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>basic_json_view</span><span class=o>&amp;</span><span class=w> </span><span class=n>rhs</span><span class=p>);</span>
</code></pre></div> <ol> <li>Compares two views for equality: whether the values <a href=../../basic_json/parse/ ><code>BasicJsonType::parse()</code></a> would produce for <code>lhs</code> and <code>rhs</code> are equal, according to <code>BasicJsonType</code>'s <a href=../../basic_json/operator_eq/ ><code>operator==</code></a>.</li> <li>Compares a view and a <code>BasicJsonType</code> value for equality, in either order: whether the value <code>parse()</code> would produce for the view and the other operand are equal, according to <code>BasicJsonType</code>'s <a href=../../basic_json/operator_eq/ ><code>operator==</code></a>.</li> </ol> <p>Neither overload builds a <code>BasicJsonType</code> value for a view to do the comparison (see <a href=#notes>Notes</a> below). Numbers compare by value across their types (<code class=highlight><span class=mi>1</span><span class=w> </span><span class=o>==</span><span class=w> </span><span class=mf>1.0</span></code>), and an object compares by its members, with duplicate keys resolved exactly as <code>parse()</code> resolves them -- the last value, at the position of the first occurrence of the key. This is not what <a href=../operator%5B%5D/ ><code>operator[]</code></a> and the other lookups return for a duplicate key: they find the <em>first</em> member (see <a href=../../../features/json_view/#duplicate-keys>Duplicate keys</a>).</p> <h2 id=parameters>Parameters<a class=headerlink href=#parameters title="Permanent link">&para;</a></h2> <dl> <dt><code>lhs</code> (in)</dt> <dd>first value to consider</dd> <dt><code>rhs</code> (in)</dt> <dd>second value to consider</dd> </dl> <h2 id=return-value>Return value<a class=headerlink href=#return-value title="Permanent link">&para;</a></h2> <p>whether the values <code>lhs</code> and <code>rhs</code> are equal</p> <h2 id=exception-safety>Exception safety<a class=headerlink href=#exception-safety title="Permanent link">&para;</a></h2> <p>Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a view refers to.</p> <h2 id=exceptions>Exceptions<a class=headerlink href=#exceptions title="Permanent link">&para;</a></h2> <p>May throw <code class=highlight><span class=n>std</span><span class=o>::</span><span class=n>bad_alloc</span></code>. Unlike the other comparison and most other <code>basic_json_view</code> functions, <code>operator==</code> is not <code class=highlight><span class=k>noexcept</span></code>: resolving an object's members needs a temporary array to sort them by key (see <a href=#complexity>Complexity</a> below), and that allocation can fail.</p> <h2 id=complexity>Complexity<a class=headerlink href=#complexity title="Permanent link">&para;</a></h2> <p>Linear in the size of the compared values: every number, string, array element, and object member is visited at most once, and the walk is iterative, so the nesting depth it can compare is limited by available memory only, not by the call stack (as for <a href=../materialize/ ><code>materialize()</code></a>). Resolving an object's members takes an additional O(n log n) in the number of members at that level, since they are sorted by key to detect and resolve duplicates before being compared. Two arrays of different <a href=../size/ ><code>size()</code></a> are rejected without visiting either one's elements.</p> <h2 id=notes>Notes<a class=headerlink href=#notes title="Permanent link">&para;</a></h2> <p>Only a single number, boolean, or <code class=highlight><span class=n>null</span></code> value is ever materialized into a <code>BasicJsonType</code>, to reuse its <code>operator==</code> -- for numbers, so that values written differently in the source text but equal in value (e.g. an integer and a floating-point literal) still compare equal, following the same rules <code>BasicJsonType</code> does for special values such as <code class=highlight><span class=n>NaN</span></code>. Constructing one of these scalars never allocates. Strings are compared directly, without allocating, either from the source text on both sides or, for overload 2, against <code>BasicJsonType</code>'s own string. Arrays and objects are never materialized at all; only their elements or members are visited, one pair at a time.</p> <div class="admonition info"> <p class=admonition-title>How objects are compared</p> <p>For a <a href=../../json_view/ ><code>json_view</code></a> (<code>BasicJsonType::object_t</code> is <code class=highlight><span class=n>std</span><span class=o>::</span><span class=n>map</span></code>), members are compared by key, regardless of the order they appear in the source text. For an <a href=../../ordered_json_view/ ><code>ordered_json_view</code></a> (<code>object_t</code> is <code>ordered_map</code>), they are compared in the order they occur, so the very same two objects with their members reordered can compare equal as <code>json_view</code>s but not as <code>ordered_json_view</code>s. This is exactly how <a href=..Line truncated
<span class=cp>#include</span><span class=w> </span><span class=cpf>&lt;nlohmann/json_view.hpp&gt;</span>
<span class=k>using</span><span class=w> </span><span class=n>json_document</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>nlohmann</span><span class=o>::</span><span class=n>json_document</span><span class=p>;</span>
<span class=k>using</span><span class=w> </span><span class=n>json</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>nlohmann</span><span class=o>::</span><span class=n>json</span><span class=p>;</span>
<span class=kt>int</span><span class=w> </span><span class=nf>main</span><span class=p>()</span>
<span class=p>{</span>
<span class=w> </span><span class=c1>// two snapshots of a polled configuration endpoint -- compare them</span>
<span class=w> </span><span class=c1>// directly as views, without ever building a nlohmann::json value for</span>
<span class=w> </span><span class=c1>// either one</span>
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>json_document</span><span class=w> </span><span class=n>previous</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>json_document</span><span class=o>::</span><span class=n>parse</span><span class=p>(</span>
<span class=w> </span><span class=sa>R</span><span class=s>"</span><span class=dl>(</span><span class=s>{"name": "cache", "port": 6379, "timeout": 30}</span><span class=dl>)</span><span class=s>"</span><span class=p>);</span>
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>json_document</span><span class=w> </span><span class=n>current</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>json_document</span><span class=o>::</span><span class=n>parse</span><span class=p>(</span>
<span class=w> </span><span class=sa>R</span><span class=s>"</span><span class=dl>(</span><span class=s>{"port": 6379.0, "timeout": 30, "name": "cache"}</span><span class=dl>)</span><span class=s>"</span><span class=p>);</span>
<span class=w> </span><span class=c1>// same members, reordered, and 6379 written as a float -- operator==</span>
<span class=w> </span><span class=c1>// treats them the same way BasicJsonType::operator== would</span>
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>cout</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>boolalpha</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=p>(</span><span class=n>previous</span><span class=p>.</span><span class=n>root</span><span class=p>()</span><span class=w> </span><span class=o>==</span><span class=w> </span><span class=n>current</span><span class=p>.</span><span class=n>root</span><span class=p>())</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=sc>'\n'</span><span class=p>;</span>
<span class=w> </span><span class=c1>// an actually changed value is detected the same way</span>
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>json_document</span><span class=w> </span><span class=n>changed</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>json_document</span><span class=o>::</span><span class=n>parse</span><span class=p>(</span>
<span class=w> </span><span class=sa>R</span><span class=s>"</span><span class=dl>(</span><span class=s>{"name": "cache", "port": 6380, "timeout": 30}</span><span class=dl>)</span><span class=s>"</span><span class=p>);</span>
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>cout</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=p>(</span><span class=n>previous</span><span class=p>.</span><span class=n>root</span><span class=p>()</span><span class=w> </span><span class=o>==</span><span class=w> </span><span class=n>changed</span><span class=p>.</span><span class=n>root</span><span class=p>())</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=sc>'\n'</span><span class=p>;</span>
<span class=w> </span><span class=c1>// comparing a view directly against an expected json value -- handy in a</span>
<span class=w> </span><span class=c1>// test, without materializing the received document at all</span>
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=n>json</span><span class=w> </span><span class=n>expected</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=p>{{</span><span class=s>"name"</span><span class=p>,</span><span class=w> </span><span class=s>"cache"</span><span class=p>},</span><span class=w> </span><span class=p>{</span><span class=s>"port"</span><span class=p>,</span><span class=w> </span><span class=mi>6379</span><span class=p>},</span><span class=w> </span><span class=p>{</span><span class=s>"timeout"</span><span class=p>,</span><span class=w> </span><span class=mi>30</span><span class=p>}};</span>
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>cout</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=p>(</span><span class=n>previous</span><span class=p>.</span><span class=n>root</span><span class=p>()</span><span class=w> </span><span class=o>==</span><span class=w> </span><span class=n>expected</span><span class=p>)</span><span class=w> </span><span class=o>&lt;&lt;</span><span class=w> </span><span class=sc>'\n'</span><span class=p>;</span>
<span class=p>}</span>
</code></pre></div> <p>Output:</p> <div class=highlight><pre><span></span><code><span class=kc>true</span>
<span class=kc>false</span>
<span class=kc>true</span>
</code></pre></div> </details> <h2 id=see-also>See also<a class=headerlink href=#see-also title="Permanent link">&para;</a></h2> <ul> <li><a href=../operator_ne/ >operator!=</a> - compare for inequality</li> <li><a href=../materialize/ >materialize</a> - build a <code>BasicJsonType</code> value, e.g. to keep comparing after the document is gone</li> <li><a href=../../basic_json/operator_eq/ ><code>BasicJsonType::operator==</code></a> - the corresponding function of <code>basic_json</code></li> </ul> <h2 id=version-history>Version history<a class=headerlink href=#version-history title="Permanent link">&para;</a></h2> <ul> <li>Added in version 3.13.0 <span class=unreleased-version title="Not part of a release yet; the latest release is 3.12.0.">unreleased</span>.</li> </ul> <!-- https://squidfunk.github.io/mkdocs-material/reference/tooltips/#adding-a-glossary --> <aside class=md-source-file> <span class=md-source-file__fact> <span class=md-icon title="Last update"> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M21 13.1c-.1 0-.3.1-.4.2l-1 1 2.1 2.1 1-1c.2-.2.2-.6 0-.8l-1.3-1.3c-.1-.1-.2-.2-.4-.2m-1.9 1.8-6.1 6V23h2.1l6.1-6.1zM12.5 7v5.2l4 2.4-1 1L11 13V7zM11 21.9c-5.1-.5-9-4.8-9-9.9C2 6.5 6.5 2 12 2c5.3 0 9.6 4.1 10 9.3-.3-.1-.6-.2-1-.2s-.7.1-1 .2C19.6 7.2 16.2 4 12 4c-4.4 0-8 3.6-8 8 0 4.1 3.1 7.5 7.1 7.9l-.1.2z"/></svg> </span> <span class="git-revision-date-localized-plugin git-revision-date-localized-plugin-date" title="October 21, 2026 08:21:28 UTC">October 21, 2026</span> </span> </aside> </article> </div> <script>var tabs=__md_get("__tabs");if(Array.isArray(tabs))e:for(var set of document.querySelectorAll(".tabbed-set")){var labels=set.querySelector(".tabbed-labels");for(var tab of tabs)for(var label of labels.getElementsByTagName("label"))if(label.innerText.trim()===tab){var input=document.getElementById(label.htmlFor);input.checked=!0;continue e}}</script> <script>var target=document.getElementById(location.hash.slice(1));target&&target.name&&(target.checked=target.name.startsWith("__tabbed_"))</script> </div> <button type=button class="md-top md-icon" data-md-component=top hidden> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M13 20h-2V8l-5.5 5.5-1.42-1.42L12 4.16l7.92 7.92-1.42 1.42L13 8z"/></svg> Back to top </button> </main> <footer class=md-footer> <div class="md-footer-meta md-typeset"> <div class="md-footer-meta__inner md-grid"> <div class=md-copyright> <div class=md-copyright__highlight> Copyright &copy; 2013-2026 Niels Lohmann </div> </div> <div class=md-social> <a href="https://github.com/nlohmann" target="_blank" rel="noopener" title="github.com" class="md-social__link"> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 512 512"><!-- Font Awesome Free 7.1.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2025 Fonticons, Inc.--><path d="M173.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6m-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3m44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9M252.8 8C114.1 8 8 113.3 8 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C436.2 457.8 504 362.9 504 252 504 113.3 391.5 8 252.8 8M105.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1m-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7m32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1m-11.4-14.7c-1.6 1-1.6 3.6 0 5.9s4.3 3.3 5.6 2.3c1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2"/></svg> </a> <a href="https://www.linkedin.com/in/nielslohmann/" target="_blank" rel="noopener" title="www.linkedin.com" class="md-social__link"> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 448 512"><!-- Font Awesome Free 7.1.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2025 Fonticons, Inc.--><path d="M416 32H31.9C14.3 32 0 46.5 0 64.3v383.4C0 465.5 14.3 480 31.9 480H416c17.6 0 32-14.5 32-32.3V64.3c0-17.8-14.4-32.3-32-32.3M135.4 416H69V202.2h66.5V416zM102.2 96a38.5 38.5 0 1 1 0 77 38.5 38.5 0 1 1 0-77m282.1 320h-66.4V312c0-24.8-.5-56.7-34.5-56.7-34.6 0-39.9 27-39.9 54.9V416h-66.4V202.2h63.7v29.2h.9c8.9-16.8 30.6-34.5 62.9-34Line truncated
+108
View File
@@ -0,0 +1,108 @@
# nlohmann::basic_json_view::operator==
```
// (1)
bool operator==(const basic_json_view& lhs, const basic_json_view& rhs);
// (2)
bool operator==(const basic_json_view& lhs, const BasicJsonType& rhs);
bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs);
```
1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](https://json.nlohmann.me/api/basic_json/parse/index.md) would produce for `lhs` and `rhs` are equal, according to `BasicJsonType`'s [`operator==`](https://json.nlohmann.me/api/basic_json/operator_eq/index.md).
1. Compares a view and a `BasicJsonType` value for equality, in either order: whether the value `parse()` would produce for the view and the other operand are equal, according to `BasicJsonType`'s [`operator==`](https://json.nlohmann.me/api/basic_json/operator_eq/index.md).
Neither overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers compare by value across their types (`1 == 1.0`), and an object compares by its members, with duplicate keys resolved exactly as `parse()` resolves them -- the last value, at the position of the first occurrence of the key. This is not what [`operator[]`](https://json.nlohmann.me/api/basic_json_view/operator%5B%5D/index.md) and the other lookups return for a duplicate key: they find the *first* member (see [Duplicate keys](https://json.nlohmann.me/features/json_view/#duplicate-keys)).
## Parameters
`lhs` (in) : first value to consider
`rhs` (in) : second value to consider
## Return value
whether the values `lhs` and `rhs` are equal
## Exception safety
Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a view refers to.
## Exceptions
May throw `std::bad_alloc`. Unlike the other comparison and most other `basic_json_view` functions, `operator==` is not `noexcept`: resolving an object's members needs a temporary array to sort them by key (see [Complexity](#complexity) below), and that allocation can fail.
## Complexity
Linear in the size of the compared values: every number, string, array element, and object member is visited at most once, and the walk is iterative, so the nesting depth it can compare is limited by available memory only, not by the call stack (as for [`materialize()`](https://json.nlohmann.me/api/basic_json_view/materialize/index.md)). Resolving an object's members takes an additional O(n log n) in the number of members at that level, since they are sorted by key to detect and resolve duplicates before being compared. Two arrays of different [`size()`](https://json.nlohmann.me/api/basic_json_view/size/index.md) are rejected without visiting either one's elements.
## Notes
Only a single number, boolean, or `null` value is ever materialized into a `BasicJsonType`, to reuse its `operator==` -- for numbers, so that values written differently in the source text but equal in value (e.g. an integer and a floating-point literal) still compare equal, following the same rules `BasicJsonType` does for special values such as `NaN`. Constructing one of these scalars never allocates. Strings are compared directly, without allocating, either from the source text on both sides or, for overload 2, against `BasicJsonType`'s own string. Arrays and objects are never materialized at all; only their elements or members are visited, one pair at a time.
How objects are compared
For a [`json_view`](https://json.nlohmann.me/api/json_view/index.md) (`BasicJsonType::object_t` is `std::map`), members are compared by key, regardless of the order they appear in the source text. For an [`ordered_json_view`](https://json.nlohmann.me/api/ordered_json_view/index.md) (`object_t` is `ordered_map`), they are compared in the order they occur, so the very same two objects with their members reordered can compare equal as `json_view`s but not as `ordered_json_view`s. This is exactly how [`json`](https://json.nlohmann.me/api/json/index.md) and [`ordered_json`](https://json.nlohmann.me/api/ordered_json/index.md) compare, see ["Comparing different `basic_json` specializations"](https://json.nlohmann.me/api/basic_json/operator_eq/#notes).
Discarded views
A [discarded](https://json.nlohmann.me/api/basic_json_view/is_discarded/index.md) view compares the same way a discarded `BasicJsonType` value does, which is governed by [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](https://json.nlohmann.me/api/macros/json_use_legacy_discarded_value_comparison/index.md): by default, a discarded view is never equal to anything, not even another discarded view.
No ordering comparison (`operator<`) is provided for `basic_json_view`; [`materialize()`](https://json.nlohmann.me/api/basic_json_view/materialize/index.md) is the way to get a `BasicJsonType` value that supports it.
## Examples
Example
The example below checks whether a newly received configuration differs from the previous one, and whether a received document matches what a test expects -- directly on views, without ever materializing a `BasicJsonType` value for either side.
```
#include <iostream>
#include <nlohmann/json_view.hpp>
using json_document = nlohmann::json_document;
using json = nlohmann::json;
int main()
{
// two snapshots of a polled configuration endpoint -- compare them
// directly as views, without ever building a nlohmann::json value for
// either one
const json_document previous = json_document::parse(
R"({"name": "cache", "port": 6379, "timeout": 30})");
const json_document current = json_document::parse(
R"({"port": 6379.0, "timeout": 30, "name": "cache"})");
// same members, reordered, and 6379 written as a float -- operator==
// treats them the same way BasicJsonType::operator== would
std::cout << std::boolalpha << (previous.root() == current.root()) << '\n';
// an actually changed value is detected the same way
const json_document changed = json_document::parse(
R"({"name": "cache", "port": 6380, "timeout": 30})");
std::cout << (previous.root() == changed.root()) << '\n';
// comparing a view directly against an expected json value -- handy in a
// test, without materializing the received document at all
const json expected = {{"name", "cache"}, {"port", 6379}, {"timeout", 30}};
std::cout << (previous.root() == expected) << '\n';
}
```
Output:
```
true
false
true
```
## See also
- [operator!=](https://json.nlohmann.me/api/basic_json_view/operator_ne/index.md) - compare for inequality
- [materialize](https://json.nlohmann.me/api/basic_json_view/materialize/index.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
- [`BasicJsonType::operator==`](https://json.nlohmann.me/api/basic_json/operator_eq/index.md) - the corresponding function of `basic_json`
## Version history
- Added in version 3.13.0 unreleased.