[#absl-FixedArray]
= xref:absl.adoc[absl]::FixedArray
:relfileprefix: ../
:mrdocs:

A run‐time fixed‐size array that allocates small arrays inline.

== Synopsis

Declared in `<absl/container/fixed_array.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<
    typename T,
    size_t N = kFixedArrayUseDefault,
    typename A = std::allocator<T>>
class FixedArray;
----

== Description

A `FixedArray` provides a run‐time fixed‐size array, allocating a small array inline for efficiency.

Most users should not specify the `N` template parameter and let `FixedArray` automatically determine the number of elements to store inline based on `sizeof(T)`. If `N` is specified, the `FixedArray` implementation will use inline storage for arrays with a length <= `N`.

Note that a `FixedArray` constructed with a `size_type` argument will default‐initialize its values by leaving trivially constructible types uninitialized (e.g. int, int[4], double), and others default‐constructed. This matches the behavior of c‐style arrays and `std::array`, but not `std::vector`.

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:absl/FixedArray/allocator_type.adoc[`allocator_type`] 
| The allocator type used to allocate and construct elements.
| xref:absl/FixedArray/const_iterator.adoc[`const_iterator`] 
| A random‐access iterator over const elements.
| xref:absl/FixedArray/const_pointer.adoc[`const_pointer`] 
| A pointer to a const element.
| xref:absl/FixedArray/const_reference.adoc[`const_reference`] 
| A reference to a const element.
| xref:absl/FixedArray/const_reverse_iterator.adoc[`const_reverse_iterator`] 
| A reverse iterator over const elements.
| xref:absl/FixedArray/difference_type.adoc[`difference_type`] 
| A signed integral type used for iterator differences.
| xref:absl/FixedArray/iterator.adoc[`iterator`] 
| A random‐access iterator over the elements.
| xref:absl/FixedArray/pointer.adoc[`pointer`] 
| A pointer to an element.
| xref:absl/FixedArray/reference.adoc[`reference`] 
| A reference to an element.
| xref:absl/FixedArray/reverse_iterator.adoc[`reverse_iterator`] 
| A reverse iterator over the elements.
| xref:absl/FixedArray/size_type.adoc[`size_type`] 
| An unsigned integral type used for sizes and indices.
| xref:absl/FixedArray/value_type.adoc[`value_type`] 
| The type of the elements stored in the fixed array.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:absl/FixedArray/2constructor-08b.adoc[`FixedArray`]         [.small]#[constructor]#
| Constructors
| xref:absl/FixedArray/2destructor.adoc[`~FixedArray`] [.small]#[destructor]#
| Destroys the fixed array and its elements.
| xref:absl/FixedArray/operator_assign-06.adoc[`operator=`] 
| Assignment operators
| xref:absl/FixedArray/at-08.adoc[`at`] 
| `at` overloads
| xref:absl/FixedArray/back-07.adoc[`back`] 
| `back` overloads
| xref:absl/FixedArray/begin-067.adoc[`begin`] 
| `begin` overloads
| xref:absl/FixedArray/cbegin.adoc[`cbegin`] 
| Returns a const iterator to the beginning of the fixed array.
| xref:absl/FixedArray/cend.adoc[`cend`] 
| Returns a const iterator to the end of the fixed array.
| xref:absl/FixedArray/crbegin.adoc[`crbegin`] 
| Returns a const reverse iterator from the end of the fixed array.
| xref:absl/FixedArray/crend.adoc[`crend`] 
| Returns a const reverse iterator from the beginning of the fixed array.
| xref:absl/FixedArray/data-0d.adoc[`data`] 
| `data` overloads
| xref:absl/FixedArray/empty.adoc[`empty`] 
| Returns whether or not the fixed array is empty.
| xref:absl/FixedArray/end-07.adoc[`end`] 
| `end` overloads
| xref:absl/FixedArray/fill.adoc[`fill`] 
| Assigns the given `value` to all elements in the fixed array.
| xref:absl/FixedArray/front-00.adoc[`front`] 
| `front` overloads
| xref:absl/FixedArray/max_size.adoc[`max_size`] 
| Returns the largest possible value of `std::distance(begin(), end())` for a `FixedArray<T>`. This is equivalent to the most possible addressable bytes over the number of bytes taken by T.
| xref:absl/FixedArray/memsize.adoc[`memsize`] 
| Returns the memory size of the fixed array in bytes.
| xref:absl/FixedArray/operator_subs-01.adoc[`operator[]`] 
| Subscript operators
| xref:absl/FixedArray/rbegin-07.adoc[`rbegin`] 
| `rbegin` overloads
| xref:absl/FixedArray/rend-0d.adoc[`rend`] 
| `rend` overloads
| xref:absl/FixedArray/size.adoc[`size`] 
| Returns the length of the fixed array.
|===


== Static Data Members

[cols="1,4"]
|===
| Name| Description
| xref:absl/FixedArray/inline_elements.adoc[`inline_elements`] 
| The number of elements stored inline before heap allocation is used.
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:absl/AbslHashValue-0c5.adoc[absl::AbslHashValue]`
| Combines the contents of the fixed array into a hash state.
| `xref:absl/operator_ge-0a9.adoc[absl::operator>=]`
| Returns whether `lhs` orders lexicographically after or equal to `rhs`.
| `xref:absl/operator_le-097.adoc[absl::operator<=]`
| Returns whether `lhs` orders lexicographically before or equal to `rhs`.
| `xref:absl/operator_gt-0ce.adoc[absl::operator>]`
| Returns whether `lhs` orders lexicographically after `rhs`.
| `xref:absl/operator_lt-0ef.adoc[absl::operator<]`
| Returns whether `lhs` orders lexicographically before `rhs`.
| `xref:absl/operator_not_eq-0ca.adoc[absl::operator!=]`
| Returns whether two fixed arrays are not elementwise equal.
| `xref:absl/operator_eq-0c2.adoc[absl::operator==]`
| Returns whether two fixed arrays are elementwise equal.
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#