JSON for Modern C++  2.0.3
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 ValueType , typename std::enable_if< not std::is_pointer< ValueType >::value andnot std::is_same< ValueType, typename string_t::value_type >::valueand not std::is_same< ValueType, std::initializer_list< typename string_t::value_type >>::value, int >::type = 0>
nlohmann::basic_json::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
Linear in the size of the JSON value.
Example
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 
4 using json = nlohmann::json;
5 
6 int main()
7 {
8  // create a JSON value with different types
9  json json_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 }
basic_json<> json
default JSON class
Definition: json.hpp:10122
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 3108 of file json.hpp.