mirror of
https://github.com/ETLCPP/etl.git
synced 2026-10-29 02:17:09 +08:00
c8bc1bd896
* Corrected the documented make_xxx factory signatures and examples
The Make template sections across the container documentation had
drifted from the implementations, largely through copy-paste:
- map.md, multimap.md and flat-multimap.md all documented
make_flat_map; multiset.md documented make_set; flat-multiset.md
documented make_flat_set; unordered-multimap.md documented
make_unordered_map. Names and examples now match each container.
- Every signature omitted the C++11-required trailing return type
despite the sections being labelled C++11 and above; several also
used a parameter name (TValues) that did not match any template
parameter, and the unordered map headers were missing a comma.
- forward-list.md documented a make_array-style signature with an
explicit element type; the real function deduces the element type as
the common type of the arguments, as documented for make_list.
- The flat_set/flat_multiset template headers were missing the
variadic parameter pack, and their examples passed a braced list to
a variadic function, which does not compile; set.md used TKeyCompare
where the implementation uses TCompare.
- deque.md and the reference container docs were missing code fences.
- Updated the four reference_flat_* function. However these functions
cannot be instantiated at all (the reference containers have no
initializer_list constructor, since one would dangle by design), so
the documented examples have never compiled.
Every remaining documented example verified to compile with clang 22
(C++17) against the current headers.
* Fixed C++17-only syntax in factory examples and flagged the non-compilable ones
Review feedback on the make_xxx documentation examples:
- All the map-family factory examples are labelled C++11 and above but
constructed their pairs with class template argument deduction
(etl::pair{0, 1}), which requires C++17. The pairs in the make_flat_map,
make_flat_multimap, make_map, make_multimap, make_unordered_map,
make_unordered_multimap, make_reference_flat_map and
make_reference_flat_multimap examples now name their template arguments
explicitly. The template deduction guide examples are unchanged, as
those sections are labelled C++17 and above. Verified with clang 22 in
C++14 mode, which, like C++11, has no deduction guides.
- The four make_reference_flat_* examples are now preceded by a warning
callout stating that they do not currently compile: the functions
cannot be instantiated because the reference containers have no
initializer_list constructor. The examples themselves are retained,
rewritten to pass named lvalues rather than temporaries, since the
reference containers store references to external objects and the
temporaries would dangle even if the functions compiled. The defect
is being reported separately.
---------
Co-authored-by: John Wellbelove <jwellbelove@users.noreply.github.com>
356 lines
7.5 KiB
Markdown
356 lines
7.5 KiB
Markdown
---
|
|
title: "array"
|
|
weight: 1
|
|
---
|
|
|
|
{{< callout >}}
|
|
Header: `array.h`
|
|
Since: All versions
|
|
Similar to: [std::array](https://en.cppreference.com/w/cpp/container/array.html)
|
|
{{< /callout >}}
|
|
|
|
A fixed capacity array.
|
|
Adds additional members functions, `assign`, `insert` & `erase`.
|
|
|
|
```cpp
|
|
etl::array<typename T, const size_t SIZE>
|
|
```
|
|
|
|
See also:
|
|
[array_view]({{< relref "array-view" >}})
|
|
[multi_array]({{< relref "multi-array" >}})
|
|
|
|
## Template deduction guides
|
|
**C++17 and above**
|
|
|
|
```cpp
|
|
template <typename... T>
|
|
etl::array(T...)
|
|
```
|
|
|
|
### Example
|
|
```cpp
|
|
etl::array data{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
|
```
|
|
Defines data as an array of 'int', of length '10', containing the supplied data.
|
|
|
|
## Make template
|
|
**C++11 and above**
|
|
|
|
```cpp
|
|
template <typename T, typename... TValues>
|
|
constexpr auto make_array(TValues&&... values) -> etl::array<T, sizeof...(TValues)>
|
|
```
|
|
|
|
### Example
|
|
```cpp
|
|
auto data = etl::make_array<int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
|
```
|
|
|
|
## Member types
|
|
|
|
`value_type`
|
|
`size_type`
|
|
`difference_type`
|
|
`reference`
|
|
`const_reference`
|
|
`pointer`
|
|
`const_pointer`
|
|
`iterator`
|
|
`const_iterator`
|
|
`reverse_iterator`
|
|
`const_reverse_iterator`
|
|
|
|
`etl::array` iterators are random access.
|
|
|
|
## Static Constants
|
|
|
|
```cpp
|
|
SIZE
|
|
```
|
|
**Description**
|
|
The size of the array.
|
|
|
|
## Constructor
|
|
|
|
```cpp
|
|
etl::array<int, 10> data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
|
|
```
|
|
**Description**
|
|
Default or copy constructs each element.
|
|
Can be initialised like a C array.
|
|
|
|
## Element access
|
|
```cpp
|
|
T& at(size_t i)
|
|
const T& at(size_t i) const
|
|
```
|
|
**Description**
|
|
Returns a reference or const reference to the indexed element. Emits an etl::array_out_of_range if the index is not in range.
|
|
If asserts or exceptions are not enabled then an out of range index results in undefined behaviour.
|
|
|
|
---
|
|
|
|
```cpp
|
|
T& operator[](size_t i)
|
|
const T& operator[](size_t i) const
|
|
```
|
|
**Description**
|
|
Returns a reference or const reference to the indexed element.
|
|
An out of range index results in undefined behaviour.
|
|
|
|
---
|
|
|
|
```cpp
|
|
T& front()
|
|
const T& front() const
|
|
```
|
|
**Description**
|
|
Returns a reference or const reference to the first element.
|
|
|
|
---
|
|
|
|
```cpp
|
|
T& back()
|
|
const T& back() const
|
|
```
|
|
**Description**
|
|
Returns a reference or const reference to the last element.
|
|
|
|
## Iterators
|
|
|
|
```cpp
|
|
iterator begin()
|
|
const_iterator begin() const
|
|
const_iterator cbegin() const
|
|
```
|
|
**Description**
|
|
Returns an iterator to the beginning of the array.
|
|
|
|
---
|
|
|
|
```cpp
|
|
iterator end()
|
|
const_iterator end() const
|
|
const_iterator cend() const
|
|
```
|
|
**Description**
|
|
Returns an iterator to the end of the array.
|
|
|
|
---
|
|
|
|
```cpp
|
|
iterator rbegin()
|
|
const_iterator rbegin() const
|
|
const_iterator crbegin() const
|
|
```
|
|
**Description**
|
|
Returns a reverse iterator to the beginning of the array.
|
|
|
|
---
|
|
|
|
```cpp
|
|
iterator rend()
|
|
const_iterator rend() const
|
|
const_iterator crend() const
|
|
```
|
|
**Description**
|
|
Returns a reverse iterator to the end of the array.
|
|
|
|
## Capacity
|
|
|
|
```cpp
|
|
bool empty() const
|
|
```
|
|
**Description**
|
|
Returns true if the size of the array is zero, otherwise false.
|
|
|
|
---
|
|
|
|
```cpp
|
|
size_t size() const
|
|
```
|
|
**Description**
|
|
Returns the size of the array.
|
|
|
|
---
|
|
|
|
```cpp
|
|
size_t max_size() const
|
|
```
|
|
**Description**
|
|
Returns the maximum possible size of the array.
|
|
|
|
## Modifiers
|
|
|
|
```cpp
|
|
void fill(T value)
|
|
```
|
|
**Description**
|
|
Fills the array with value.
|
|
|
|
## ETL Extensions
|
|
|
|
```cpp
|
|
template <typename TIterator>
|
|
void assign(TIterator first, const TIterator last)
|
|
```
|
|
|
|
```cpp
|
|
template <typename TIterator>
|
|
void assign(TIterator first, const TIterator last, parameter_t value)
|
|
```
|
|
|
|
**Description**
|
|
Assigns a range of values to the array. The second form set uninitialised elements to value.
|
|
If the range is larger than the array then the extra data is ignored.
|
|
If the range is smaller than the array then the unused array elements are left unmodified.
|
|
|
|
---
|
|
|
|
```cpp
|
|
iterator insert_at(size_t position, parameter_t value)
|
|
iterator insert(const_iterator position, parameter_t value)
|
|
```
|
|
|
|
**Description**
|
|
Inserts a value into the array at the specified position, shifting elements to make room.
|
|
Elements may be truncated if they are shifted off the end of the array.
|
|
|
|
---
|
|
|
|
```cpp
|
|
template <typename TIterator>
|
|
iterator insert_at(size_t position, TIterator first, const TIterator last)
|
|
```
|
|
|
|
**Description**
|
|
`position` is not checked for validity.
|
|
|
|
---
|
|
|
|
```cpp
|
|
template <typename TIterator>
|
|
iterator insert(const_iterator position, TIterator first, const TIterator last)
|
|
```
|
|
|
|
**Description**
|
|
Inserts a range of values into the array at the specified position, shifting elements to make room.
|
|
Elements may be truncated if they are shifted off the end of the array.
|
|
The range may be larger than the capacity of the array. Excess elements will be ignored.
|
|
|
|
---
|
|
|
|
```cpp
|
|
iterator erase_at(size_t position)
|
|
iterator erase_at(size_t position, parameter_t value)
|
|
iterator erase(const_iterator position)
|
|
iterator erase(const_iterator position, parameter_t value)
|
|
```
|
|
|
|
**Description**
|
|
Erases an element at the specified position, shifting elements into the space.
|
|
The value parameter variants initialise the unused elements with value, while the others leave them unchanged.
|
|
position is not checked for valid range.
|
|
|
|
---
|
|
|
|
```cpp
|
|
iterator erase_range(size_t first, size_t last)
|
|
iterator erase_range(size_t first, size_t last, parameter_t value)
|
|
iterator erase(const_iterator first, const_iterator last)
|
|
iterator erase(const_iterator first, const_iterator last, parameter_t value)
|
|
```
|
|
|
|
**Description**
|
|
Erases a range, shifting elements into the space.
|
|
The value parameter variants initialise the unused elements with value, while the others leave them unchanged.
|
|
first/last are not checked for valid range.
|
|
|
|
## Non-member functions
|
|
**Lexicographically comparisons**
|
|
```cpp
|
|
operator ==
|
|
```
|
|
**Description**
|
|
`true` if the contents of the lists are equal, otherwise `false`.
|
|
|
|
---
|
|
|
|
```cpp
|
|
operator !=
|
|
```
|
|
**Description**
|
|
`true` if the contents of the lists are not equal, otherwise `false`.
|
|
|
|
---
|
|
|
|
```cpp
|
|
operator <
|
|
```
|
|
**Description**
|
|
`true` if the contents of the lhs are lexicographically less than the contents of the rhs, otherwise `false`.
|
|
|
|
---
|
|
|
|
```cpp
|
|
operator <=
|
|
```
|
|
**Description**
|
|
`true` if the contents of the lhs are lexicographically less than or equal to the contents of the rhs, otherwise `false`.
|
|
|
|
---
|
|
|
|
```cpp
|
|
operator >
|
|
```
|
|
**Description**
|
|
`true` if the contents of the lhs are lexicographically greater than the contents of the rhs, otherwise `false`.
|
|
|
|
---
|
|
|
|
```cpp
|
|
operator >=
|
|
```
|
|
**Description**
|
|
`true` if the contents of the lhs are lexicographically greater than or equal to the contents of the rhs, otherwise `false`.
|
|
|
|
---
|
|
|
|
```cpp
|
|
template <size_t Index, typename T, size_t Size>
|
|
T& get(etl::array<T, Size>& a)
|
|
|
|
template <size_t Index, typename T, size_t Size>
|
|
const T& get(const etl::array<T, Size>& a)
|
|
```
|
|
**Description**
|
|
Gets a reference to the element at `Index` in the array.
|
|
|
|
## Structured bindings
|
|
`etl::array` provides the tuple-like interface required for C++17 structured bindings.
|
|
|
|
```cpp
|
|
etl::array<int, 3> a = { 1, 2, 3 };
|
|
|
|
auto& [x, y, z] = a; // x, y, z are references to a[0], a[1], a[2]
|
|
```
|
|
|
|
```cpp
|
|
template <typename T, size_t Size>
|
|
struct tuple_size<etl::array<T, Size>>
|
|
```
|
|
**Description**
|
|
Gets the number of elements in the array.
|
|
Specialised in namespaces `etl` and `std` (the `std` specialisation allows the use of C++ structured bindings).
|
|
|
|
---
|
|
|
|
```cpp
|
|
template <size_t Index, typename T, size_t Size>
|
|
struct tuple_element<Index, etl::array<T, Size>>
|
|
```
|
|
**Description**
|
|
Gets the type of the element at `Index` in the array.
|
|
Specialised in namespaces `etl` and `std` (the `std` specialisation allows the use of C++ structured bindings).
|