Цикл for в C++: синтаксис, примеры и распространённые ошибки

Зачем нужен цикл for

switch выбирает одну ветку и выполняет её один раз. Но настоящим программам нужно делать что-то многократно: вывести каждый результат, просуммировать список чисел, нарисовать 10 строк сетки. Цикл for — рабочая лошадка C++ для повторения кода известное число раз, со встроенным счётчиком, которым вы управляете.

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

Заголовок из трёх частей

Заголовок цикла for состоит из трёх частей, разделённых точкой с запятой: инициализатор, условие и обновление.

for (initializer; condition; update) {
    // тело - выполняется, пока условие истинно
}

Они выполняются в определённом порядке: инициализатор выполняется один раз в начале; затем условие проверяется перед каждой итерацией; тело выполняется только если условие true; а обновление выполняется в конце каждой итерации, прямо перед тем, как условие снова проверяется.

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; i++) {
        cout << "i = " << i << "\n";
    }
    cout << "done\n";
}

Здесь int i = 0 выполняется один раз. Затем проверяется i < 5: пока оно истинно, тело выводит значение, а i++ увеличивает счётчик. Когда i достигает 5, условие становится false, поэтому цикл завершается и выводится done. Тело выполняется ровно 5 раз, при этом i принимает значения от 0 до 4.

Объявление счётчика внутри заголовка (int i = 0) ограничивает область видимости i циклом — он не существует после закрывающей фигурной скобки, что как раз то, что вам нужно.

Счёт вверх, вниз и с шагом

Часть обновления не ограничивается i++. Можно считать вниз, шагать на любую величину или перебирать индекс массива.

#include <iostream>
using namespace std;

int main() {
    // обратный отсчёт
    for (int i = 5; i > 0; i--) {
        cout << i << " ";
    }
    cout << "liftoff\n";

    // шаг 2 (чётные числа)
    for (int n = 0; n <= 10; n += 2) {
        cout << n << " ";
    }
    cout << "\n";
}

Первый цикл выполняется, пока i > 0, уменьшая счётчик каждый раз, поэтому выводит 5 4 3 2 1. Второй прибавляет 2 на каждом проходе и использует <= 10, потому что 10 — значение, которое мы хотим включить. Согласуйте условие с обновлением: счёт вниз сочетается с > или >=, счёт вверх — с < или <=.

Перебор массива

Самое частое применение счётного цикла — обход массива по индексу. Счётчик заодно служит позицией, которую вы читаете.

#include <iostream>
using namespace std;

int main() {
    int scores[] = {88, 92, 75, 60, 100};
    int n = sizeof(scores) / sizeof(scores[0]);

    int total = 0;
    for (int i = 0; i < n; i++) {
        total += scores[i];
    }

    cout << "Sum: " << total << "\n";
    cout << "Average: " << total / n << "\n";
}

Обратите внимание, что условие — i < n, а не i <= n. У массива из 5 элементов допустимые индексы от 0 до 4; индекс 5 находится за концом. Чтение scores[5] — неопределённое поведение: может вывестись мусор, программа упадёт или, казалось бы, сработает, незаметно повредив память. Шаблон i < n — безопасный вариант по умолчанию для любого массива с отсчётом от нуля.

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

break и continue

Два ключевых слова позволяют менять ход выполнения посреди цикла. break немедленно выходит из цикла; continue пропускает остаток текущей итерации и переходит к обновлению.

#include <iostream>
using namespace std;

int main() {
    // остановиться на первом числе, делящемся на 7
    for (int i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            cout << "First multiple of 7: " << i << "\n";
            break;
        }
    }

    // вывести только нечётные числа, пропуская чётные
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;
        }
        cout << i << " ";
    }
    cout << "\n";
}

Первый цикл останавливается в тот момент, когда находит 7, и не проверяет остальное. Второй использует continue, чтобы пропускать вывод в теле всякий раз, когда i чётное, — обновление i++ всё равно выполняется, поэтому цикл продолжает двигаться. Тонкая ловушка: continue переходит к обновлению, поэтому если вы когда-нибудь полагаетесь на continue в цикле, чей счётчик обновляется внутри тела, а не в заголовке, вы можете случайно пропустить это обновление и зациклиться навсегда.

Вложенные циклы

Поместите один for внутрь другого, чтобы работать с сетками, таблицами или парами. Внутренний цикл полностью отрабатывает на каждом отдельном шаге внешнего цикла.

#include <iostream>
using namespace std;

int main() {
    for (int row = 1; row <= 3; row++) {
        for (int col = 1; col <= 3; col++) {
            cout << row * col << "\t";
        }
        cout << "\n";
    }
}

Это выводит таблицу умножения 3x3. Внешний цикл фиксирует row, внутренний цикл проходит по каждому col для этой строки, а затем перевод строки завершает строку. Давайте счётчикам разные имена (row/col, а не i/i) — повторное использование одного имени затеняет внешний и порождает непонятные баги. Следите и за стоимостью: вложение цикла на n внутрь цикла на n выполняет тело n * n раз, что быстро накапливается.

Распространённые подводные камни

Несколько ловушек объясняют большинство багов циклов for в C++:

• Смещение на единицу: i <= n при размере с отсчётом от нуля читает один элемент за концом. Используйте i < n.
• Беззнаковое переполнение снизу (underflow): счёт вниз с беззнаковым типом никогда не уходит в отрицательные. for (size_t i = n - 1; i >= 0; i--) зацикливается навсегда, потому что i >= 0 всегда истинно для беззнакового значения — когда i равно 0, i-- оборачивается в огромное положительное число. Используйте знаковый int для убывающего счёта или перепишите условие.
• Изменение счётчика внутри тела: изменение i и в теле, и в заголовке делает число итераций непредсказуемым. Выберите одно место.

// BUG: infinite loop - unsigned i is never < 0
for (size_t i = n - 1; i >= 0; i--) {
    process(arr[i]);
}

Счётчики с плавающей точкой — другая тихая опасность: for (double x = 0.0; x != 1.0; x += 0.1) может никогда не попасть точно в 1.0, потому что 0.1 нельзя сохранить точно. Делайте цикл по целочисленному счёту и вычисляйте значение внутри, либо используйте < вместо !=.

Далее: циклы while

Цикл for хорош, когда число повторений известно заранее. Но иногда нужно повторять до тех пор, пока не изменится условие — читать ввод до конца файла, повторять до успеха — без фиксированного числа шагов. Это работа цикла while, который сводит заголовок к одному лишь условию. Это следующая страница.