Заголовок стандартной библиотеки <array> (C++11)

Этот заголовок входит в библиотеку контейнеров.

Подключаемые заголовки
<compare> (C++20)	поддержка оператора трёхстороннего сравнения
<initializer_list> (C++11)	шаблон класса std::initializer_list
Классы
array (C++11)	массив фиксированного размера с последовательным размещением элементов (шаблон класса)
tuple_size (C++11)	получает количество элементов типа, подобного кортежу (шаблон класса)
tuple_element (C++11)	получает типы элементов типа, подобного кортежу (шаблон класса)
std::tuple_size<std::array> (C++11)	получает размер array (специализация шаблона класса)
std::tuple_element<std::array> (C++11)	получает тип элементов array (специализация шаблона класса)
Функции
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(удалён в C++20)(C++11)(удалён в C++20)(C++11)(удалён в C++20)(C++11)(удалён в C++20)(C++11)(удалён в C++20)(C++20)	сравнивает лексикографически значения двух array (шаблон функции)
std::swap(std::array) (C++11)	специализирует алгоритм std::swap (шаблон функции)
to_array (C++20)	создаёт объект std::array из встроенного массива (шаблон функции)
get(std::array) (C++11)	получает доступ к элементу array (шаблон функции)
Доступ к диапазону
begincbegin (C++11)(C++14)	возвращает итератор на начало контейнера или массива (шаблон функции)
endcend (C++11)(C++14)	возвращает итератор на конец контейнера или массива (шаблон функции)
rbegincrbegin (C++14)	возвращает обратный итератор на начало контейнера или массива (шаблон функции)
rendcrend (C++14)	возвращает обратный итератор на конец контейнера или массива (шаблон функции)
sizessize (C++17)(C++20)	возвращает размер контейнера или массива (шаблон функции)
empty (C++17)	проверяет, пуст ли контейнер (шаблон функции)
data (C++17)	получает указатель на базовый массив (шаблон функции)

Обзор

// mostly freestanding
#include <compare>
#include <initializer_list>

namespace std {
  // class template array
  template<class T, size_t N> struct array; // partially freestanding

  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 /*synth-three-way-result*/<T> operator<=>(const array<T, N>& x,
                                                      const array<T, N>& y);

  // specialized algorithms
  template<class T, size_t N>
  constexpr void swap(array<T, N>& x, array<T, N>& y) noexcept(noexcept(x.swap(y)));

  // array creation functions
  template<class T, size_t N> constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);
  template<class T, size_t N> constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]);

  // tuple interface
  template<class T> struct tuple_size;
  template<size_t I, class T> struct 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;
}

Шаблон класса std::array

namespace std {
  template<class T, size_t N> struct array
  {
    // types
    using value_type = T;
    using pointer = T*;
    using const_pointer = const T*;
    using reference = T&;
    using const_reference = const T&;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
    using iterator = /* implementation-defined */;
    using const_iterator = /* implementation-defined */;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    // no explicit construct/copy/destroy for aggregate type

    constexpr void fill(const T& u);
    constexpr void swap(array&) 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 bool empty() const noexcept;
    constexpr size_type size() const noexcept;
    constexpr size_type max_size() const noexcept;

    // element access
    constexpr reference operator[](size_type n);
    constexpr const_reference operator[](size_type n) const;
    constexpr reference at(size_type n);             // freestanding-deleted
    constexpr const_reference at(size_type n) const; // freestanding-deleted
    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)>;
}