std::array C++. Статический массив из контейнеров STL.

- std::array или массив это контейнер размер которого должен быть известен на момент компиляции. Подключается через #include <array>;

- Размер array не может меняться.

- Элементы array, располагаются непрерывно подряд (как в массиве), но хранятся в стеке а не в куче. Поэтому доступ к элементам массива осуществляется быстрее чем к элементам вектора.

- Доступ к элементам array может осуществляться как по индексу, так и через итераторы.

- Если нужен массив размер которого может изменяться - используйте std::vector

МетодОписаниеПримерСложность
[] Доступ к элементу по индексу. cout << ar[2]; O(1)
array(int size) Конструктор. Создает массив с заданным количеством элементов array< int, 4> ar;
array<int, 4> ar1{0, 1, 2, 3};
array<int, 4> ar2 = {0, 1, 2, 3};
O(n)
at(size_t index) Доступ к элементу по индексу. Выбрасывает исключение при выходе за границы. cout << ar.at(20); O(1)
back() Доступ к последнему элементу. cout << ar.back(); O(1)
begin() Возвращает итератор на первый элемент. auto i = ar.begin(); O(1)
data() Возвращает указатель на массив данных (не контейнер) auto *i = ar.data(); O(1)
empty() Возвращает пустой ли массив. if(!ar.empty); O(1)
end() Возвращает итератор на место после последнего элемента. auto i = ar.end(); O(1)
fill(const T& value) Заполняет массив значениями value ar.fill(3); O(n)
front() Доступ к первому элементу. cout << ar.front(); O(1)
max_size() Возвращает максимально возможный (текущий) размер массива. size_t msize = ar.max_size(); O(1)
rbegin() Возвращает реверсивный итератор на конец массива. auto i = ar.rbegin(); O(1)
rend() Возвращает реверсивный итератор на начало массива. auto i = ar.rend(); O(1)
size() Возвращает размер массива. size_t size = ar.size(); O(1)
swap(array& ar) Обменивает содержимое массивов ar.swap(ar1); O(n)

#include <iostream> // cout
#include <array>    // array
int main(){
    std::array<int, 3> ar{1, 2, 3}; // Создали массив на 3 элемента
    std::array<int, 3> ar1{10, 20, 30}; // Создали массив на 3 элемента
    std::array ar2{5, 4, 3}; //C++17 Создали массив на 3 элемента int
    std::array ar3{1.1, 4.0, 3.14}; //C++17 Создали массив на 3 элемента double
    std::cout << ar.front() << "\n"; //1
    std::cout << ar.back() << "\n";  //3
    for(auto i = ar.rbegin(); i != ar.rend(); i++){ // Перебираем массив в обратном порядке через итераторы
        std::cout << *i << " "; //3 2 1
    }
    std::cout << "\n";
    ar.swap(ar1);   // Меняем местами ar и ar1
    for(size_t i = 0; i != ar.size(); i++){
        std::cout << ar[i] << " ";  //10 20 30  Видим что в ar значения ar1
    }
    std::cout << "\n" << ar.max_size(); //3 Максимальный размер массива равен текущему
}

Двумерный массив std::array


#include <iostream> // cout
#include <array>    // array
int main(){
    std::array<std::array<int, 2>, 3> ar = {{{1, 2}, {3, 4}, {5, 6}}};    // Двухмерный массив размером 2 на 3
    for(size_t x = 0; x < ar.size(); x++){                // Перебор строк
        for(uint64_t y = 0; y < ar[x].size(); y++){         // Перебор столбцов
            //ar[x][y] = x * y;                               // Присваиваем значения элементам массива
            std::cout << "ar[" << x << "][" << y << "] = " << ar[x][y] << "\t";     // Выводим значения элементов массива
        }
    std::cout << '\n';
    }
}
/* Вывод программы
ar[0][0] = 1    ar[0][1] = 2
ar[1][0] = 3    ar[1][1] = 4
ar[2][0] = 5    ar[2][1] = 6
*/

Сортировка массива

Для сортировки массива используется функция sort из заголовочного файла algorithm.


#include <iostream>  // cout
#include <array>     // array
#include <algorithm> // sort()
int main() {
    std::array<int, 8> data = {3, 1, 4, 1, 5, 9, 2, 6};
    std::sort(data.begin(), data.end()); // Сортировка массива по возростанию
    for(int n : data){
        std::cout << n << ' '; //1 1 2 3 4 5 6 9
    }
    std::cout << "\n";

    std::sort(data.rbegin(), data.rend()); // Сортировка массива по убыванию
    //std::sort(data.begin(), data.end(), greater<int>()); // Аналогично Сортировка массива по убыванию
    for(int n : data){
        std::cout << n << ' '; //9 6 5 4 3 2 1 1
    }
    std::cout << "\n";
}

Для сортировки контейнеров с типами данных для которых не определен оператор < потребуется реализовать этот функционал.


#include <iostream>  // cout
#include <array>    // array
#include <algorithm> // sort()

struct Point{   // Структура точки
    int x;  // Координата x
    int y;  // Координата y
    int r;  // Радиус
};

int main() {
    std::array<Point, 4> points{{{2, 0, 2}, {2, 3, 4}, {0, 1, 1}, {3, 4, 5}}} ; // Завели массив структур. Может понадобиться лишняя пара скобок

    std::sort(points.begin(), points.end(), [](const Point &x, const Point &y){ // Сортируем массив с лямбдой
        return x.r < y.r;   // Определяем критерий сортировки
    });

    for(size_t i = 0; i < points.size(); i++){ // Выводим массив
        std::cout << points[i].x << " " << points[i].y << " " << points[i].r << "\n";
    }
}

/* Вывод программы
0 1 1
2 0 2
2 3 4
3 4 5
*/
2023-12-18



Понравилась страница?
Добавить в закладки
Или поделиться!

Связанные темы

array - статический массив (после создания размер не изменяется). Быстрее вектора.
Выбор контейнера из стандартной библиотеки С++.
deque - двусторонняя очередь (дек). Эффективное вставка-удаление по концам очереди.
forward_list - односвязный список с эффективной вставкой/удалением в начало списка.
list - двусвязный список с эффективной вставкой/удалением в любом месте списка.
map - словарь сортированных уникальных пар ключ-значение.
multimap - словарь сортированных неуникальных пар ключ-значение.
multiset - множество сортированных неуникальных элементов.
priority_queue - очередь с приоритетом (с сортировкой значений).
queue - очередь FIFO first in, first out "первый пришел - первый ушел".
set - множество сортированных уникальных элементов.
stack - стек LIFO last in, first out "последний пришел - первый ушел".
unordered_map - словарь несортированных уникальных пар ключ-значение.
unordered_multimap - словарь несортированных неуникальных пар ключ-значение.
unordered_multiset - множество несортированных неуникальных значений.
unordered_set - множество несортированных уникальных значений.
vector - вектор (массив) значений с изменяемым размером.