// (1) reference operator[](size_type idx); const_reference operator[](size_type idx) const; // (2) reference operator[](const typename object_t::key_type& key); const_reference operator[](const typename object_t::key_type& key) const; template<typename T> reference operator[](T* key); template<typename T> const_reference operator[](T* key) const; // (3) reference operator[](const json_pointer& ptr); const_reference operator[](const json_pointer& ptr) const;
idx
.key
.ptr
.T
: string literal convertible to object_t::key_type
idx
(in) : index of the element to access
key
(in) : object key of the elements to remove
ptr
(in) : JSON pointer to the desired element
idx
key
ptr
type_error.305
if the JSON value is not an array or null; in that cases, using the []
operator with an index makes no sense.type_error.305
if the JSON value is not an array or null; in that cases, using the []
operator with an index makes no sense.parse_error.106
if an array index in the passed JSON pointer ptr
begins with ‘0’.parse_error.109
if an array index in the passed JSON pointer ptr
is not a number.out_of_range.402
if the array index ‘-’ is used in the passed JSON pointer ptr
for the const version.out_of_range.404
if the JSON pointer ptr
can not be resolved.!!! danger
1. If the element with key `idx` does not exist, the behavior is undefined. 2. If the element with key `key` does not exist, the behavior is undefined and is **guarded by an assertion**!
The non-const version may add values: If idx
is beyond the range of the array (i.e., idx >= size()
), then the array is silently filled up with #!json null
values to make idx
a valid reference to the last stored element. In case the value was #!json null
before, it is converted to an array.
If key
is not found in the object, then it is silently added to the object and filled with a #!json null
value to make key
a valid reference. In case the value was #!json null
before, it is converted to an object.
null
values are created in arrays and objects if necessary.
In particular:
#!json null
value before a reference to it is returned.#!json null
value before a reference to it is returned. All indices between the current maximum and the given index are also filled with #!json null
.-
is treated as a synonym for the index past the end.Strong exception safety: if an exception occurs, the original value stays intact.
idx
is in the range of the array. Otherwise linear in idx - size()
.??? example
The example below shows how array elements can be read and written using `[]` operator. Note the addition of `#!json null` values. ```cpp --8<-- "examples/operatorarray__size_type.cpp" ``` Output: ```json --8<-- "examples/operatorarray__size_type.output" ```
??? example
The example below shows how array elements can be read using the `[]` operator. ```cpp --8<-- "examples/operatorarray__size_type_const.cpp" ``` Output: ```json --8<-- "examples/operatorarray__size_type_const.output" ```
??? example
The example below shows how object elements can be read and written using the `[]` operator. ```cpp --8<-- "examples/operatorarray__key_type.cpp" ``` Output: ```json --8<-- "examples/operatorarray__key_type.output" ```
??? example
The example below shows how object elements can be read using the `[]` operator. ```cpp --8<-- "examples/operatorarray__key_type_const.cpp" ``` Output: ```json --8<-- "examples/operatorarray__key_type_const.output" ```
??? example
The example below shows how values can be read and written using JSON Pointers. ```cpp --8<-- "examples/operatorjson_pointer.cpp" ``` Output: ```json --8<-- "examples/operatorjson_pointer.output" ```
??? example
The example below shows how values can be read using JSON Pointers. ```cpp --8<-- "examples/operatorjson_pointer_const.cpp" ``` Output: ```json --8<-- "examples/operatorjson_pointer_const.output" ```
T* key
added in version 1.1.0.