Какие знаешь способы обойти array?

Способы обхода массивов в C++

Обход (итерация) массивов — одна из самых частых операций в программировании. C++ предоставляет множество способов, каждый с собственными преимуществами и недостатками.

1. Классический цикл for с индексом

int arr[] = {1, 2, 3, 4, 5};
int size = 5;

// Самый базовый способ
for (int i = 0; i < size; i++) {
    std::cout << arr[i] << " ";
}

// C++ стиль со std::size для массива
for (size_t i = 0; i < std::size(arr); i++) {
    std::cout << arr[i] << " ";
}

Преимущества:

• Полный контроль над индексом
• Возможность перемещаться вперёд/назад
• Низкие накладные расходы
• Работает с сырыми массивами и всеми контейнерами

Недостатки:

• Многословно
• Легко ошибиться с границами (off-by-one ошибки)
• Нужно помнить размер массива

Когда использовать: когда нужен доступ к индексу, реализация сложных алгоритмов.

2. Range-based for loop (C++11)

std::vector<int> vec = {1, 2, 3, 4, 5};

// Копирование элемента в каждой итерации
for (int value : vec) {
    std::cout << value << " ";
}

// Ссылка (лучше для производительности)
for (const int& value : vec) {
    std::cout << value << " ";
}

// С изменением элементов
for (int& value : vec) {
    value *= 2;  // Удвоить каждый элемент
}

// С C++17 структурированные привязки
std::vector<std::pair<int, std::string>> pairs = {{1, "one"}, {2, "two"}};
for (auto [num, word] : pairs) {
    std::cout << num << ": " << word << std::endl;
}

Преимущества:

• Современный и ясный синтаксис
• Автоматическая работа с размером
• Работает с контейнерами и сырыми массивами
• Безопаснее классического for

Недостатки:

• Нет доступа к индексу (нужна дополнительная переменная)
• Требует C++11 и выше

Когда использовать: в 99% случаев — это лучший выбор.

3. Iterator-based цикл (классический стиль STL)

std::vector<int> vec = {1, 2, 3, 4, 5};

// Явное использование итераторов
for (auto it = vec.begin(); it != vec.end(); ++it) {
    std::cout << *it << " ";
}

// Обратное направление
for (auto it = vec.rbegin(); it != vec.rend(); ++it) {
    std::cout << *it << " ";
}

// С изменением элементов
for (auto it = vec.begin(); it != vec.end(); ++it) {
    *it *= 2;
}

// С индексом через std::distance
for (auto it = vec.begin(); it != vec.end(); ++it) {
    size_t index = std::distance(vec.begin(), it);
    std::cout << "Index " << index << ": " << *it << std::endl;
}

Преимущества:

• Работает с любыми контейнерами
• Возможность использовать std::advance для случайного доступа
• Обратный итератор встроен

Недостатки:

• Многословно
• Требует разыменования (*it)
• Может быть медленнее range-based for в некоторых случаях

Когда использовать: специальные случаи, обратный обход, работа с итератором как элементом.

4. Алгоритмы STL (функциональный подход)

#include <algorithm>

std::vector<int> vec = {1, 2, 3, 4, 5};

// std::for_each
std::for_each(vec.begin(), vec.end(), [](int value) {
    std::cout << value << " ";
});

// С индексом
std::for_each(vec.begin(), vec.end(), [i = 0](int value) mutable {
    std::cout << i++ << ": " << value << std::endl;
});

// std::transform (трансформация элементов)
std::vector<int> doubled;
std::transform(vec.begin(), vec.end(),
               std::back_inserter(doubled),
               [](int x) { return x * 2; });

// std::find_if (поиск с условием)
auto it = std::find_if(vec.begin(), vec.end(), [](int x) {
    return x > 3;
});
if (it != vec.end()) {
    std::cout << "Found: " << *it << std::endl;
}

// std::count_if (подсчёт)
int count = std::count_if(vec.begin(), vec.end(), [](int x) {
    return x % 2 == 0;
});

Преимущества:

• Функциональный, декларативный стиль
• Часто оптимизируются компилятором
• Выражают намерение ясно

Недостатки:

• Требует понимания функторов и lambda
• Сложнее с многоуровневыми проверками

Когда использовать: обработка данных, функциональный подход, когда нужна трансформация.

5. While цикл с итератором

std::vector<int> vec = {1, 2, 3, 4, 5};

auto it = vec.begin();
while (it != vec.end()) {
    std::cout << *it << " ";
    ++it;
}

// Для контролируемого удаления элементов
while (it != vec.end()) {
    if (*it % 2 == 0) {
        it = vec.erase(it);  // erase возвращает следующий итератор
    } else {
        ++it;
    }
}

Когда использовать: при удалении элементов во время итерации.

6. C++20 Ranges

#include <ranges>

std::vector<int> vec = {1, 2, 3, 4, 5};

// Range-based for с диапазонами
for (int value : vec | std::views::filter([](int x) { return x > 2; })) {
    std::cout << value << " ";
}

// Цепочки трансформаций
for (int value : vec 
     | std::views::filter([](int x) { return x % 2 == 0; })
     | std::views::transform([](int x) { return x * 2; })) {
    std::cout << value << " ";
}

// Нумерованный обход (C++20)
for (auto [i, value] : vec | std::views::enumerate) {
    std::cout << i << ": " << value << std::endl;
}

Преимущества:

• Самый современный и мощный подход
• Ленивое вычисление (lazy evaluation)
• Цепочки операций очень ясны

Недостатки:

• Требует C++20
• Синтаксис может быть сложным для новичков

Сравнительная таблица

Рекомендации

1. По умолчанию используй range-based for (C++11+) — это лучший выбор
2. Если нужен индекс — либо классический for, либо C++20 views::enumerate
3. Для трансформаций — std::transform или C++20 ranges
4. Для поиска — std::find_if или ranges::find_if
5. При удалении — осторожнее с итераторами, используй erase/remove idiom

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