json/docs/mkdocs/docs/api/basic_json/array_t.md

nlohmann::basic_json::array_t

using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;

The type used to store JSON arrays.

RFC 8259 describes JSON arrays as follows:

An array is an ordered sequence of zero or more values.

To store objects in C++, a type is defined by the template parameters explained below.

Template parameters

ArrayType

container type to store arrays. It must be a vector-like container: the library uses operator[], at(), and resize(), and requires random-access iterators. #!cpp std::vector and #!cpp std::deque qualify; #!cpp std::list does not. See Template Parameter Requirements for the full list of requirements.

AllocatorType

the allocator to use for objects (e.g., std::allocator)

Notes

Default type

With the default values for ArrayType (std::vector) and AllocatorType (std::allocator), the default type for array_t is:

std::vector<
  basic_json, // value_type
  std::allocator<basic_json> // allocator_type
>

Limits

RFC 8259 specifies:

An implementation may set limits on the maximum depth of nesting.

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 max_size function of a JSON array.

Storage

Arrays are stored as pointers in a basic_json type. That is, for any access to array values, a pointer of type #!cpp array_t* must be dereferenced.

Examples

??? example

The following code shows that `array_t` is by default, a typedef to `#!cpp std::vector<nlohmann::json>`.
 
```cpp
--8<-- "examples/array_t.cpp"
```

Output:

```json
--8<-- "examples/array_t.output"
```

See also

• object_t - the type used to store JSON objects
• binary_t - the type used to store binary values
• is_array - checks whether the JSON value is an array
• max_size - returns the maximum possible number of elements
• Types - how arrays are stored
• Template Parameter Requirements - requirements on the ArrayType template parameter

Version history

• Added in version 1.0.0.
• Made capacity() optional, so that array types such as #!cpp std::deque can be used, in version 3.13.0.