Deployed 360ce457f with MkDocs version: 1.5.3
This commit is contained in:
1 parent
1bda49b536
commit
344ced4012
263 files changed
+9968
-9734
No files matched your search
+28
-28
@@ -1,39 +1,39 @@
|
||||
<!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/features/types/ rel=canonical><link rel=icon href=../../assets/images/favicon.png><meta name=generator content="mkdocs-1.4.2, mkdocs-material-8.5.10"><title>Types - JSON for Modern C++</title><link rel=stylesheet href=../../assets/stylesheets/main.975780f9.min.css><link rel=stylesheet href=../../assets/stylesheets/palette.2505c338.min.css><link rel=preconnect href=https://fonts.gstatic.com crossorigin><link rel=stylesheet href="https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,700,700i%7CJetBrains+Mono:400,400i,700,700i&display=fallback"><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> <script>var palette=__md_get("__palette");if(palette&&"object"==typeof palette.color)for(var key of Object.keys(palette.color))document.body.setAttribute("data-md-color-"+key,palette.color[key])</script> <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=#types 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.54Z"/></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 6h18v2H3V6m0 5h18v2H3v-2m0 5h18v2H3v-2Z"/></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> Types </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_1> <label class="md-header__button md-icon" title="Switch to dark mode" for=__palette_2 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 12 20 8.69Z"/></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_2> <label class="md-header__button md-icon" title="Switch to light mode" for=__palette_1 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 12c0-2.42-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 12 20 8.69Z"/></svg> </label> </form> <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.516 6.516 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 12 14 9.5 12 5 9.5 5Z"/></svg> </label> <div class=md-search data-md-component=search role=dialog> <label class=md-search__overlay for=__search></label> <div class=md-search__inner role=search> <form class=md-search__form name=search> <input type=text class=md-search__input name=query aria-label=Search placeholder=Search autocapitalize=off autocorrect=off autocomplete=off spellcheck=false data-md-component=search-query required> <label class="md-search__icon md-icon" for=__search> <svg xmlLine truncated
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>U</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=nc>V</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=p>...</span><span class=w> </span><span class=n>Args</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>ObjectType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>map</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>U</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=p>...</span><span class=w> </span><span class=n>Args</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>ArrayType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>vector</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>StringType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>string</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>BooleanType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=kt>bool</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>NumberIntegerType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>NumberUnsignedType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>uint64_t</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>NumberFloatType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=kt>double</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>U</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>AllocatorType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>allocator</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>T</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=nc>SFINAE</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=kt>void</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>JSONSerializer</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>adl_serializer</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>BinaryType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>vector</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=kt>uint8_t</span><span class=o>></span><span class=w></span>
|
||||
<span class=o>></span><span class=w></span>
|
||||
<span class=k>class</span><span class=w> </span><span class=nc>basic_json</span><span class=p>;</span><span class=w></span>
|
||||
</code></pre></div> <p>Type <code>json</code> is an alias for <code>basic_json<></code> and uses the default types.</p> <p>From the template arguments, the following types are derived:</p> <div class=highlight><pre><span></span><code><span class=k>using</span><span class=w> </span><span class=n>object_comparator_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>less</span><span class=o><></span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>object_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>ObjectType</span><span class=o><</span><span class=n>StringType</span><span class=p>,</span><span class=w> </span><span class=n>basic_json</span><span class=p>,</span><span class=w> </span><span class=n>object_comparator_t</span><span class=p>,</span><span class=w></span>
|
||||
<span class=w> </span><span class=n>AllocatorType</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=n>pair</span><span class=o><</span><span class=k>const</span><span class=w> </span><span class=n>StringType</span><span class=p>,</span><span class=w> </span><span class=n>basic_json</span><span class=o>>>></span><span class=p>;</span><span class=w></span>
|
||||
<!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/features/types/ rel=canonical><link href=../macros/ rel=prev><link href=number_handling/ rel=next><link rel=icon href=../../assets/images/favicon.png><meta name=generator content="mkdocs-1.5.3, mkdocs-material-9.4.7"><title>Types - JSON for Modern C++</title><link rel=stylesheet href=../../assets/stylesheets/main.4b4a2bd9.min.css><link rel=stylesheet href=../../assets/stylesheets/palette.356b1318.min.css><link rel=preconnect href=https://fonts.gstatic.com crossorigin><link rel=stylesheet href="https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,700,700i%7CJetBrains+Mono:400,400i,700,700i&display=fallback"><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> <script>var palette=__md_get("__palette");if(palette&&"object"==typeof palette.color)for(var key of Object.keys(palette.color))document.body.setAttribute("data-md-color-"+key,palette.color[key])</script> <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=#types 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.54Z"/></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 6h18v2H3V6m0 5h18v2H3v-2m0 5h18v2H3v-2Z"/></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> Types </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_1> <label class="md-header__button md-icon" title="Switch to dark mode" for=__palette_2 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 12 20 8.69Z"/></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_2> <label class="md-header__button md-icon" title="Switch to light mode" for=__palette_1 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 12c0-2.42-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 12 20 8.69Z"/></svg> </label> </form> <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.516 6.516 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 12 14 9.5 12 5 9.5 5Z"/></svg> </label> <div class=md-search data-md-component=search role=dialog> <label class=md-search__overlay for=__search></label> <div class=md-search__inner role=search> <form class=md-search__form name=search> <input type=text class=md-search__input name=query aria-label=Search placeholder=Search autocapitalize=off autocorrect=off autocomplete=off spellcheck=false data-md-component=search-query requLine truncated
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>U</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=nc>V</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=p>...</span><span class=w> </span><span class=n>Args</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>ObjectType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>map</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>U</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=p>...</span><span class=w> </span><span class=n>Args</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>ArrayType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>vector</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>StringType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>string</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>BooleanType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=kt>bool</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>NumberIntegerType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>NumberUnsignedType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>uint64_t</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>NumberFloatType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=kt>double</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>U</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>AllocatorType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>allocator</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>T</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=nc>SFINAE</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=kt>void</span><span class=o>></span><span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>JSONSerializer</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>adl_serializer</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=k>class</span><span class=w> </span><span class=nc>BinaryType</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>vector</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=kt>uint8_t</span><span class=o>></span>
|
||||
<span class=o>></span>
|
||||
<span class=k>class</span><span class=w> </span><span class=nc>basic_json</span><span class=p>;</span>
|
||||
</code></pre></div> <p>Type <code>json</code> is an alias for <code>basic_json<></code> and uses the default types.</p> <p>From the template arguments, the following types are derived:</p> <div class=highlight><pre><span></span><code><span class=k>using</span><span class=w> </span><span class=n>object_comparator_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>less</span><span class=o><></span><span class=p>;</span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>object_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>ObjectType</span><span class=o><</span><span class=n>StringType</span><span class=p>,</span><span class=w> </span><span class=n>basic_json</span><span class=p>,</span><span class=w> </span><span class=n>object_comparator_t</span><span class=p>,</span>
|
||||
<span class=w> </span><span class=n>AllocatorType</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=n>pair</span><span class=o><</span><span class=k>const</span><span class=w> </span><span class=n>StringType</span><span class=p>,</span><span class=w> </span><span class=n>basic_json</span><span class=o>>>></span><span class=p>;</span>
|
||||
|
||||
<span class=k>using</span><span class=w> </span><span class=n>array_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>ArrayType</span><span class=o><</span><span class=n>basic_json</span><span class=p>,</span><span class=w> </span><span class=n>AllocatorType</span><span class=o><</span><span class=n>basic_json</span><span class=o>>></span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>array_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>ArrayType</span><span class=o><</span><span class=n>basic_json</span><span class=p>,</span><span class=w> </span><span class=n>AllocatorType</span><span class=o><</span><span class=n>basic_json</span><span class=o>>></span><span class=p>;</span>
|
||||
|
||||
<span class=k>using</span><span class=w> </span><span class=n>string_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>StringType</span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>string_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>StringType</span><span class=p>;</span>
|
||||
|
||||
<span class=k>using</span><span class=w> </span><span class=n>boolean_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>BooleanType</span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>boolean_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>BooleanType</span><span class=p>;</span>
|
||||
|
||||
<span class=k>using</span><span class=w> </span><span class=n>number_integer_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>NumberIntegerType</span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>number_unsigned_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>NumberUnsignedType</span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>number_float_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>NumberFloatType</span><span class=p>;</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>number_integer_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>NumberIntegerType</span><span class=p>;</span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>number_unsigned_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>NumberUnsignedType</span><span class=p>;</span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>number_float_t</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>NumberFloatType</span><span class=p>;</span>
|
||||
|
||||
<span class=k>using</span><span class=w> </span><span class=n>binary_t</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>byte_container_with_subtype</span><span class=o><</span><span class=n>BinaryType</span><span class=o>></span><span class=p>;</span><span class=w></span>
|
||||
</code></pre></div> <h2 id=objects>Objects<a class=headerlink href=#objects title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes JSON objects as follows:</p> <blockquote> <p>An object is an unordered collection of zero or more name/value pairs, where a name is a string and a value is a string, number, boolean, null, object, or array.</p> </blockquote> <h3 id=default-type>Default type<a class=headerlink href=#default-type title="Permanent link">¶</a></h3> <p>With the default values for <em>ObjectType</em> (<code>std::map</code>), <em>StringType</em> (<code>std::string</code>), and <em>AllocatorType</em> (<code>std::allocator</code>), the default value for <code>object_t</code> is:</p> <div class=highlight><pre><span></span><code><span class=n>std</span><span class=o>::</span><span class=n>map</span><span class=o><</span><span class=w></span>
|
||||
<span class=k>using</span><span class=w> </span><span class=n>binary_t</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>byte_container_with_subtype</span><span class=o><</span><span class=n>BinaryType</span><span class=o>></span><span class=p>;</span>
|
||||
</code></pre></div> <h2 id=objects>Objects<a class=headerlink href=#objects title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes JSON objects as follows:</p> <blockquote> <p>An object is an unordered collection of zero or more name/value pairs, where a name is a string and a value is a string, number, boolean, null, object, or array.</p> </blockquote> <h3 id=default-type>Default type<a class=headerlink href=#default-type title="Permanent link">¶</a></h3> <p>With the default values for <em>ObjectType</em> (<code>std::map</code>), <em>StringType</em> (<code>std::string</code>), and <em>AllocatorType</em> (<code>std::allocator</code>), the default value for <code>object_t</code> is:</p> <div class=highlight><pre><span></span><code><span class=n>std</span><span class=o>::</span><span class=n>map</span><span class=o><</span>
|
||||
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>string</span><span class=p>,</span><span class=w> </span><span class=c1>// key_type</span>
|
||||
<span class=w> </span><span class=n>basic_json</span><span class=p>,</span><span class=w> </span><span class=c1>// value_type</span>
|
||||
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>less</span><span class=o><></span><span class=p>,</span><span class=w> </span><span class=c1>// key_compare</span>
|
||||
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>allocator</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=n>pair</span><span class=o><</span><span class=k>const</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>string</span><span class=p>,</span><span class=w> </span><span class=n>basic_json</span><span class=o>>></span><span class=w> </span><span class=c1>// allocator_type</span>
|
||||
<span class=o>></span><span class=w></span>
|
||||
</code></pre></div> <h3 id=behavior>Behavior<a class=headerlink href=#behavior title="Permanent link">¶</a></h3> <p>The choice of <code>object_t</code> influences the behavior of the JSON class. With the default type, objects have the following behavior:</p> <ul> <li>When all names are unique, objects will be interoperable in the sense that all software implementations receiving that object will agree on the name-value mappings.</li> <li>When the names within an object are not unique, it is unspecified which one of the values for a given key will be chosen. For instance, <code class=highlight><span class=p>{</span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span><span class=w></span></code> could be equal to either <code class=highlight><span class=p>{</span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span><span class=w></span></code> or <code class=highlight><span class=p>{</span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>}</span><span class=w></span></code>.</li> <li>Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see <code>dump</code>) in this order. For instance, both <code class=highlight><span class=p>{</span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>,</span><span class=w> </span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>}</span><span class=w></span></code> and <code class=highlight><span class=p>{</span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span><span class=w></span></code> will be stored and serialized as <code class=highlight><span class=p>{</span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span><span class=w></span></code>.</li> <li>When comparing objects, the order of the name/value pairs is irrelevant. This makes objects interoperable in the sense that they will not be affected by these differences. For instance, <code class=highlight><span class=p>{</span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>,</span><span class=w> </span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>}</span><span class=w></span></code> and <code class=highlight><span class=p>{</span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span><span class=w></span></code> will be treated as equal.</li> </ul> <h3 id=key-order>Key order<a class=headerlink href=#key-order title="Permanent link">¶</a></h3> <p>The order name/value pairs are added to the object is <em>not</em> preserved by the library. Therefore, iterating an object may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in alphabetical order as <code>std::map</code> with <code>std::less</code> is used by default. Please note this behavior conforms to <a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a>, because any order implements the specified "unordered" nature of JSON objects.</p> <h3 id=limits>Limits<a class=headerlink href=#limits title="Permanent link">¶</a></h3> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> specifies:</p> <blockquote> <p>An implementation may set limits on the maximum depth of nesting.</p> </blockquote> <p>In this class, the object's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the <code>max_size</code> function of a JSON object.</p> <h3 id=storage_1>Storage<a class=headerlink href=#storage_1 title="Permanent link">¶</a></h3> <p>Objects are stored as pointers in a <code>basic_json</code> type. That is, for any access to object values, a pointer of type <code>object_t*</code> must be dereferenced.</p> <h2 id=arrays>Arrays<a class=headerlinLine truncated
|
||||
<span class=o>></span>
|
||||
</code></pre></div> <h3 id=behavior>Behavior<a class=headerlink href=#behavior title="Permanent link">¶</a></h3> <p>The choice of <code>object_t</code> influences the behavior of the JSON class. With the default type, objects have the following behavior:</p> <ul> <li>When all names are unique, objects will be interoperable in the sense that all software implementations receiving that object will agree on the name-value mappings.</li> <li>When the names within an object are not unique, it is unspecified which one of the values for a given key will be chosen. For instance, <code class=highlight><span class=p>{</span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span></code> could be equal to either <code class=highlight><span class=p>{</span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span></code> or <code class=highlight><span class=p>{</span><span class=nt>"key"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>}</span></code>.</li> <li>Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see <code>dump</code>) in this order. For instance, both <code class=highlight><span class=p>{</span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>,</span><span class=w> </span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>}</span></code> and <code class=highlight><span class=p>{</span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span></code> will be stored and serialized as <code class=highlight><span class=p>{</span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span></code>.</li> <li>When comparing objects, the order of the name/value pairs is irrelevant. This makes objects interoperable in the sense that they will not be affected by these differences. For instance, <code class=highlight><span class=p>{</span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>,</span><span class=w> </span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>}</span></code> and <code class=highlight><span class=p>{</span><span class=nt>"a"</span><span class=p>:</span><span class=w> </span><span class=mi>2</span><span class=p>,</span><span class=w> </span><span class=nt>"b"</span><span class=p>:</span><span class=w> </span><span class=mi>1</span><span class=p>}</span></code> will be treated as equal.</li> </ul> <h3 id=key-order>Key order<a class=headerlink href=#key-order title="Permanent link">¶</a></h3> <p>The order name/value pairs are added to the object is <em>not</em> preserved by the library. Therefore, iterating an object may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in alphabetical order as <code>std::map</code> with <code>std::less</code> is used by default. Please note this behavior conforms to <a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a>, because any order implements the specified "unordered" nature of JSON objects.</p> <h3 id=limits>Limits<a class=headerlink href=#limits title="Permanent link">¶</a></h3> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> specifies:</p> <blockquote> <p>An implementation may set limits on the maximum depth of nesting.</p> </blockquote> <p>In this class, the object's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the <code>max_size</code> function of a JSON object.</p> <h3 id=storage_1>Storage<a class=headerlink href=#storage_1 title="Permanent link">¶</a></h3> <p>Objects are stored as pointers in a <code>basic_json</code> type. That is, for any access to object values, a pointer of type <code>object_t*</code> must be dereferenced.</p> <h2 id=arrays>Arrays<a class=headerlink href=#arrays title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes JSON arrays as follows:</p> <blockquote> <p>Line truncated
|
||||
<span class=w> </span><span class=n>basic_json</span><span class=p>,</span><span class=w> </span><span class=c1>// value_type</span>
|
||||
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>allocator</span><span class=o><</span><span class=n>basic_json</span><span class=o>></span><span class=w> </span><span class=c1>// allocator_type</span>
|
||||
<span class=o>></span><span class=w></span>
|
||||
</code></pre></div> <h3 id=limits_1>Limits<a class=headerlink href=#limits_1 title="Permanent link">¶</a></h3> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> specifies:</p> <blockquote> <p>An implementation may set limits on the maximum depth of nesting.</p> </blockquote> <p>In this class, the array's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the <code>max_size</code> function of a JSON array.</p> <h3 id=storage_2>Storage<a class=headerlink href=#storage_2 title="Permanent link">¶</a></h3> <p>Arrays are stored as pointers in a <code>basic_json</code> type. That is, for any access to array values, a pointer of type <code>array_t*</code> must be dereferenced.</p> <h2 id=strings>Strings<a class=headerlink href=#strings title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes JSON strings as follows:</p> <blockquote> <p>A string is a sequence of zero or more Unicode characters.</p> </blockquote> <p>Unicode values are split by the JSON class into byte-sized characters during deserialization.</p> <h3 id=default-type_2>Default type<a class=headerlink href=#default-type_2 title="Permanent link">¶</a></h3> <p>With the default values for <em>StringType</em> (<code>std::string</code>), the default value for <code>string_t</code> is <code class=highlight><span class=n>std</span><span class=o>::</span><span class=n>string</span><span class=w></span></code>.</p> <h3 id=encoding>Encoding<a class=headerlink href=#encoding title="Permanent link">¶</a></h3> <p>Strings are stored in UTF-8 encoding. Therefore, functions like <code>std::string::size()</code> or <code>std::string::length()</code> return the number of <strong>bytes</strong> in the string rather than the number of characters or glyphs.</p> <h3 id=string-comparison>String comparison<a class=headerlink href=#string-comparison title="Permanent link">¶</a></h3> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> states:</p> <blockquote> <p>Software implementations are typically required to test names of object members for equality. Implementations that transform the textual representation into sequences of Unicode code units and then perform the comparison numerically, code unit by code unit, are interoperable in the sense that implementations will agree in all cases on equality or inequality of two strings. For example, implementations that compare strings with escaped characters unconverted may incorrectly find that <code>"a\\b"</code> and <code>"a\u005Cb"</code> are not equal.</p> </blockquote> <p>This implementation is interoperable as it does compare strings code unit by code unit.</p> <h3 id=storage_3>Storage<a class=headerlink href=#storage_3 title="Permanent link">¶</a></h3> <p>String values are stored as pointers in a <code>basic_json</code> type. That is, for any access to string values, a pointer of type <code>string_t*</code> must be dereferenced.</p> <h2 id=booleans>Booleans<a class=headerlink href=#booleans title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> implicitly describes a boolean as a type which differentiates the two literals <code>true</code> and <code>false</code>.</p> <h3 id=default-type_3>Default type<a class=headerlink href=#default-type_3 title="Permanent link">¶</a></h3> <p>With the default values for <em>BooleanType</em> (<code class=highlight><span class=kt>bool</span><span class=w></span></code>), the default value for <code>boolean_t</code> is <code class=highlight><span class=kt>bool</span><span class=w></span></code>.</p> <h3 id=storage_4>Storage<a class=headerlink href=#storage_4 title="Permanent link">¶</a></h3> <p>Boolean values are stored directly inside a <code>basic_json</code> type.</p> <h2 id=numbers>Numbers<a class=headerlink href=#numbers title="Permanent link">¶</a></h2> <p>See the <a href=number_handling/ >number handling</a> article for a detailed discussion on how numbers are handled by this library.</p> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes numbers as follows:</p> <blockquote> <p>The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.</p> </blockquote> <p>This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, <code>numbLine truncated
|
||||
<span class=o>></span>
|
||||
</code></pre></div> <h3 id=limits_1>Limits<a class=headerlink href=#limits_1 title="Permanent link">¶</a></h3> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> specifies:</p> <blockquote> <p>An implementation may set limits on the maximum depth of nesting.</p> </blockquote> <p>In this class, the array's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the <code>max_size</code> function of a JSON array.</p> <h3 id=storage_2>Storage<a class=headerlink href=#storage_2 title="Permanent link">¶</a></h3> <p>Arrays are stored as pointers in a <code>basic_json</code> type. That is, for any access to array values, a pointer of type <code>array_t*</code> must be dereferenced.</p> <h2 id=strings>Strings<a class=headerlink href=#strings title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes JSON strings as follows:</p> <blockquote> <p>A string is a sequence of zero or more Unicode characters.</p> </blockquote> <p>Unicode values are split by the JSON class into byte-sized characters during deserialization.</p> <h3 id=default-type_2>Default type<a class=headerlink href=#default-type_2 title="Permanent link">¶</a></h3> <p>With the default values for <em>StringType</em> (<code>std::string</code>), the default value for <code>string_t</code> is <code class=highlight><span class=n>std</span><span class=o>::</span><span class=n>string</span></code>.</p> <h3 id=encoding>Encoding<a class=headerlink href=#encoding title="Permanent link">¶</a></h3> <p>Strings are stored in UTF-8 encoding. Therefore, functions like <code>std::string::size()</code> or <code>std::string::length()</code> return the number of <strong>bytes</strong> in the string rather than the number of characters or glyphs.</p> <h3 id=string-comparison>String comparison<a class=headerlink href=#string-comparison title="Permanent link">¶</a></h3> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> states:</p> <blockquote> <p>Software implementations are typically required to test names of object members for equality. Implementations that transform the textual representation into sequences of Unicode code units and then perform the comparison numerically, code unit by code unit, are interoperable in the sense that implementations will agree in all cases on equality or inequality of two strings. For example, implementations that compare strings with escaped characters unconverted may incorrectly find that <code>"a\\b"</code> and <code>"a\u005Cb"</code> are not equal.</p> </blockquote> <p>This implementation is interoperable as it does compare strings code unit by code unit.</p> <h3 id=storage_3>Storage<a class=headerlink href=#storage_3 title="Permanent link">¶</a></h3> <p>String values are stored as pointers in a <code>basic_json</code> type. That is, for any access to string values, a pointer of type <code>string_t*</code> must be dereferenced.</p> <h2 id=booleans>Booleans<a class=headerlink href=#booleans title="Permanent link">¶</a></h2> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> implicitly describes a boolean as a type which differentiates the two literals <code>true</code> and <code>false</code>.</p> <h3 id=default-type_3>Default type<a class=headerlink href=#default-type_3 title="Permanent link">¶</a></h3> <p>With the default values for <em>BooleanType</em> (<code class=highlight><span class=kt>bool</span></code>), the default value for <code>boolean_t</code> is <code class=highlight><span class=kt>bool</span></code>.</p> <h3 id=storage_4>Storage<a class=headerlink href=#storage_4 title="Permanent link">¶</a></h3> <p>Boolean values are stored directly inside a <code>basic_json</code> type.</p> <h2 id=numbers>Numbers<a class=headerlink href=#numbers title="Permanent link">¶</a></h2> <p>See the <a href=number_handling/ >number handling</a> article for a detailed discussion on how numbers are handled by this library.</p> <p><a href=https://tools.ietf.org/html/rfc8259>RFC 8259</a> describes numbers as follows:</p> <blockquote> <p>The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.</p> </blockquote> <p>This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, <code>number_integer_t</code>, <code>number_unsigned_t</code>, and <code>Line truncated
|
||||
@@ -1,57 +1,57 @@
|
||||
<!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/features/types/number_handling/ rel=canonical><link rel=icon href=../../../assets/images/favicon.png><meta name=generator content="mkdocs-1.4.2, mkdocs-material-8.5.10"><title>Number Handling - JSON for Modern C++</title><link rel=stylesheet href=../../../assets/stylesheets/main.975780f9.min.css><link rel=stylesheet href=../../../assets/stylesheets/palette.2505c338.min.css><link rel=preconnect href=https://fonts.gstatic.com crossorigin><link rel=stylesheet href="https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,700,700i%7CJetBrains+Mono:400,400i,700,700i&display=fallback"><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> <script>var palette=__md_get("__palette");if(palette&&"object"==typeof palette.color)for(var key of Object.keys(palette.color))document.body.setAttribute("data-md-color-"+key,palette.color[key])</script> <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=#number-handling 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.54Z"/></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 6h18v2H3V6m0 5h18v2H3v-2m0 5h18v2H3v-2Z"/></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> Number Handling </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_1> <label class="md-header__button md-icon" title="Switch to dark mode" for=__palette_2 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 12 20 8.69Z"/></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_2> <label class="md-header__button md-icon" title="Switch to light mode" for=__palette_1 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 12c0-2.42-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 12 20 8.69Z"/></svg> </label> </form> <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.516 6.516 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 12 14 9.5 12 5 9.5 5Z"/></svg> </label> <div class=md-search data-md-component=search role=dialog> <label class=md-search__overlay for=__search></label> <div class=md-search__inner role=search> <form class=md-search__form name=search> <input type=text class=md-search__input name=query aria-label=Search placeholder=Search autocapitalize=off autocorrect=off autocomplete=off spellcheck=false data-md-component=search-query requireLine truncated
|
||||
<span class=n>json</span><span class=w> </span><span class=n>j</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>f</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><<</span><span class=w> </span><span class=n>j</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=sc>'\n'</span><span class=p>;</span><span class=w></span>
|
||||
</code></pre></div> yields <code class=highlight><span class=mf>0.30000001192092896</span><span class=w></span></code>.</li> </ul> <p>All examples here can be reproduced by passing the original double value to</p> <div class=highlight><pre><span></span><code><span class=n>std</span><span class=o>::</span><span class=n>printf</span><span class=p>(</span><span class=s>"%.*g</span><span class=se>\n</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>numeric_limits</span><span class=o><</span><span class=kt>double</span><span class=o>>::</span><span class=n>max_digits10</span><span class=p>,</span><span class=w> </span><span class=n>double_value</span><span class=p>);</span><span class=w></span>
|
||||
</code></pre></div> </div> <h4 id=nan-handling>NaN handling<a class=headerlink href=#nan-handling title="Permanent link">¶</a></h4> <p>NaN (not-a-number) cannot be expressed with the number syntax described above and are in fact explicitly excluded:</p> <div class="admonition quote"> <p class=admonition-title><a href=https://tools.ietf.org/html/rfc8259#section-6>RFC 8259</a>, Section 6</p> <p>Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.</p> </div> <p>That is, there is no way to <em>parse</em> a NaN value. However, NaN values can be stored in a JSON value by assignment.</p> <p>This library serializes NaN values as <code class=highlight><span class=kc>null</span><span class=w></span></code>. This corresponds to the behavior of JavaScript's <a href=https://www.w3schools.com/js/js_json_stringify.asp><code>JSON.stringify</code></a> function.</p> <div class="admonition example"> <p class=admonition-title>Example</p> <p>The following example shows how a NaN value is stored in a <code>json</code> value.</p> <div class=highlight><pre><span></span><code><span class=kt>int</span><span class=w> </span><span class=nf>main</span><span class=p>()</span><span class=w></span>
|
||||
<span class=p>{</span><span class=w></span>
|
||||
<span class=w> </span><span class=kt>double</span><span class=w> </span><span class=n>val</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>numeric_limits</span><span class=o><</span><span class=kt>double</span><span class=o>>::</span><span class=n>quiet_NaN</span><span class=p>();</span><span class=w></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><<</span><span class=w> </span><span class=s>"val="</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>val</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>endl</span><span class=p>;</span><span class=w></span>
|
||||
<span class=w> </span><span class=n>json</span><span class=w> </span><span class=n>j</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>val</span><span class=p>;</span><span class=w></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><<</span><span class=w> </span><span class=s>"j="</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>j</span><span class=p>.</span><span class=n>dump</span><span class=p>()</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>endl</span><span class=p>;</span><span class=w></span>
|
||||
<span class=w> </span><span class=n>val</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>j</span><span class=p>;</span><span class=w></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><<</span><span class=w> </span><span class=s>"val="</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>val</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>endl</span><span class=p>;</span><span class=w></span>
|
||||
<span class=p>}</span><span class=w></span>
|
||||
<!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/features/types/number_handling/ rel=canonical><link href=../ rel=prev><link href=../../../integration/ rel=next><link rel=icon href=../../../assets/images/favicon.png><meta name=generator content="mkdocs-1.5.3, mkdocs-material-9.4.7"><title>Number Handling - JSON for Modern C++</title><link rel=stylesheet href=../../../assets/stylesheets/main.4b4a2bd9.min.css><link rel=stylesheet href=../../../assets/stylesheets/palette.356b1318.min.css><link rel=preconnect href=https://fonts.gstatic.com crossorigin><link rel=stylesheet href="https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,700,700i%7CJetBrains+Mono:400,400i,700,700i&display=fallback"><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> <script>var palette=__md_get("__palette");if(palette&&"object"==typeof palette.color)for(var key of Object.keys(palette.color))document.body.setAttribute("data-md-color-"+key,palette.color[key])</script> <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=#number-handling 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.54Z"/></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 6h18v2H3V6m0 5h18v2H3v-2m0 5h18v2H3v-2Z"/></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> Number Handling </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_1> <label class="md-header__button md-icon" title="Switch to dark mode" for=__palette_2 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 12 20 8.69Z"/></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_2> <label class="md-header__button md-icon" title="Switch to light mode" for=__palette_1 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 12c0-2.42-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 12 20 8.69Z"/></svg> </label> </form> <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.516 6.516 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 12 14 9.5 12 5 9.5 5Z"/></svg> </label> <div class=md-search data-md-component=search role=dialog> <label class=md-search__overlay for=__search></label> <div class=md-search__inner role=search> <form class=md-search__form name=search> <input type=text class=md-search__input name=query aria-label=Search placeholder=Search autocapitalize=off autocorrect=off autocomLine truncated
|
||||
<span class=n>json</span><span class=w> </span><span class=n>j</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>f</span><span class=p>;</span>
|
||||
<span class=n>std</span><span class=o>::</span><span class=n>cout</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>j</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=sc>'\n'</span><span class=p>;</span>
|
||||
</code></pre></div> yields <code class=highlight><span class=mf>0.30000001192092896</span></code>.</li> </ul> <p>All examples here can be reproduced by passing the original double value to</p> <div class=highlight><pre><span></span><code><span class=n>std</span><span class=o>::</span><span class=n>printf</span><span class=p>(</span><span class=s>"%.*g</span><span class=se>\n</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>numeric_limits</span><span class=o><</span><span class=kt>double</span><span class=o>>::</span><span class=n>max_digits10</span><span class=p>,</span><span class=w> </span><span class=n>double_value</span><span class=p>);</span>
|
||||
</code></pre></div> </div> <h4 id=nan-handling>NaN handling<a class=headerlink href=#nan-handling title="Permanent link">¶</a></h4> <p>NaN (not-a-number) cannot be expressed with the number syntax described above and are in fact explicitly excluded:</p> <div class="admonition quote"> <p class=admonition-title><a href=https://tools.ietf.org/html/rfc8259#section-6>RFC 8259</a>, Section 6</p> <p>Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.</p> </div> <p>That is, there is no way to <em>parse</em> a NaN value. However, NaN values can be stored in a JSON value by assignment.</p> <p>This library serializes NaN values as <code class=highlight><span class=kc>null</span></code>. This corresponds to the behavior of JavaScript's <a href=https://www.w3schools.com/js/js_json_stringify.asp><code>JSON.stringify</code></a> function.</p> <div class="admonition example"> <p class=admonition-title>Example</p> <p>The following example shows how a NaN value is stored in a <code>json</code> value.</p> <div class=highlight><pre><span></span><code><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=kt>double</span><span class=w> </span><span class=n>val</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>numeric_limits</span><span class=o><</span><span class=kt>double</span><span class=o>>::</span><span class=n>quiet_NaN</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><<</span><span class=w> </span><span class=s>"val="</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>val</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>endl</span><span class=p>;</span>
|
||||
<span class=w> </span><span class=n>json</span><span class=w> </span><span class=n>j</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>val</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><<</span><span class=w> </span><span class=s>"j="</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>j</span><span class=p>.</span><span class=n>dump</span><span class=p>()</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>endl</span><span class=p>;</span>
|
||||
<span class=w> </span><span class=n>val</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>j</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><<</span><span class=w> </span><span class=s>"val="</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>val</span><span class=w> </span><span class=o><<</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>endl</span><span class=p>;</span>
|
||||
<span class=p>}</span>
|
||||
</code></pre></div> <p>output:</p> <div class=highlight><pre><span></span><code>val=nan
|
||||
j=null
|
||||
val=nan
|
||||
</code></pre></div> </div> <h3 id=number-comparison>Number comparison<a class=headerlink href=#number-comparison title="Permanent link">¶</a></h3> <p>Floating-point inside JSON values numbers are compared with <code class=highlight><span class=n>json</span><span class=o>::</span><span class=n>number_float_t</span><span class=o>::</span><span class=n>operator</span><span class=o>==</span><span class=w></span></code> which is <code class=highlight><span class=kt>double</span><span class=o>::</span><span class=n>operator</span><span class=o>==</span><span class=w></span></code> by default.</p> <div class="admonition example"> <p class=admonition-title>Alternative comparison functions</p> <p>To compare floating-point while respecting an epsilon, an alternative <a href=https://github.com/mariokonrad/marnav/blob/master/include/marnav/math/floatingpoint.hpp#L34-#L39>comparison function</a> could be used, for instance</p> <p><div class=highlight><pre><span></span><code><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>T</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=nc>std</span><span class=o>::</span><span class=n>enable_if</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=n>is_floating_point</span><span class=o><</span><span class=n>T</span><span class=o>>::</span><span class=n>value</span><span class=p>,</span><span class=w> </span><span class=n>T</span><span class=o>>::</span><span class=n>type</span><span class=o>></span><span class=w></span>
|
||||
<span class=kr>inline</span><span class=w> </span><span class=kt>bool</span><span class=w> </span><span class=n>is_same</span><span class=p>(</span><span class=n>T</span><span class=w> </span><span class=n>a</span><span class=p>,</span><span class=w> </span><span class=n>T</span><span class=w> </span><span class=n>b</span><span class=p>,</span><span class=w> </span><span class=n>T</span><span class=w> </span><span class=n>epsilon</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>numeric_limits</span><span class=o><</span><span class=n>T</span><span class=o>>::</span><span class=n>epsilon</span><span class=p>())</span><span class=w> </span><span class=k>noexcept</span><span class=w></span>
|
||||
<span class=p>{</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>return</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>abs</span><span class=p>(</span><span class=n>a</span><span class=w> </span><span class=o>-</span><span class=w> </span><span class=n>b</span><span class=p>)</span><span class=w> </span><span class=o><=</span><span class=w> </span><span class=n>epsilon</span><span class=p>;</span><span class=w></span>
|
||||
<span class=p>}</span><span class=w></span>
|
||||
</code></pre></div> Or you can self-define an operator equal function like this:</p> <div class=highlight><pre><span></span><code><span class=kt>bool</span><span class=w> </span><span class=nf>my_equal</span><span class=p>(</span><span class=n>const_reference</span><span class=w> </span><span class=n>lhs</span><span class=p>,</span><span class=w> </span><span class=n>const_reference</span><span class=w> </span><span class=n>rhs</span><span class=p>)</span><span class=w></span>
|
||||
<span class=p>{</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=k>auto</span><span class=w> </span><span class=n>lhs_type</span><span class=w> </span><span class=n>lhs</span><span class=p>.</span><span class=n>type</span><span class=p>();</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=k>auto</span><span class=w> </span><span class=n>rhs_type</span><span class=w> </span><span class=n>rhs</span><span class=p>.</span><span class=n>type</span><span class=p>();</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>if</span><span class=w> </span><span class=p>(</span><span class=n>lhs_type</span><span class=w> </span><span class=o>==</span><span class=w> </span><span class=n>rhs_type</span><span class=p>)</span><span class=w></span>
|
||||
<span class=w> </span><span class=p>{</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>switch</span><span class=p>(</span><span class=n>lhs_type</span><span class=p>)</span><span class=w></span>
|
||||
<span class=w> </span><span class=p>{</span><span class=w></span>
|
||||
</code></pre></div> </div> <h3 id=number-comparison>Number comparison<a class=headerlink href=#number-comparison title="Permanent link">¶</a></h3> <p>Floating-point inside JSON values numbers are compared with <code class=highlight><span class=n>json</span><span class=o>::</span><span class=n>number_float_t</span><span class=o>::</span><span class=n>operator</span><span class=o>==</span></code> which is <code class=highlight><span class=kt>double</span><span class=o>::</span><span class=n>operator</span><span class=o>==</span></code> by default.</p> <div class="admonition example"> <p class=admonition-title>Alternative comparison functions</p> <p>To compare floating-point while respecting an epsilon, an alternative <a href=https://github.com/mariokonrad/marnav/blob/master/include/marnav/math/floatingpoint.hpp#L34-#L39>comparison function</a> could be used, for instance</p> <p><div class=highlight><pre><span></span><code><span class=k>template</span><span class=o><</span><span class=k>typename</span><span class=w> </span><span class=nc>T</span><span class=p>,</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=k>typename</span><span class=w> </span><span class=nc>std</span><span class=o>::</span><span class=n>enable_if</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=n>is_floating_point</span><span class=o><</span><span class=n>T</span><span class=o>>::</span><span class=n>value</span><span class=p>,</span><span class=w> </span><span class=n>T</span><span class=o>>::</span><span class=n>type</span><span class=o>></span>
|
||||
<span class=kr>inline</span><span class=w> </span><span class=kt>bool</span><span class=w> </span><span class=n>is_same</span><span class=p>(</span><span class=n>T</span><span class=w> </span><span class=n>a</span><span class=p>,</span><span class=w> </span><span class=n>T</span><span class=w> </span><span class=n>b</span><span class=p>,</span><span class=w> </span><span class=n>T</span><span class=w> </span><span class=n>epsilon</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>numeric_limits</span><span class=o><</span><span class=n>T</span><span class=o>>::</span><span class=n>epsilon</span><span class=p>())</span><span class=w> </span><span class=k>noexcept</span>
|
||||
<span class=p>{</span>
|
||||
<span class=w> </span><span class=k>return</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>abs</span><span class=p>(</span><span class=n>a</span><span class=w> </span><span class=o>-</span><span class=w> </span><span class=n>b</span><span class=p>)</span><span class=w> </span><span class=o><=</span><span class=w> </span><span class=n>epsilon</span><span class=p>;</span>
|
||||
<span class=p>}</span>
|
||||
</code></pre></div> Or you can self-define an operator equal function like this:</p> <div class=highlight><pre><span></span><code><span class=kt>bool</span><span class=w> </span><span class=nf>my_equal</span><span class=p>(</span><span class=n>const_reference</span><span class=w> </span><span class=n>lhs</span><span class=p>,</span><span class=w> </span><span class=n>const_reference</span><span class=w> </span><span class=n>rhs</span><span class=p>)</span>
|
||||
<span class=p>{</span>
|
||||
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=k>auto</span><span class=w> </span><span class=n>lhs_type</span><span class=w> </span><span class=n>lhs</span><span class=p>.</span><span class=n>type</span><span class=p>();</span>
|
||||
<span class=w> </span><span class=k>const</span><span class=w> </span><span class=k>auto</span><span class=w> </span><span class=n>rhs_type</span><span class=w> </span><span class=n>rhs</span><span class=p>.</span><span class=n>type</span><span class=p>();</span>
|
||||
<span class=w> </span><span class=k>if</span><span class=w> </span><span class=p>(</span><span class=n>lhs_type</span><span class=w> </span><span class=o>==</span><span class=w> </span><span class=n>rhs_type</span><span class=p>)</span>
|
||||
<span class=w> </span><span class=p>{</span>
|
||||
<span class=w> </span><span class=k>switch</span><span class=p>(</span><span class=n>lhs_type</span><span class=p>)</span>
|
||||
<span class=w> </span><span class=p>{</span>
|
||||
<span class=w> </span><span class=c1>// self_defined case</span>
|
||||
<span class=w> </span><span class=k>case</span><span class=w> </span><span class=no>value_t</span><span class=o>::</span><span class=no>number_float</span><span class=p>:</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>return</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>abs</span><span class=p>(</span><span class=n>lhs</span><span class=w> </span><span class=o>-</span><span class=w> </span><span class=n>rhs</span><span class=p>)</span><span class=w> </span><span class=o><=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>numeric_limits</span><span class=o><</span><span class=kt>float</span><span class=o>>::</span><span class=n>epsilon</span><span class=p>();</span><span class=w></span>
|
||||
<span class=w> </span><span class=k>case</span><span class=w> </span><span class=no>value_t</span><span class=o>::</span><span class=no>number_float</span><span class=p>:</span>
|
||||
<span class=w> </span><span class=k>return</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>abs</span><span class=p>(</span><span class=n>lhs</span><span class=w> </span><span class=o>-</span><span class=w> </span><span class=n>rhs</span><span class=p>)</span><span class=w> </span><span class=o><=</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=n>numeric_limits</span><span class=o><</span><span class=kt>float</span><span class=o>>::</span><span class=n>epsilon</span><span class=p>();</span>
|
||||
|
||||
<span class=w> </span><span class=c1>// other cases remain the same with the original</span>
|
||||
<span class=w> </span><span class=p>...</span><span class=w></span>
|
||||
<span class=w> </span><span class=p>}</span><span class=w></span>
|
||||
<span class=w> </span><span class=p>}</span><span class=w></span>
|
||||
<span class=w> </span><span class=p>...</span><span class=w></span>
|
||||
<span class=p>}</span><span class=w></span>
|
||||
<span class=w> </span><span class=p>...</span>
|
||||
<span class=w> </span><span class=p>}</span>
|
||||
<span class=w> </span><span class=p>}</span>
|
||||
<span class=w> </span><span class=p>...</span>
|
||||
<span class=p>}</span>
|
||||
</code></pre></div> <p>(see <a href=https://github.com/nlohmann/json/issues/703>#703</a> for more information.)</p> </div> <div class="admonition note"> <p class=admonition-title>Note</p> <p>NaN values never compare equal to themselves or to other NaN values. See <a href=https://github.com/nlohmann/json/issues/514>#514</a>.</p> </div> <h3 id=number-conversion>Number conversion<a class=headerlink href=#number-conversion title="Permanent link">¶</a></h3> <p>Just like the C++ language itself, the <code>get</code> family of functions allows conversions between unsigned and signed integers, and between integers and floating-point values to integers. This behavior may be surprising.</p> <div class="admonition warning"> <p class=admonition-title>Unconditional number conversions</p> <div class=highlight><pre><span></span><code><span class=kt>double</span><span class=w> </span><span class=n>d</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=mf>42.3</span><span class=p>;</span><span class=w> </span><span class=c1>// non-integer double value 42.3</span>
|
||||
<span class=n>json</span><span class=w> </span><span class=n>jd</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>d</span><span class=p>;</span><span class=w> </span><span class=c1>// stores double value 42.3</span>
|
||||
<span class=hll><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=w> </span><span class=n>i</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>jd</span><span class=p>.</span><span class=k>template</span><span class=w> </span><span class=n>get</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=o>></span><span class=p>();</span><span class=w> </span><span class=c1>// now i==42; no warning or error is produced</span>
|
||||
</span></code></pre></div> <p>Note the last line with throw a <a href=../../../home/exceptions/#jsonexceptiontype_error302><code>json.exception.type_error.302</code></a> exception if <code>jd</code> is not a numerical type, for instance a string.</p> </div> <p>The rationale is twofold:</p> <ol> <li>JSON does not define a number type or precision (see <a href=above>#json-specification</a>).</li> <li>C++ also allows to silently convert between number types.</li> </ol> <div class="admonition success"> <p class=admonition-title>Conditional number conversion</p> <p>The code above can be solved by explicitly checking the nature of the value with members such as <a href=../../../api/basic_json/is_number_integer/ ><code>is_number_integer()</code></a> or <a href=../../../api/basic_json/is_number_unsigned/ ><code>is_number_unsigned()</code></a>:</p> <div class=highlight><pre><span></span><code><span class=c1>// check if jd is really integer-valued</span>
|
||||
<span class=hll><span class=k>if</span><span class=w> </span><span class=p>(</span><span class=n>jd</span><span class=p>.</span><span class=n>is_number_integer</span><span class=p>())</span><span class=w></span>
|
||||
</span><span class=p>{</span><span class=w></span>
|
||||
</span></code></pre></div> <p>Note the last line with throw a <a href=../../../home/exceptions/#jsonexceptiontype_error302><code>json.exception.type_error.302</code></a> exception if <code>jd</code> is not a numerical type, for instance a string.</p> </div> <p>The rationale is twofold:</p> <ol> <li>JSON does not define a number type or precision (see above).</li> <li>C++ also allows to silently convert between number types.</li> </ol> <div class="admonition success"> <p class=admonition-title>Conditional number conversion</p> <p>The code above can be solved by explicitly checking the nature of the value with members such as <a href=../../../api/basic_json/is_number_integer/ ><code>is_number_integer()</code></a> or <a href=../../../api/basic_json/is_number_unsigned/ ><code>is_number_unsigned()</code></a>:</p> <div class=highlight><pre><span></span><code><span class=c1>// check if jd is really integer-valued</span>
|
||||
<span class=hll><span class=k>if</span><span class=w> </span><span class=p>(</span><span class=n>jd</span><span class=p>.</span><span class=n>is_number_integer</span><span class=p>())</span>
|
||||
</span><span class=p>{</span>
|
||||
<span class=w> </span><span class=c1>// if so, do the conversion and use i</span>
|
||||
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=w> </span><span class=n>i</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>jd</span><span class=p>.</span><span class=k>template</span><span class=w> </span><span class=n>get</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=o>></span><span class=p>();</span><span class=w></span>
|
||||
<span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=w> </span><span class=n>i</span><span class=w> </span><span class=o>=</span><span class=w> </span><span class=n>jd</span><span class=p>.</span><span class=k>template</span><span class=w> </span><span class=n>get</span><span class=o><</span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=o>></span><span class=p>();</span>
|
||||
<span class=w> </span><span class=c1>// ...</span>
|
||||
<span class=p>}</span><span class=w></span>
|
||||
<span class=k>else</span><span class=w></span>
|
||||
<span class=p>{</span><span class=w></span>
|
||||
<span class=p>}</span>
|
||||
<span class=k>else</span>
|
||||
<span class=p>{</span>
|
||||
<span class=w> </span><span class=c1>// otherwise, take appropriate action</span>
|
||||
<span class=w> </span><span class=c1>// ...</span>
|
||||
<span class=p>}</span><span class=w></span>
|
||||
</code></pre></div> <p>Note this approach also has the advantage that it can react on non-numerical JSON value types such as strings.</p> <p>(Example taken from <a href=https://github.com/nlohmann/json/issues/777#issuecomment-459968458>#777</a>.)</p> </div> <h3 id=determine-number-types>Determine number types<a class=headerlink href=#determine-number-types title="Permanent link">¶</a></h3> <p>As the example in <a href=#number-conversion>Number conversion</a> shows, there are different functions to determine the type of the stored number:</p> <ul> <li><a href=../../../api/basic_json/is_number/ ><code>is_number()</code></a> returns <code class=highlight><span class=nb>true</span><span class=w></span></code> for any number type</li> <li><a href=../../../api/basic_json/is_number_integer/ ><code>is_number_integer()</code></a> returns <code class=highlight><span class=nb>true</span><span class=w></span></code> for signed and unsigned integers</li> <li><a href=../../../api/basic_json/is_number_unsigned/ ><code>is_number_unsigned()</code></a> returns <code class=highlight><span class=nb>true</span><span class=w></span></code> for unsigned integers only</li> <li><a href=../../../api/basic_json/is_number_float/ ><code>is_number_float()</code></a> returns <code class=highlight><span class=nb>true</span><span class=w></span></code> for floating-point numbers</li> <li><a href=../../../api/basic_json/type_name/ ><code>type_name()</code></a> returns <code class=highlight><span class=s>"number"</span><span class=w></span></code> for any number type</li> <li><a href=../../../api/basic_json/type/ ><code>type()</code></a> returns a different enumerator of <a href=../../../api/basic_json/value_t/ ><code>value_t</code></a> for all number types</li> </ul> <table> <thead> <tr> <th>function</th> <th>unsigned integer</th> <th>signed integer</th> <th>floating-point</th> <th>string</th> </tr> </thead> <tbody> <tr> <td><a href=../../../api/basic_json/is_number/ ><code>is_number()</code></a></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/is_number_integer/ ><code>is_number_integer()</code></a></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/is_number_unsigned/ ><code>is_number_unsigned()</code></a></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/is_number_float/ ><code>is_number_float()</code></a></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>true</span><span class=w></span></code></td> <td><code class=highlight><span class=nb>false</span><span class=w></span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/type_name/ ><code>type_name()</code></a></td> <td><code class=highlight><span class=s>"number"</span><span class=w></span></code></td> <td><code class=highlight><span class=s>"number"</span><span class=w></span></code></td> <td><code class=highlight><span class=s>"number"</span><span class=w></span></code></td> <td><code class=highlight><span class=s>"string"</span><span class=w></span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/type/ ><code>type()</code></a></td> <td><code>number_unsigned</code></td> <td><code>number_integer</code></td> <td><code>number_float</code></td> <td><code>string</code></td> </tr> </tbody> </table> <h3 id=template-number-types>Template number types<a class=headerlink href=#template-number-types title="Permanent link">¶</a></h3> <p>The number types can be changed with template parameters.</p> <table> <thead> <tr> <th>position</th> <th>number type</th> <th>default type</th> <th>possible values</th> </tr> </thead> <tbody> <tr> <td>5</td> <td>signed integers</td> <td><code class=highlight><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=w></span></code></td> <td><code class=highlight><Line truncated
|
||||
<span class=hll><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=p>,</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>uint64_t</span><span class=p>,</span><span class=w> </span><span class=kt>long</span><span class=w> </span><span class=kt>double</span><span class=o>></span><span class=p>;</span><span class=w></span>
|
||||
</span></code></pre></div> <p>Note values should then be parsed with <code>json_ld::parse</code> rather than <code>json::parse</code> as the latter would parse floating-point values to <code class=highlight><span class=kt>double</span><span class=w></span></code> before then converting them to <code class=highlight><span class=kt>long</span><span class=w> </span><span class=kt>double</span><span class=w></span></code>.</p> </div> <hr> <div class=md-source-file> <small> Last update: <span class="git-revision-date-localized-plugin git-revision-date-localized-plugin-date">June 11, 2023</span> </small> </div> </article> </div> <script>var tabs=__md_get("__tabs");if(Array.isArray(tabs))e:for(var set of document.querySelectorAll(".tabbed-set")){var tab,labels=set.querySelector(".tabbed-labels");for(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> </div> <a href=# 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 8v12Z"/></svg> Back to top </a> </main> <footer class=md-footer> <nav class="md-footer__inner md-grid" aria-label=Footer> <a href=../ class="md-footer__link md-footer__link--prev" aria-label="Previous: Types" rel=prev> <div class="md-footer__button md-icon"> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M20 11v2H8l5.5 5.5-1.42 1.42L4.16 12l7.92-7.92L13.5 5.5 8 11h12Z"/></svg> </div> <div class=md-footer__title> <div class=md-ellipsis> <span class=md-footer__direction> Previous </span> Types </div> </div> </a> <a href=../../../integration/ class="md-footer__link md-footer__link--next" aria-label="Next: Header only" rel=next> <div class=md-footer__title> <div class=md-ellipsis> <span class=md-footer__direction> Next </span> Header only </div> </div> <div class="md-footer__button md-icon"> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 24 24"><path d="M4 11v2h12l-5.5 5.5 1.42 1.42L19.84 12l-7.92-7.92L10.5 5.5 16 11H4Z"/></svg> </div> </a> </nav> <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 © 2013 - 2022 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 496 512"><!-- Font Awesome Free 6.2.1 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 2022 Fonticons, Inc.--><path d="M165.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.6zm-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.3zm44.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.9zM244.8 8C106.1 8 0 113.3 0 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.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.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-1zm-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.7zm32.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-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg> </a> <a href=https://twitter.com/nlohmann target=_blank rel=noopener title=twitter.com class=md-social__link> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 512 512"><!-- Font Awesome Free 6.2.1 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 2022 Fonticons, Inc.--><path d="M459.37 151.716c.325 4.548.325 9.097.325 13.645 0 138.72-105.583 298.558-298.558 298.558-59.452 0-114.68-17.219-161.137-47.106 8.447.974 16.568 1.299 25.34 1.299 49.055 0 94.213-16.568 130.274-44.832-46.132-.975-84.792-31.188-98.112-72.772 6.498.974 12.995 1.624 19.818 1.624 9.421 0 18.843-1.3 27.614-3.573-48.081-9.747-84.143-51.98-84.143-102.985v-1.299c13.969 7.797 30.214 12.67 47.431 13.319-28.264-18.843-46.781-51.005-46.781-87.391 0-19.492 5.197-37.36 14.294-52.954 51.655 63.675 129.3 105.258 216.365 109.807-1.6Line truncated
|
||||
<span class=p>}</span>
|
||||
</code></pre></div> <p>Note this approach also has the advantage that it can react on non-numerical JSON value types such as strings.</p> <p>(Example taken from <a href=https://github.com/nlohmann/json/issues/777#issuecomment-459968458>#777</a>.)</p> </div> <h3 id=determine-number-types>Determine number types<a class=headerlink href=#determine-number-types title="Permanent link">¶</a></h3> <p>As the example in <a href=#number-conversion>Number conversion</a> shows, there are different functions to determine the type of the stored number:</p> <ul> <li><a href=../../../api/basic_json/is_number/ ><code>is_number()</code></a> returns <code class=highlight><span class=nb>true</span></code> for any number type</li> <li><a href=../../../api/basic_json/is_number_integer/ ><code>is_number_integer()</code></a> returns <code class=highlight><span class=nb>true</span></code> for signed and unsigned integers</li> <li><a href=../../../api/basic_json/is_number_unsigned/ ><code>is_number_unsigned()</code></a> returns <code class=highlight><span class=nb>true</span></code> for unsigned integers only</li> <li><a href=../../../api/basic_json/is_number_float/ ><code>is_number_float()</code></a> returns <code class=highlight><span class=nb>true</span></code> for floating-point numbers</li> <li><a href=../../../api/basic_json/type_name/ ><code>type_name()</code></a> returns <code class=highlight><span class=s>"number"</span></code> for any number type</li> <li><a href=../../../api/basic_json/type/ ><code>type()</code></a> returns a different enumerator of <a href=../../../api/basic_json/value_t/ ><code>value_t</code></a> for all number types</li> </ul> <table> <thead> <tr> <th>function</th> <th>unsigned integer</th> <th>signed integer</th> <th>floating-point</th> <th>string</th> </tr> </thead> <tbody> <tr> <td><a href=../../../api/basic_json/is_number/ ><code>is_number()</code></a></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/is_number_integer/ ><code>is_number_integer()</code></a></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/is_number_unsigned/ ><code>is_number_unsigned()</code></a></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/is_number_float/ ><code>is_number_float()</code></a></td> <td><code class=highlight><span class=nb>false</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> <td><code class=highlight><span class=nb>true</span></code></td> <td><code class=highlight><span class=nb>false</span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/type_name/ ><code>type_name()</code></a></td> <td><code class=highlight><span class=s>"number"</span></code></td> <td><code class=highlight><span class=s>"number"</span></code></td> <td><code class=highlight><span class=s>"number"</span></code></td> <td><code class=highlight><span class=s>"string"</span></code></td> </tr> <tr> <td><a href=../../../api/basic_json/type/ ><code>type()</code></a></td> <td><code>number_unsigned</code></td> <td><code>number_integer</code></td> <td><code>number_float</code></td> <td><code>string</code></td> </tr> </tbody> </table> <h3 id=template-number-types>Template number types<a class=headerlink href=#template-number-types title="Permanent link">¶</a></h3> <p>The number types can be changed with template parameters.</p> <table> <thead> <tr> <th>position</th> <th>number type</th> <th>default type</th> <th>possible values</th> </tr> </thead> <tbody> <tr> <td>5</td> <td>signed integers</td> <td><code class=highlight><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span></code></td> <td><code class=highlight><span class=n>std</span><span class=o>::</span><span class=kt>int32_t</span></code>, <code class=highlight><span class=n>std</span><span class=o>::</span><span class=kt>int16_t</span></code>, etc.</td> </tr> <tr> <td>6</td> <td>unsigned integers</td> <td><code class=highlight><span class=n>std</span><span class=o>::</span><span class=kt>uint64_t</span></code></td> <td><code class=highlight><span class=n>std</span><span class=o>::</span><span class=kt>uint32_t</span></code>, <code class=highlight><span class=n>std</span><span class=o>::</spanLine truncated
|
||||
<span class=hll><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>int64_t</span><span class=p>,</span><span class=w> </span><span class=n>std</span><span class=o>::</span><span class=kt>uint64_t</span><span class=p>,</span><span class=w> </span><span class=kt>long</span><span class=w> </span><span class=kt>double</span><span class=o>></span><span class=p>;</span>
|
||||
</span></code></pre></div> <p>Note values should then be parsed with <code>json_ld::parse</code> rather than <code>json::parse</code> as the latter would parse floating-point values to <code class=highlight><span class=kt>double</span></code> before then converting them to <code class=highlight><span class=kt>long</span><span class=w> </span><span class=kt>double</span></code>.</p> </div> <hr> <div class=md-source-file> <small> Last update: <span class="git-revision-date-localized-plugin git-revision-date-localized-plugin-date">November 1, 2023</span> </small> </div> </article> </div> <script>var tabs=__md_get("__tabs");if(Array.isArray(tabs))e:for(var set of document.querySelectorAll(".tabbed-set")){var tab,labels=set.querySelector(".tabbed-labels");for(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> </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 8v12Z"/></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 © 2013 - 2023 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 496 512"><!-- Font Awesome Free 6.4.2 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 2023 Fonticons, Inc.--><path d="M165.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.6zm-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.3zm44.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.9zM244.8 8C106.1 8 0 113.3 0 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.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.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-1zm-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.7zm32.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-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg> </a> <a href=https://twitter.com/nlohmann target=_blank rel=noopener title=twitter.com class=md-social__link> <svg xmlns=http://www.w3.org/2000/svg viewbox="0 0 512 512"><!-- Font Awesome Free 6.4.2 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 2023 Fonticons, Inc.--><path d="M459.37 151.716c.325 4.548.325 9.097.325 13.645 0 138.72-105.583 298.558-298.558 298.558-59.452 0-114.68-17.219-161.137-47.106 8.447.974 16.568 1.299 25.34 1.299 49.055 0 94.213-16.568 130.274-44.832-46.132-.975-84.792-31.188-98.112-72.772 6.498.974 12.995 1.624 19.818 1.624 9.421 0 18.843-1.3 27.614-3.573-48.081-9.747-84.143-51.98-84.143-102.985v-1.299c13.969 7.797 30.214 12.67 47.431 13.319-28.264-18.843-46.781-51.005-46.781-87.391 0-19.492 5.197-37.36 14.294-52.954 51.655 63.675 129.3 105.258 216.365 109.807-1.624-7.797-2.599-15.918-2.599-24.04 0-57.828 46.782-104.934 104.934-104.934 30.213 0 57.502 12.67 76.67 33.137 23.715-4.548 46.456-13.32 66.599-25.34-7.798 24.366-24.366 44.833-46.132 57.827 21.117-2.273 41.584-8.122 60.426-16.243-14.292 20.791-32.161 39.308-52.628 54.253z"/></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 6.4.2 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 2023 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.3zM135.4 416H69V202.2h66.5V416zm-33.2-243c-21.3 0-38.5-17.3-38.5-38.5S80.9 96 102.2 96c21.2 0 38.5 17.3 38.5 38.5 0 21.3-17.2 38.5-3Line truncated
|
||||
Reference in new issue
Block a user