bulgakov

18. Повторение действий: цикл while

До сих пор программа выбирала, нужно ли выполнить действие. Теперь пусть она выводит числа от 0 до 9. Десять почти одинаковых вызовов printf писать неудобно. Цикл повторяет один и тот же участок кода, пока выполняется условие.

Сначала проверить, затем выполнить

У while условие стоит перед повторяемыми командами. Полная программа:

C
#include <stdio.h>

int main(void)
{
    int i = 0;

    while (i < 10) {
        printf("%d\n", i);
        i = i + 1;
    }
    return 0;
}

Вывод:

0
1
2
3
4
5
6
7
8
9

Переменная i хранит текущее число. Здесь она служит счётчиком: после каждого вывода увеличивается на единицу. Команды внутри { ... } называются телом цикла. Одно выполнение тела — итерация.

Программа сначала записывает 0 в i. Затем проверяет i < 10. Если проверка истинна, выполняет тело сверху вниз: печатает i, увеличивает его и возвращается к проверке.

Схема
i = 0
  ↓
проверка i < 10 ── ложь ──→ продолжить после цикла
  │
  истина
  ↓
напечатать i
  ↓
i = i + 1
  │
  └──────────────→ снова проверить i < 10

int i = 0; находится до цикла, поэтому выполняется один раз. При возврате к условию значение i не сбрасывается.

i перед проверкой i < 10 Что происходит
0 истина Печатается 0; i становится 1
1 истина Печатается 1; i становится 2
9 истина Печатается 9; i становится 10
10 ложь Тело пропускается; цикл заканчивается

В таблице пропущены одинаково устроенные шаги от 2 до 8. Число 10 не печатается: проверка уже ложна до очередного вызова printf.

Как и в if, ноль в условии означает ложь, любое ненулевое значение — истину. Если при первой проверке условие ложно, тело while не выполнится ни разу. Например, при начальном i = 10 первая программа ничего не напечатает.

Начало, граница и шаг

Для цикла со счётчиком полезно отдельно назвать три вещи: начальное значение, условие продолжения и изменение после шага.

Выведем 10, 8, 6, 4, 2, 0:

C
#include <stdio.h>

int main(void)
{
    int i = 10;

    while (i >= 0) {
        printf("%d\n", i);
        i = i - 2;
    }
    return 0;
}

Здесь начало — 10, условие — i >= 0, шаг — уменьшение на 2. Ноль входит в вывод, потому что 0 >= 0 истинно. После него i становится -2; следующая проверка завершает цикл. Для этого обратного отсчёта выбран знаковый int: отрицательное значение позволяет выйти по условию.

Запись i += 1 для этой простой переменной означает то же изменение, что i = i + 1. Аналогично i -= 2 уменьшает её на два. Такие записи называют составным присваиванием. Само присваивание не создаёт цикл: оно лишь меняет значение в одном шаге.

Условие i != 10 тоже напечатает 0…9, если начать с нуля и каждый раз прибавлять ровно один. Но оно требует попасть точно в 10. Например, последовательность 1, 3, 5, 7, 9, 11, ... при шаге 2 пропустит 10. Условие i < 10 в такой задаче удобнее: оно остановит цикл и при пересечении границы. Не рассчитывайте, что знаковый счётчик будет безопасно расти бесконечно: при переполнении int поведение не определено.

Почему цикл может не закончиться

Если из первой программы убрать i = i + 1;, значение i останется нулём. Условие 0 < 10 каждый раз будет истинным, и программа продолжит печатать 0. Это бесконечный цикл: в его действиях нет причины для выхода. Такой пример лучше разобрать по шагам; случайно запущенную печать в терминале обычно можно остановить Ctrl+C.

Другая ошибка — точка с запятой сразу после условия: while (i < 10);. Она образует пустое тело. Блок в фигурных скобках после неё уже не является телом этого цикла. При начальном i = 0 и отсутствии других изменений цикл не дойдёт до увеличения счётчика в том блоке.

В обычной записи while (условие) { ... } точка с запятой между условием и { не нужна. Фигурные скобки объединяют вывод и изменение счётчика в одно повторяемое тело.

Два счётчика и составное условие

Условие цикла может соединять проверки через && и ||, как условие if. В следующей программе i растёт на один, а j — на два. Продолжаем, пока i < x и одновременно j <= y.

Для примера вводите два целых числа от 0 до 100. Проверка диапазона также ограничивает значения счётчиков в этой программе.

C
#include <stdio.h>

int main(void)
{
    int x = 0;
    int y = 0;
    int i = 0;
    int j = 0;

    if (scanf("%d %d", &x, &y) != 2) {
        printf("Input error\n");
        return 1;
    }
    if (x < 0 || x > 100 || y < 0 || y > 100) {
        printf("Out of range\n");
        return 1;
    }

    while (i < x && j <= y) {
        printf("i = %d, j = %d\n", i, j);
        i += 1;
        j += 2;
    }
    return 0;
}

При вводе 3 4:

i = 0, j = 0
i = 1, j = 2
i = 2, j = 4

После третьего шага значения становятся i = 3, j = 6. Для продолжения нужны обе проверки, но 3 < 3 уже ложно. При вводе 10 1 выполнится только шаг с i = 0, j = 0: затем j станет 2, и проверка 2 <= 1 остановит цикл. При x = 0 тело не выполнится ни разу.

scanf с двумя спецификаторами должна успешно прочитать два числа, поэтому сравниваем её результат с 2. Для этих учебных программ вводимые числа должны помещаться в int; проверка результата scanf не является полноценной защитой от ввода чисел произвольной длины.

Практика: вывести числа в обоих направлениях

Введите целое x из [0, 100]. Сначала выведите все числа от 0 до x включительно, затем — от x до 0. Перед чтением решения определите начальное значение, условие и шаг для каждого направления.

Решение и проверка границ
C
#include <stdio.h>

int main(void)
{
    int x = 0;
    if (scanf("%d", &x) != 1) {
        printf("Input error\n");
        return 1;
    }
    if (x < 0 || x > 100) {
        printf("Out of range\n");
        return 1;
    }

    int i = 0;
    printf("Up:");
    while (i <= x) {
        printf(" %d", i);
        i += 1;
    }
    printf("\nDown:");
    i = x;
    while (i >= 0) {
        printf(" %d", i);
        i -= 1;
    }
    printf("\n");
    return 0;
}

При вводе 3 получится:

Up: 0 1 2 3
Down: 3 2 1 0

В первом цикле <= включает верхнюю границу x. Перед вторым циклом заново присваиваем i = x; иначе он начал бы с значения, оставшегося после первого цикла. Условие i >= 0 включает ноль, а затем пропускает тело при i = -1.

При вводе 0 оба направления печатают единственное число 0. При 100 каждый цикл выводит 101 число. Ввод -1 и 101 отклоняется проверкой диапазона, а q — проверкой чтения.

Практика: накопить сумму

Введите целое x из [0, 20]. Вычислите сумму чисел от 1 до x. Здесь нужны две разные переменные: одна выбирает очередное слагаемое, другая хранит накопленный результат.

Решение и смысл переменной sum
C
#include <stdio.h>

int main(void)
{
    int x = 0;
    if (scanf("%d", &x) != 1) {
        printf("Input error\n");
        return 1;
    }
    if (x < 0 || x > 20) {
        printf("Out of range\n");
        return 1;
    }

    int i = 1;
    int sum = 0;
    while (i <= x) {
        sum += i;
        i += 1;
    }
    printf("Sum: %d\n", sum);
    return 0;
}

При вводе 4 вывод — Sum: 10. Изменения суммы: 0 → 1 → 3 → 6 → 10. На каждом шаге к прежней сумме прибавляется текущее i, и только затем i увеличивается.

sum = 0 стоит перед циклом. Если обнулять сумму внутри тела, предыдущие слагаемые будут теряться.

При x = 0 нет чисел от 1 до x: первая проверка 1 <= 0 ложна, тело пропускается, сумма остаётся 0. При x = 20 получается 210; такой результат помещается даже в минимальный гарантированный диапазон int.

В следующем уроке переставим проверку в конец и разберём цикл do…while.

ПрактикаЗагружаем тест…