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 = int64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator>
RFC 7159 describes JSON objects as follows:
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.
To store objects in C++, a type is defined by the template parameters ObjectType which chooses the container (e.g., std::map
or std::unordered_map
), StringType which chooses the type of the keys or names, and AllocatorType which chooses the allocator to use.
Default type
With the default values for ObjectType (std::map
), StringType (std::string
), and AllocatorType (std::allocator
), the default value for object_t is:
std::map<
std::string,
std::less<std::string>,
std::allocator<std::pair<const std::string, basic_json>>
>
Behavior
The choice of object_t influences the behavior of the JSON class. With the default type, objects have the following behavior:
- 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.
- When the names within an object are not unique, later stored name/value pairs overwrite previously stored name/value pairs, leaving the used names unique. For instance,
{"key": 1}
and {"key": 2, "key": 1}
will be treated as equal and both stored as {"key": 1}
.
- Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see dump) in this order. For instance,
{"b": 1, "a": 2}
and {"a": 2, "b": 1}
will be stored and serialized as {"a": 2, "b": 1}
.
- 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,
{"b": 1, "a": 2}
and {"a": 2, "b": 1}
will be treated as equal.
Limits
RFC 7159 specifies:
An implementation may set limits on the maximum depth of nesting.
In this class, the object's limit of nesting is not constraint explicitly. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON object.
Storage
Objects are stored as pointers in a basic_json
type. That is, for any access to object values, a pointer of type object_t*
must be dereferenced.
- See also
- array_t