This website uses cookies. By continuing, you give permission to deploy cookies, as detailed in our privacy policy.

ok

Search: Go
Not logged in

Reference <array> array register log in

C++
1 Famous American Singer - Bought This With $5 Millions
Information A famous american singer-songwriter bought this new toy to her husband as birthday present armadathoughtpark.com
Tutorials
Reference 2 GUI Virtualization SDK
Articles Instantly take your legacy windows applications to the web using our Web enabling SDK Cybelesoft.com
Forum
class template
Reference <array>
C library:
std::array
Containers: template < class T, size_t N > class array;
<array> Array class
<deque> Arrays are fixed-size sequence containers: they hold a specific number of elements ordered in a strict linear sequence.
<forward_list>
<list> 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
<map> compile time). It is as efficient in terms of storage size as an ordinary array declared with the language's bracket syntax ([]). This class
<queue> merely adds a layer of member and global functions to it, so that arrays can be used as standard containers.
<set>
Unlike the other standard containers, arrays have a fixed size and do not manage the allocation of its elements through an allocator: they are
<stack>
an aggregate type encapsulating a fixed-size array of elements. Therefore, they cannot be expanded or contracted dynamically (see vector
<unordered_map> for a similar container that can be expanded).
<unordered_set>
<vector> Zero-sized arrays are valid, but they should not be dereferenced (members front, back, and data).
Input/Output:
Multi-threading: Unlike with the other containers in the Standard Library, swapping two array containers is a linear operation that involves swapping all the
Other: 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.
<array>
Another unique feature of array containers is that they can be treated as tuple objects: The <array> header overloads the get function to
array
access the elements of the array as if it was a tuple, as well as specialized tuple_size and tuple_element types.
array
array::array Container properties
member functions:
array::at Sequence
array::back Elements in sequence containers are ordered in a strict linear sequence. Individual elements are accessed by their position in this
array::begin sequence.
array::cbegin Contiguous storage
array::cend The elements are stored in contiguous memory locations, allowing constant time random access to elements. Pointers to an element
array::crbegin can be offset to access other elements.
array::crend Fixed-size aggregate
array::data The container uses implicit constructors and destructors to allocate the required space statically. Its size is compile-time constant. No
array::empty memory or time overhead.
array::end
array::fill
array::front Template parameters
array::max_size
array::operator[] T
array::rbegin Type of the elements contained.
Aliased as member type array::value_type.
array::rend
array::size N
array::swap Size of the array, in terms of number of elements.
non-member overloads:
In the reference for the array member functions, these same names are assumed for the template parameters.
get (array)
relational operators (array)
non-member specializations: Member types
tuple_element<array>
The following aliases are member types of array. They are widely used as parameter and return types by member functions:
tuple_size<array>
member type definition notes
value_type 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 convertible to const_iterator
const_iterator a random access iterator to const value_type
reverse_iterator reverse_iterator<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

© cplusplus.com, 2000-2019 - All rights reserved - v3.1
Spotted an error? contact us