JSON for Modern C++ 2.1.1
Loading...
Searching...
No Matches

◆ operator ValueType()

template<template< typename U, typename V, typename... Args > class ObjectType = std::map, template< typename U, typename... Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator, template< typename T, typename SFINAE=void > class JSONSerializer = adl_serializer>
template<typename ValueType , typename std::enable_if< not std::is_pointer< ValueType >::value and not std::is_same< ValueType, typename string_t::value_type >::value and not std::is_same< ValueType, std::initializer_list< typename string_t::value_type > >::value, int >::type = 0>
nlohmann::basic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer >::operator ValueType ( ) const
inline

Implicit type conversion between the JSON value and a compatible value. The call is realized by calling get() const.

Template Parameters
ValueTypenon-pointer type compatible to the JSON value, for instance int for JSON integer numbers, bool for JSON booleans, or std::vector types for JSON arrays. The character type of string_t as well as an initializer list of this type is excluded to avoid ambiguities as these types implicitly convert to std::string.
Returns
copy of the JSON value, converted to type ValueType
Exceptions
std::domain_errorin case passed type ValueType is incompatible to JSON, thrown by get() const
Complexity\n Linear in the size of the JSON value.
Example\n 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::unordered_map<std::string, json>.
1#include <json.hpp>
2#include <unordered_map>
3
4using json = nlohmann::json;
5
6int main()
7{
8 // create a JSON value with different types
10 {
11 {"boolean", true},
12 {
13 "number", {
14 {"integer", 42},
15 {"floating-point", 17.23}
16 }
17 },
18 {"string", "Hello, world!"},
19 {"array", {1, 2, 3, 4, 5}},
20 {"null", nullptr}
21 };
22
23 // use implicit conversions
24 bool v1 = json_types["boolean"];
25 int v2 = json_types["number"]["integer"];
26 short v3 = json_types["number"]["integer"];
27 float v4 = json_types["number"]["floating-point"];
28 int v5 = json_types["number"]["floating-point"];
29 std::string v6 = json_types["string"];
30 std::vector<short> v7 = json_types["array"];
31 std::unordered_map<std::string, json> v8 = json_types;
32
33 // print the conversion results
34 std::cout << v1 << '\n';
35 std::cout << v2 << ' ' << v3 << '\n';
36 std::cout << v4 << ' ' << v5 << '\n';
37 std::cout << v6 << '\n';
38
39 for (auto i : v7)
40 {
41 std::cout << i << ' ';
42 }
43 std::cout << "\n\n";
44
45 for (auto i : v8)
46 {
47 std::cout << i.first << ": " << i.second << '\n';
48 }
49}
static basic_json array(std::initializer_list< basic_json > init=std::initializer_list< basic_json >())
explicitly create an array from an initializer list
Definition json.hpp:2165
a class to store JSON values
Definition json.hpp:1040
basic_json<> json
default JSON class
Definition json.hpp:12369

Output (play with this example online):
1
42 42
17.23 17
Hello, world!
1 2 3 4 5 

string: "Hello, world!"
number: {"floating-point":17.23,"integer":42}
null: null
boolean: true
array: [1,2,3,4,5]

The example code above can be translated with
g++ -std=c++11 -Isrc doc/examples/operator__ValueType.cpp -o operator__ValueType 
Since
version 1.0.0

Definition at line 3492 of file json.hpp.