W3cubDocs

/C++

Standard library header <array>

This header is part of the containers library.

Includes

<initializer_list>(C++11)

Classes

(C++11)
static contiguous array
(class template)
obtains the size of an array
(class template specialization)
obtains the type of the elements of array
(class template specialization)

Functions

lexicographically compares the values in the array
(function template)
accesses an element of an array
(function template)
(C++11)
specializes the std::swap algorithm
(function template)

Synopsis

#include <initializer_list>
 
namespace std {
 
    template <class T, size_t N> struct array;
 
    template <class T, size_t N>
        constexpr bool operator==(const array<T,N>& x, const array<T,N>& y);
    template <class T, size_t N>
        constexpr bool operator!=(const array<T,N>& x, const array<T,N>& y);
    template <class T, size_t N>
        constexpr bool operator<(const array<T,N>& x, const array<T,N>& y);
    template <class T, size_t N>
        constexpr bool operator>(const array<T,N>& x, const array<T,N>& y);
    template <class T, size_t N>
        constexpr bool operator<=(const array<T,N>& x, const array<T,N>& y);
    template <class T, size_t N>
        constexpr bool operator>=(const array<T,N>& x, const array<T,N>& y);
 
    template <class T, size_t N>
        constexpr void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y)));
 
    template <class T> class tuple_size;
    template <size_t I, class T> class tuple_element;
    template <class T, size_t N> struct tuple_size<array<T, N> >;
    template <size_t I, class T, size_t N> struct tuple_element<I, array<T, N> >;
    template <size_t I, class T, size_t N>
    constexpr T& get(array<T, N>&) noexcept;
    template <size_t I, class T, size_t N>
    constexpr T&& get(array<T, N>&&) noexcept;
    template <size_t I, class T, size_t N>
    constexpr const T& get(const array<T, N>&) noexcept;
    template <size_t I, class T, size_t N>
    constexpr const T&& get(const array<T, N>&&) noexcept;
}

Class std::array

template <class T, size_t N >
struct array {
    // types:
    typedef T&                               reference;
    typedef const T&                         const_reference;
    typedef /*implementation-defined*/       iterator;
    typedef /*implementation-defined*/       const_iterator;
    typedef size_t                           size_type;
    typedef ptrdiff_t                        difference_type;
    typedef T                                value_type;
    typedef T*                               pointer;
    typedef const T*                         const_pointer;
    typedef reverse_iterator<iterator>       reverse_iterator;
    typedef reverse_iterator<const_iterator> const_reverse_iterator;
 
    T elems[N]; // exposition only
 
    // no explicit construct/copy/destroy for aggregate type
 
    constexpr void fill(const T& u);
    constexpr void swap(array<T, N>&) noexcept(is_nothrow_swappable_v<T>);
 
    // iterators:
    constexpr iterator                begin() noexcept;
    constexpr const_iterator          begin() const noexcept;
    constexpr iterator                end() noexcept;
    constexpr const_iterator          end() const noexcept;
 
    constexpr reverse_iterator        rbegin() noexcept;
    constexpr const_reverse_iterator  rbegin() const noexcept;
    constexpr reverse_iterator        rend() noexcept;
    constexpr const_reverse_iterator  rend() const noexcept;
 
    constexpr const_iterator          cbegin() const noexcept;
    constexpr const_iterator          cend() const noexcept;
    constexpr const_reverse_iterator  crbegin() const noexcept;
    constexpr const_reverse_iterator  crend() const noexcept;
 
    // capacity:
    constexpr size_type size() const noexcept;
    constexpr size_type max_size() const noexcept;
    constexpr bool      empty() const noexcept;
 
    // element access:
    constexpr reference       operator[](size_type n);
    constexpr const_reference operator[](size_type n) const;
    constexpr const_reference at(size_type n) const;
    constexpr reference       at(size_type n);
    constexpr reference       front();
    constexpr const_reference front() const;
    constexpr reference       back();
    constexpr const_reference back() const;
 
    constexpr T *       data() noexcept;
    constexpr const T * data() const noexcept;
};
 
template<class T, class... U>
  array(T, U...) -> array<T, 1 + sizeof...(U)>;
Note

The name array::elems is only for exposition, it's not part of the interface.

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/header/array