// (1) template<typename ValueType> ValueType get() const noexcept( noexcept(JSONSerializer<ValueType>::from_json( std::declval<const basic_json_t&>(), std::declval<ValueType&>()))); // (2) template<typename BasicJsonType> BasicJsonType get() const; // (3) template<typename PointerType> PointerType get() noexcept; template<typename PointerType> const PointerType get() const noexcept; // constexpr since C++14
Explicit type conversion between the JSON value and a compatible value which is CopyConstructible and DefaultConstructible. The value is converted by calling the json_serializer<ValueType> from_json() method.
The function is equivalent to executing
ValueType ret; JSONSerializer<ValueType>::from_json(*this, ret); return ret;
This overload is chosen if:
ValueType is not basic_json,json_serializer<ValueType> has a from_json() method of the form void from_json(const basic_json&, ValueType&), andjson_serializer<ValueType> does not have a from_json() method of the form ValueType from_json(const basic_json&)If the type is not CopyConstructible and not DefaultConstructible, the value is converted by calling the json_serializer<ValueType> from_json() method.
The function is then equivalent to executing
return JSONSerializer<ValueTypeCV>::from_json(*this);
This overload is chosen if:
ValueType is not basic_json andjson_serializer<ValueType> has a from_json() method of the form ValueType from_json(const basic_json&)If json_serializer<ValueType> has both overloads of from_json(), the latter one is chosen.
Overload for basic_json specializations. The function is equivalent to executing
return *this;
Explicit pointer access to the internally stored JSON value. No copies are made.
ValueType : the value type to return
BasicJsonType : a specialization of basic_json
PointerType : pointer type; must be a pointer to array_t, object_t, string_t, boolean_t, number_integer_t, or number_unsigned_t, number_float_t, or binary_t. Other types will not compile.
ValueType#!cpp *this, converted into BasicJsonType#!cpp nullptr otherwiseDepends on what json_serializer<ValueType> from_json() method throws for overloads (1) and (2); the JSON value itself is never modified, since get() is a #!cpp const member function. No-throw guarantee for overload (3): this function never throws exceptions.
Depends on what json_serializer<ValueType> from_json() method throws
Depends on the json_serializer<ValueType>::from_json() implementation for overloads (1) and (2); constant for overload (3).
!!! danger “Undefined behavior for pointers”
Writing data to the pointee (overload 3) of the result yields an undefined state.
!!! danger “Undefined behavior for numeric conversions”
Conversions between numeric types are performed by the corresponding `from_json()` implementation using the target C++ type. When converting between numeric types, the library does not check whether the source value is representable by the target type. If the source value is outside the range of the target type, the behavior is the same as the corresponding C++ conversion. In particular, converting a floating-point value to an integer type that cannot represent the value results in undefined behavior. See [Number conversion](../../features/types/number_handling.md#number-conversion) for more information.
!!! note “std::optional conversions”
Prior to version 3.13.0, `#!cpp get<std::optional<T>>()` (and other conversions to `std::optional<T>`) failed to compile in every configuration, due to an internal implementation bug that made the `from_json` overload for `std::optional` unreachable regardless of the [`JSON_USE_IMPLICIT_CONVERSIONS`](../macros/json_use_implicit_conversions.md) setting. This has been fixed.
??? example “Example: (1) explicit conversion to compatible types”
The example below shows several conversions from JSON values
to other types. There a few things to note: (1) Floating-point numbers can
be converted to integers, (2) A JSON array can be converted to a standard
`std::vector<short>`, (3) A JSON object can be converted to C++
associative containers such as `std::map<std::string, json>`.
```cpp
#include <iostream>
#include <map>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create a JSON value with different types
json json_types =
{
{"boolean", true},
{
"number", {
{"integer", 42},
{"floating-point", 17.23}
}
},
{"string", "Hello, world!"},
{"array", {1, 2, 3, 4, 5}},
{"null", nullptr}
};
// use explicit conversions
auto v1 = json_types["boolean"].get<bool>();
auto v2 = json_types["number"]["integer"].get<int>();
auto v3 = json_types["number"]["integer"].get<short>();
auto v4 = json_types["number"]["floating-point"].get<float>();
auto v5 = json_types["number"]["floating-point"].get<int>();
auto v6 = json_types["string"].get<std::string>();
auto v7 = json_types["array"].get<std::vector<short>>();
auto v8 = json_types.get<std::map<std::string, json>>();
// print the conversion results
std::cout << v1 << '\n';
std::cout << v2 << ' ' << v3 << '\n';
std::cout << v4 << ' ' << v5 << '\n';
std::cout << v6 << '\n';
for (auto i : v7)
{
std::cout << i << ' ';
}
std::cout << "\n\n";
for (auto i : v8)
{
std::cout << i.first << ": " << i.second << '\n';
}
}
```
Output:
```json
1
42 42
17.23 17
Hello, world!
1 2 3 4 5
array: [1,2,3,4,5]
boolean: true
null: null
number: {"floating-point":17.23,"integer":42}
string: "Hello, world!"
```
??? example “Example: (2) explicit conversion to another basic_json specialization”
The example below shows how a `json` value is converted to an `ordered_json` value using `get<BasicJsonType>()`.
```cpp
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
using ordered_json = nlohmann::ordered_json;
int main()
{
// create a JSON value
json j = {{"one", 1}, {"two", 2}, {"three", 3}};
// convert to a different basic_json specialization
ordered_json oj = j.get<ordered_json>();
std::cout << j << '\n';
std::cout << oj << '\n';
}
```
Output:
```json
{"one":1,"three":3,"two":2}
{"one":1,"three":3,"two":2}
```
??? example “Example: (3) explicit pointer access to the stored value”
The example below shows how pointers to internal values of a JSON value can be requested. Note that no type
conversions are made and a `#cpp nullptr` is returned if the value and the requested pointer type does not match.
```cpp
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create a JSON number
json value = 17;
// explicitly getting pointers
auto p1 = value.get<const json::number_integer_t*>();
auto p2 = value.get<json::number_integer_t*>();
auto p3 = value.get<json::number_integer_t* const>();
auto p4 = value.get<const json::number_integer_t* const>();
auto p5 = value.get<json::number_float_t*>();
// print the pointees
std::cout << *p1 << ' ' << *p2 << ' ' << *p3 << ' ' << *p4 << '\n';
std::cout << std::boolalpha << (p5 == nullptr) << '\n';
}
```
Output:
```json
17 17 17 17
true
```
basic_json value)basic_json in version 3.2.0.