array

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Библиотека контейнеров

Последовательные

array (C++11)

vector

vector<bool>

deque

forward_list (C++11)

list

Ассоциативные

set

multiset

map

multimap

Неупорядоченные ассоциативные

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Адаптеры

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Представления

span (C++20)

mdspan (C++23)

Недействительные итераторы

Таблица функций-элементов

Таблица функций, не являющихся элементами

 

std::array

Типы элементы

Функции-элементы

Доступ к элементам

array::at

array::operator[]

array::front

array::back

array::data

Итераторы

array::beginarray::cbegin

array::endarray::cend

array::rbeginarray::crbegin

array::rendarray::crend

Ёмкость

array::empty

array::size

array::max_size

Модификаторы

array::fill

array::swap

Функции, не являющиеся элементами

get

std::swap

to_array (C++20)

operator==operator!=operator<operator>operator<=operator>=operator<=> (до C++20)(до C++20)(до C++20)(до C++20)(до C++20)(C++20)

Вспомогательные классы

tuple_size

tuple_element

Принципы вывода (C++17)

 

Определено в заголовочном файле <array>
template<     class T,     std::size_t N > struct array;		(начиная с C++11)

std::array это контейнер, инкапсулирующий массив фиксированного размера.

Этот контейнер является агрегатным типом с той же семантикой, что и структура, содержащая массив в стиле C T[N] в качестве единственного нестатического элемента данных. В отличие от массива в стиле C, он не распадается на T* автоматически. Как агрегатный тип, он может быть инициализирован с помощью агрегатной инициализации с указанием не более чем N инициализаторов, которые можно преобразовать в T: std::array<int, 3> a = {1,2,3};.

Структура сочетает в себе производительность и доступность массива в стиле C с преимуществами стандартного контейнера, такими как знание его собственного размера, поддержка присваивания, итераторы произвольного доступа и т.д.

std::array удовлетворяет требованиям Container и ReversibleContainer за исключением того, что созданный по умолчанию массив не пустой и сложность обмена линейна, удовлетворяет требованиям ContiguousContainer, (начиная с C++17) и частично удовлетворяет требованиям SequenceContainer.

Особый случай массив нулевой длины (N == 0). В этом случае array.begin() == array.end(), которое является некоторым уникальным значением. Эффект от вызова front() или back() для массива нулевого размера не определён.

Массив также можно использовать как кортеж из N элементов одного типа.

Аннулирование итератора

Как правило, итераторы массива никогда не становятся недействительными в течение всего времени существования массива. Однако следует отметить, что во время обмена итератор будет продолжать указывать на тот же элемент массива и, таким образом, будет изменять его значение.

Типы элементы

Тип элемент	Определение
value_type	T
size_type	std::size_t
difference_type	std::ptrdiff_t
reference	value_type&
const_reference	const value_type&
pointer	value_type*
const_pointer	const value_type*
iterator	LegacyRandomAccessIterator и LegacyContiguousIterator в value_type (до C++17) LegacyRandomAccessIterator и LegacyContiguousIterator это LiteralType to value_type (начиная с C++17) (до C++20) LegacyRandomAccessIterator, contiguous_iterator и ConstexprIterator в value_type (начиная с C++20)
const_iterator	LegacyContiguousIterator в const value_type (до C++17) LegacyRandomAccessIterator и LegacyContiguousIterator это LiteralType to const value_type (начиная с C++17) (до C++20) LegacyRandomAccessIterator, contiguous_iterator и ConstexprIterator в const value_type (начиная с C++20)
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Функции-элементы

Неявно определённые функции-элементы
(конструктор) (объявлено неявно)	инициализирует массив в соответствии с правилами агрегатной инициализации (обратите внимание, что инициализация по умолчанию может привести к неопределённым значениям для неклассового T) (public функция-элемент)
(деструктор) (объявлено неявно)	уничтожает каждый элемент массива (public функция-элемент)
operator= (объявлено неявно)	перезаписывает каждый элемент массива соответствующим элементом другого массива (public функция-элемент)
Доступ к элементам
at (C++11)	предоставляет доступ к указанному элементу с проверкой границ (public функция-элемент)
operator[] (C++11)	предоставляет доступ к указанному элементу (public функция-элемент)
front (C++11)	предоставляет доступ к первому элементу (public функция-элемент)
back (C++11)	предоставляет доступ к последнему элементу (public функция-элемент)
data (C++11)	прямой доступ к базовому массиву (public функция-элемент)
Итераторы
begin cbegin (C++11)	возвращает итератор на начало (public функция-элемент)
end cend (C++11)	возвращает итератор на конец (public функция-элемент)
rbegin crbegin (C++11)	возвращает обратный итератор на начало (public функция-элемент)
rend crend (C++11)	возвращает обратный итератор на конец (public функция-элемент)
Ёмкость
empty (C++11)	проверяет, пуст ли контейнер (public функция-элемент)
size (C++11)	возвращает количество элементов (public функция-элемент)
max_size (C++11)	возвращает максимально возможное количество элементов (public функция-элемент)
Операции
fill (C++11)	заполняет контейнер указанным значением (public функция-элемент)
swap (C++11)	обменивает содержимое (public функция-элемент)

Функции, не являющиеся элементами

operator==operator!=operator<operator<=operator>operator>=operator<=> (удалено в C++20)(удалено в C++20)(удалено в C++20)(удалено в C++20)(удалено в C++20)(C++20)	лексикографически сравнивает значения в array (шаблон функции)
std::get(std::array) (C++11)	предоставляет доступ к элементу array (шаблон функции)
std::swap(std::array) (C++11)	специализация алгоритма std::swap (шаблон функции)
to_array (C++20)	создаёт объект std::array из встроенного массива (шаблон функции)

Вспомогательные классы

std::tuple_size<std::array> (C++11)	получает размер array (специализация шаблона класса)
std::tuple_element<std::array> (C++11)	получает тип элементов array (специализация шаблона класса)

Принципы вывода

(начиная с C++17)

Пример

Запустить этот код

#include <string>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <array>
 
int main()
{
    // Создание с использованием агрегатной инициализации
    std::array<int, 3> a1{ {1, 2, 3} }; // двойные фигурные скобки необходимы C++11 до
                                        // версии CWG 1270 (не требуются в C++11
                                        // после этой версии и в C++14 и последующих
                                        // версиях)
 
    std::array<int, 3> a2 = {1, 2, 3};  // двойные скобки никогда не требуются после =
 
    // Поддерживаются контейнерные операции
    std::sort(a1.begin(), a1.end());
    std::ranges::reverse_copy(a2, std::ostream_iterator<int>(std::cout, " "));
 
    std::cout << '\n';
 
    // Поддерживается диапазонный цикл for
    std::array<std::string, 2> a3 = { std::string("E"), "\u018E" };
    for(const auto& s: a3)
        std::cout << s << ' ';
 
    // Правила вывода для создания массива (начиная с C++17)
    [[maybe_unused]] std::array a4{3.0, 1.0, 4.0};  // -> std::array<double, 3>
 
    // Поведение неуказанных элементов такое же, как и у встроенных массивов
    // нет инициализации списком, a5[0] и a5[1] инициализируются по умолчанию
    [[maybe_unused]] std::array<int, 2> a5;
    // инициализация списком, оба элемента инициализируются значением, a6[0] = a6[1] = 0
    [[maybe_unused]] std::array<int, 2> a6{};
    // инициализация списком, неуказанный элемент инициализируется значением,
    // a7[0] = 1, a7[1] = 0
    [[maybe_unused]] std::array<int, 2> a7{1};
}

Вывод:

3 2 1 
E Ǝ

Смотрите также

make_array (ТС основ библиотеки v2)

создаёт объект std::array, размер и, возможно, тип элемента выводится из аргументов (шаблон функции)