18. Повторение действий: цикл while
До сих пор программа выбирала, нужно ли выполнить действие. Теперь пусть она выводит числа от 0 до 9. Десять почти одинаковых вызовов printf писать неудобно. Цикл повторяет один и тот же участок кода, пока выполняется условие.
Сначала проверить, затем выполнить
У while условие стоит перед повторяемыми командами. Полная программа:
#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:
#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. Проверка диапазона также ограничивает значения счётчиков в этой программе.
#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. Перед чтением решения определите начальное значение, условие и шаг для каждого направления.
Решение и проверка границ
#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
#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.
