Search:
Reference
Go
<array>
Not logged in
array
register
log in
C++
Information
Tutorials
Reference
Articles
Forum
Reference
class template
array
C library:
Containers:
std::
<array>
<deque>
<forward_list>
<list>
<map>
<queue>
<set>
<stack>
<unordered_map>
<unordered_set>
<vector>
Array class
<array>
template < class T, size_t N > class array;
Input/Output:
Multi-threading:
Other:
<array>
array
array
array::array
member functions:
array::at
array::back
array::begin
array::cbegin
array::cend
array::crbegin
array::crend
array::data
array::empty
array::end
array::fill
array::front
array::max_size
array::operator[]
array::rbegin
array::rend
array::size
array::swap
Arrays are fixed-size sequence containers: they hold a specific number of elements ordered in a strict linear sequence.
Internally, an array does not keep any data other than the elements it contains (not even its size, which is a template
parameter, fixed on compile time). It is as efficient in terms of storage size as an ordinary array declared with the
language's bracket syntax ([]). This class merely adds a layer of member and global functions to it, so that arrays can
be used as standard containers.
Unlike the other standard containers, arrays have a fixed size and do not manage the allocation of its elements through
an allocator: they are an aggregate type encapsulating a fixed-size array of elements. Therefore, they cannot be
expanded or contracted dynamically (see vector for a similar container that can be expanded).
Zero-sized arrays are valid, but they should not be dereferenced (members front, back, and data).
Unlike with the other containers in the Standard Library, swapping two array containers is a linear operation that
involves swapping all the elements in the ranges individually, which generally is a considerably less efficient operation.
On the other side, this allows the iterators to elements in both containers to keep their original container association.
Another unique feature of array containers is that they can be treated as tuple objects: The <array> header overloads
the get function to access the elements of the array as if it was a tuple, as well as specialized tuple_size and
tuple_element types.
Container properties
Sequence
Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by
their position in this sequence.
Contiguous storage
The elements are stored in contiguous memory locations, allowing constant time random access to elements.
Pointers to an element can be offset to access other elements.
Fixed-size aggregate
The container uses implicit constructors and destructors to allocate the required space statically. Its size is
compile-time constant. No memory or time overhead.
Template parameters
T
Type of the elements contained.
Aliased as member type array::value_type.
non-member overloads:
get (array)
relational operators (array)
non-member specializations:
tuple_element<array>
tuple_size<array>
Size of the array, in terms of number of elements.
In the reference for the array member functions, these same names are assumed for the template parameters.
Member types
The following aliases are member types of array. They are widely used as parameter and return types by member
functions:
member type
value_type
definition
The first template parameter (T)
reference
value_type&
const_reference
const value_type&
pointer
value_type*
const_pointer
const value_type*
iterator
a random access iterator to value_type
const_iterator
a random access iterator to const value_type
reverse_iterator
reverse_iterator<iterator>
notes
convertible to const_iterator
const_reverse_iterator reverse_iterator<const_iterator>
size_type
size_t
unsigned integral type
difference_type
ptrdiff_t
signed integral type
Member functions
Iterators
begin
Return iterator to beginning (public member function )
end
Return iterator to end (public member function )
rbegin
Return reverse iterator to reverse beginning (public member function )
rend
Return reverse iterator to reverse end (public member function )
cbegin
Return const_iterator to beginning (public member function )
cend
Return const_iterator to end (public member function )
crbegin
Return const_reverse_iterator to reverse beginning (public member function )
crend
Return const_reverse_iterator to reverse end (public member function )
Capacity
size
Return size (public member function )
max_size
Return maximum size (public member function )
empty
Test whether array is empty (public member function )
Element access
operator[]
Access element (public member function )
at
Access element (public member function )
front
Access first element (public member function )
back
Access last element (public member function )
data
Get pointer to data (public member function )
Modifiers
fill
Fill array with value (public member function )
swap
Swap content (public member function )
Non-member function overloads
get (array)
Get element (tuple interface) (function template )
relational operators (array) Relational operators for array (function template )
Non-member class specializations
tuple_element<array> Tuple element type for array (class template specialization )
tuple_size<array>
Tuple size traits for array (class template specialization )
Home page | Privacy policy
[Link], 2000-2016 - All rights reserved - v3.1
Spotted an error? contact us