std::array<T, N>: size() и begin()/end()

1. Знакомство с std::array

Если вы только что освоили обычные массивы int a[5], логичный вопрос: «Почему стандартная библиотека решила сделать ещё один массив?». Ответ очень практичный: C‑массив — историческая конструкция, у которой много удобства и столько же сюрпризов. std::array оставляет удобство (фиксированный размер и скорость), но убирает часть сюрпризов: у него есть методы, размер не теряется «по дороге», и он дружит с общими библиотечными приёмами.

std::array<T, N> — это контейнер стандартной библиотеки: то есть тип «из коробки», который живёт в заголовке <array> и ведёт себя как «настоящий объект» со встроенными возможностями. Он стандартизирован и развивается вместе со стандартом C++, включая связанные утилиты вокруг массива.

Самое важное: std::array хранит ровно N элементов типа T, как и C‑массив. Но делает это «в стиле современного C++»: размер можно спросить, начало и конец можно получить одинаковым способом, тип становится строже.

2. Объявление: N — часть типа

Когда вы впервые видите std::array<int, 5>, может показаться, что это «какой-то сложный шаблон». Да, это шаблон, но идея простая: T — тип элемента, N — количество элементов. И это количество — не переменная, а часть типа. То есть std::array<int, 5> и std::array<int, 6> — разные типы.

Начнём с объявления и чтения элементов. Пусть наше мини‑приложение в уровне 11 будет «термометр на неделю»: мы храним 7 температур и считаем простую статистику.

#include <array>
#include <cstddef>
#include <iostream>

int main() {
    std::array<int, 7> temps{10, 11, 9, 8, 12, 13, 7};
    std::cout << temps[0] << ' ' << temps[6] << '\n'; // 10 7
}

Здесь temps — объект. Не «кусок памяти без паспорта», а именно объект, у которого есть методы и понятное поведение.

Отдельно приятно то, что N фиксируется прямо в типе: если вы попытаетесь присвоить массив другого размера, компилятор вас остановит раньше, чем программа начнёт «интересно жить».

3. Инициализация: полная, частичная и {}

С инициализацией у новичков обычно два режима. Первый — «я всё заполнил явно, я молодец». Второй — «ой, а почему там мусор?». std::array помогает держаться первого режима, потому что списковая инициализация работает очень предсказуемо.

Полная инициализация выглядит привычно:

#include <array>
#include <iostream>

int main() {
    std::array<int, 3> a{1, 2, 3};
    std::cout << a[1] << '\n'; // 2
}

Частичная инициализация тоже работает: «хвост» заполнится нулями (для чисел — 0, для double — 0.0).

#include <array>
#include <iostream>

int main() {
    std::array<int, 5> a{10, 20}; // остальные станут 0
    std::cout << a[2] << ' ' << a[4] << '\n'; // 0 0
}

Нулевая инициализация — это когда вы хотите гарантированно стартовать «с чистого листа», без сюрпризов:

#include <array>
#include <iostream>

int main() {
    std::array<int, 4> a{}; // все 0
    std::cout << a[0] << ' ' << a[3] << '\n'; // 0 0
}

Для нашего «термометра на неделю» это удобно: мы можем объявить массив и затем заполнить вводом пользователя, но при этом даже до ввода значения будут предсказуемыми (а не «какие байты были в памяти»).

4. size(): меньше магических чисел

Когда вы работаете с фиксированным массивом, самая частая ошибка — «где-то я написал 7, где-то 6, а где-то вообще забыл обновить». std::array предлагает более здоровую привычку: спрашивать размер у объекта.

size() возвращает количество элементов (тип обычно std::size_t).

Давайте перепишем часть нашего мини‑приложения: введём температуры и выведем их обратно, но границу цикла возьмём из size().

#include <array>
#include <cstddef>
#include <iostream>

int main() {
    std::array<int, 7> temps{};

    for (std::size_t i = 0; i < temps.size(); ++i) {
        std::cin >> temps[i];
    }

    std::cout << "Read " << temps.size() << " values\n"; // например: Read 7 values
}

Смысл здесь даже не в том, что «так короче». Смысл в том, что теперь размер живёт в одном месте — в типе std::array<int, 7>, а код обхода не обязан помнить, что это именно 7. Он просто спрашивает у массива: «сколько вас там?».

Таблица: C‑массив vs std::array

Эта таблица не делает C‑массив «плохим». Он просто более старый и менее строгий. А мы сейчас учимся писать так, чтобы строгие правила помогали, а не мешали.

5. begin() и end(): границы диапазона

С size() мы уже чувствуем, что std::array — не просто «память», а объект. Следующий шаг — понять, что у контейнера можно запросить «границы». Для этого и существуют begin() и end().

Важно ухватить идею правильно: begin() — это «точка входа» в последовательность, то есть доступ к первому элементу. end() — это «точка сразу после последнего элемента». Не последний элемент, а именно позиция «после». Это звучит странно, но это невероятно удобная договорённость: диапазон элементов — это всегда [begin, end) (включая начало и не включая конец).

Визуально можно думать так:

flowchart LR
    B["begin()"] --> E0[0] --> E1[1] --> E2[2] --> D[...]
    D --> EN[последний] --> X["end()"]

Почему end() — «после последнего»? Потому что тогда пустой массив тоже описывается корректно: если элементов нет, begin() == end(). И это очень удобная общая логика.

Для std::array begin()/end() возвращают «итераторы» — на этом этапе мы воспринимаем их максимально просто: как «курсор/указатель‑подобную штуку», которая умеет двигаться по элементам и позволяет получить текущий элемент.

Посмотрим на минимальный пример:

#include <array>
#include <iostream>

int main() {
    std::array<int, 3> a{5, 6, 7};

    auto it = a.begin();          // "указатель" на первый элемент
    std::cout << *it << '\n';     // 5
}

Здесь появляется *it. Да, это оператор «взять элемент по итератору». Мы не уходим в большую тему указателей и памяти, но держим простую модель: it указывает на элемент, *it — сам элемент.

6. Обход по итераторам без индексов

Индексные циклы прекрасны, особенно когда вы только учитесь: i понятно, граница понятно, a[i] — тоже понятно. Но иногда хочется обход «не через числа», а через границы контейнера. begin()/end() как раз дают универсальный способ пройти от начала до конца, не зная размер «вручную».

Вот как выглядит печать элементов через итераторы:

#include <array>
#include <iostream>

int main() {
    std::array<int, 4> a{10, 20, 30, 40};

    for (auto it = a.begin(); it != a.end(); ++it) {
        std::cout << *it << ' ';
    }
    std::cout << '\n'; // 10 20 30 40
}

Разберём цикл человеческими словами. Мы берём it на начало массива. Пока it не дошёл до «позиции после последнего» (a.end()), мы печатаем текущий элемент *it и двигаем итератор вперёд ++it.

Плюс такого обхода в том, что это единая привычка для контейнеров и диапазонов. Минус для новичка в том, что тут чуть больше «новых значков» (*it, ++it). Поэтому держим баланс: индексы — для простоты, begin/end — чтобы понимать «границы контейнера» как отдельную идею.

7. Пример: статистика температур

Сейчас мы соберём маленький кусочек логики в стиле «один файл, один main, никакой магии». Наша задача: ввести 7 температур, вывести их, посчитать сумму и среднее. Часть сделаем индексами (потому что так проще), а часть — через begin/end (потому что мы сегодня их изучаем).

Ввод и печать через size()

#include <array>
#include <cstddef>
#include <iostream>

int main() {
    std::array<int, 7> temps{};

    for (std::size_t i = 0; i < temps.size(); ++i) {
        std::cin >> temps[i];
    }

    for (std::size_t i = 0; i < temps.size(); ++i) {
        std::cout << temps[i] << ' ';
    }
    std::cout << '\n'; // например: 10 11 9 8 12 13 7
}

Здесь мы закрепили две вещи: «размер спрашиваем у массива» и «граница цикла — строго < size()».

Сумма через begin()/end()

Теперь считаем сумму через итераторы:

#include <array>
#include <iostream>

int main() {
    std::array<int, 7> temps{10, 11, 9, 8, 12, 13, 7};

    int sum = 0;
    for (auto it = temps.begin(); it != temps.end(); ++it) {
        sum += *it;
    }

    std::cout << "sum=" << sum << '\n'; // sum=70
}

Обратите внимание: мы не используем индексы вообще. Мы просто идём от begin() до end().

Среднее: целые и double

Среднее = сумма / количество. Если всё int, среднее тоже получится int (с отбрасыванием дробной части). Это нормально, если вы это понимаете. Если хочется дробное среднее, нужно привести к double.

#include <array>
#include <iostream>

int main() {
    std::array<int, 7> temps{10, 11, 9, 8, 12, 13, 7};

    int sum = 0;
    for (auto it = temps.begin(); it != temps.end(); ++it) {
        sum += *it;
    }

    double avg = static_cast<double>(sum) / temps.size();
    std::cout << "avg=" << avg << '\n'; // avg=10
}

Да, в примере avg вышло ровно 10, но это потому что числа так сложились. В других наборах было бы, например, 10.4286...

Почему std::array часто безопаснее C‑массива

Иногда начинающие думают, что «контейнер стандартной библиотеки» обязательно медленнее, потому что «там внутри, наверное, магия». У std::array магии почти нет: это тонкая оболочка вокруг фиксированного блока элементов. По ощущению он похож на C‑массив, но с нормальным интерфейсом.

Ключевой момент безопасности здесь даже не в том, что std::array «проверяет границы» (оператор [] не проверяет). Безопасность в том, что вы меньше пишете вручную. Меньше вручную — меньше мест, где можно ошибиться. size() уменьшает шанс «off-by-one», begin/end задают единый способ обхода, а сам объект можно передать/скопировать как целое (в пределах того, что вам нужно), не устраивая танцы с «это массив, его нельзя присваивать».

Ещё одна очень практичная вещь: std::array не превращается сам по себе в «просто адрес первого элемента» так легко, как C‑массив. То есть вам сложнее случайно потерять размер. Если уж вам нужен «сырой доступ», он тоже есть, но это будет уже осознанный шаг.

8. Типичные ошибки при работе со std::array

Ошибка №1: снова писать «магическое число» вместо size().
Если вы объявили std::array<int, 7>, а потом делаете for (int i = 0; i < 7; ++i), вы как будто купили умную стиральную машину, но стираете руками, потому что «так привычнее». Привычка использовать a.size() окупается очень быстро: вы меняете размер один раз в типе, а не ищете все «7» по файлу.

Ошибка №2: путать end() с «последним элементом».
end() — это позиция «после последнего». Если вы попытаетесь сделать *a.end(), это логически то же самое, что «взять элемент за пределами». То есть ничего хорошего. Если нужен последний элемент по индексу, это a[a.size() - 1]. Если говорить итераторно, то до end() можно дойти, но разыменовывать end() нельзя.

Ошибка №3: писать условие it <= a.end() в итераторном цикле.
Почти всегда корректный цикл выглядит как it != a.end() (или it < a.end() для случайно‑доступных итераторов, но это отдельная история). Когда вы пишете <= end(), вы гарантированно попадаете в ситуацию «а вот сейчас я попытаюсь обработать end как элемент», и это закончится плохо или странно.

Ошибка №4: забыть, что size() — это не int.
size() возвращает тип размера (std::size_t). Если вы храните индекс в int, а потом сравниваете с size(), компилятор может начать предупреждать, а иногда и логика станет скользкой на границах. На этом этапе курса разумное правило простое: индексы и размеры держим в std::size_t, и жизнь становится спокойнее.

Ошибка №5: ожидать, что std::array «автоматически защищает от выхода за границы».
std::array — более удобный и строгий объект, но a[i] всё равно требует, чтобы i был в диапазоне 0..size()-1. Контейнер помогает тем, что даёт size() и нормальные границы, но думать головой всё равно придётся.