2.3. Операторы цикла
Теория
Зачем нужен этот пункт
Во многих задачах одно и то же действие нужно выполнить несколько раз: вывести числа от 1 до 10, посчитать сумму, найти произведение, повторять ввод до тех пор, пока пользователь не введёт корректные данные, обработать последовательность значений.
Для таких ситуаций в языке C используются операторы цикла. Цикл позволяет многократно выполнять один оператор или блок операторов, пока выполняется заданное условие.
В языке C есть три основные формы циклов:
while— цикл с предусловием;do while— цикл с постусловием;for— параметрический цикл.
Из чего состоит цикл
Большинство циклов состоит из двух частей:
- условие или управляющая часть — определяет, нужно ли продолжать цикл;
- тело цикла — оператор или блок операторов, которые повторяются.
Тело цикла может быть:
- одним оператором;
- составным оператором в фигурных скобках;
- пустым оператором.
while (условие)
один_оператор;
while (условие)
{
оператор_1;
оператор_2;
}
while (условие)
;
В учебных программах чаще всего тело цикла записывают в фигурных скобках, даже если внутри только один оператор. Так код легче читать и безопаснее изменять.
Цикл while
Цикл while называется циклом с предусловием, потому что условие
проверяется до выполнения тела цикла.
Общая форма:
while (условие)
{
тело_цикла;
}
Алгоритм работы:
- сначала вычисляется условие;
- если условие истинно, выполняется тело цикла;
- после выполнения тела программа снова возвращается к проверке условия;
- если условие ложно, цикл завершается.
Если условие ложно уже при первой проверке, тело цикла не выполнится ни разу.
Пример while: вывод чисел
#include <stdio.h>
int main(void)
{
int i = 1;
while (i <= 5)
{
printf("%d\n", i);
i++;
}
return 0;
}
Результат работы:
1
2
3
4
5
Здесь переменная i является счётчиком цикла.
Перед циклом она получает начальное значение 1.
На каждой итерации значение выводится, затем увеличивается на единицу.
Когда i становится равно 6, условие
i <= 5 становится ложным, и цикл завершается.
Три обязательные части цикла со счётчиком
В цикле со счётчиком обычно есть три важные части:
- инициализация — начальное значение счётчика;
- условие продолжения — пока оно истинно, цикл продолжается;
- изменение счётчика — приближение к завершению цикла.
int i = 1; /* инициализация */
while (i <= 5) /* условие */
{
printf("%d\n", i);
i++; /* изменение */
}
Если забыть изменить счётчик, цикл может стать бесконечным.
int i = 1;
while (i <= 5)
{
printf("%d\n", i);
/* i++ забыли */
}
В этом примере i всегда остаётся равным 1,
поэтому условие всегда истинно.
Цикл do while
Цикл do while называется циклом с постусловием, потому что
условие проверяется после выполнения тела цикла.
Общая форма:
do
{
тело_цикла;
} while (условие);
Алгоритм работы:
- сначала выполняется тело цикла;
- после этого проверяется условие;
- если условие истинно, тело выполняется снова;
- если условие ложно, цикл завершается.
Главное отличие от while: тело цикла do while
всегда выполняется хотя бы один раз.
После условия в цикле do while обязательно ставится точка
с запятой.
do
{
printf("Hello\n");
} while (0);
Пример do while: повторный ввод
Цикл do while удобно использовать, когда действие нужно
выполнить хотя бы один раз. Например, запросить число у пользователя,
а затем повторять ввод, пока число не станет допустимым.
#include <stdio.h>
int main(void)
{
int n;
do
{
printf("Введите положительное число: ");
scanf("%d", &n);
if (n <= 0)
{
printf("Ошибка: число должно быть больше нуля.\n");
}
} while (n <= 0);
printf("Вы ввели n = %d\n", n);
return 0;
}
Здесь ввод выполняется минимум один раз. Если пользователь ввёл неправильное значение, цикл повторяется.
Сравнение while и do while
| Цикл | Когда проверяется условие | Минимальное число выполнений тела |
|---|---|---|
while |
до тела цикла | 0 |
do while |
после тела цикла | 1 |
Используй while, если тело цикла может не понадобиться вообще.
Используй do while, если действие нужно выполнить минимум один раз.
while (n > 0)
{
/* может не выполниться ни разу */
}
do
{
/* выполнится хотя бы один раз */
} while (n > 0);
Цикл for
Цикл for часто называют параметрическим циклом. Он удобен,
когда заранее понятно, как изменяется счётчик цикла.
Общая форма:
for (выражение_1; условие; выражение_3)
{
тело_цикла;
}
Обычно:
выражение_1задаёт начальное значение счётчика;условиепроверяет, нужно ли продолжать цикл;выражение_3изменяет счётчик после каждой итерации.
for (i = 1; i <= 5; i++)
{
printf("%d\n", i);
}
Этот цикл делает то же самое, что пример с while:
выводит числа от 1 до 5.
Как выполняется цикл for
Рассмотрим цикл:
for (i = 1; i <= 5; i++)
{
printf("%d\n", i);
}
Порядок выполнения:
- сначала один раз выполняется
i = 1; - проверяется условие
i <= 5; - если условие истинно, выполняется тело цикла;
- после тела выполняется
i++; - затем снова проверяется условие;
- когда условие становится ложным, цикл завершается.
Эквивалентная запись через while:
i = 1;
while (i <= 5)
{
printf("%d\n", i);
i++;
}
Пример for: сумма чисел
Найдём сумму чисел от 1 до n.
#include <stdio.h>
int main(void)
{
int n;
int i;
int sum = 0;
printf("Введите n: ");
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
sum += i;
}
printf("Сумма = %d\n", sum);
return 0;
}
Переменная sum накапливает результат. Перед циклом она
обязательно инициализируется нулём. На каждой итерации к ней
прибавляется очередное значение i.
Любые выражения в заголовке for
В заголовке for могут использоваться не только простые
присваивания и инкременты. Там могут быть любые выражения, если они
имеют смысл для управления циклом.
for (i = 0, j = 10; i < j; i++, j--)
{
printf("i = %d, j = %d\n", i, j);
}
Здесь в первой части заголовка задаются два начальных значения:
i = 0 и j = 10. В третьей части одновременно
изменяются обе переменные.
Запятая в заголовке for часто используется для записи
нескольких действий в одной части цикла.
Необязательные части for
В цикле for любое из трёх выражений может отсутствовать.
Но две точки с запятой внутри круглых скобок должны остаться.
for (; i <= 10; i++)
{
printf("%d\n", i);
}
Здесь отсутствует выражение инициализации. Значение i
должно быть задано до цикла.
for (i = 1; i <= 10; )
{
printf("%d\n", i);
i++;
}
Здесь отсутствует третья часть заголовка. Изменение счётчика выполняется внутри тела цикла.
for (i = 1; ; i++)
{
printf("%d\n", i);
if (i == 10)
{
break;
}
}
Здесь отсутствует условие. Если условие в for не указано,
оно считается истинным, поэтому для выхода нужен другой механизм,
например break.
Бесконечные циклы
Бесконечный цикл — это цикл, условие которого всегда истинно. Иногда он является ошибкой, а иногда используется специально.
Бесконечный цикл через while:
while (1)
{
/* тело цикла */
}
Бесконечный цикл через for:
for (;;)
{
/* тело цикла */
}
Если бесконечный цикл используется осознанно, внутри него должен быть
способ выхода: break, return или изменение состояния,
которое завершит программу.
Оператор break
Оператор break немедленно завершает ближайший цикл
или оператор switch.
while (1)
{
scanf("%d", &n);
if (n > 0)
{
break;
}
printf("Ошибка: n должно быть больше 0\n");
}
Здесь цикл формально бесконечный, потому что условие while (1)
всегда истинно. Но если пользователь вводит корректное значение,
выполняется break, и цикл завершается.
После break выполнение продолжается с оператора, который
находится после цикла.
Пример break: проверка ввода
Пример: нужно вводить n, пока пользователь не введёт
положительное число.
#include <stdio.h>
int main(void)
{
int n;
while (1)
{
printf("Введите n > 0: ");
scanf("%d", &n);
if (n > 0)
{
break;
}
printf("Ошибка! n должно быть больше 0.\n");
}
printf("Корректное n = %d\n", n);
return 0;
}
Такой приём удобен, когда условие выхода естественно проверять в середине тела цикла: сначала нужно выполнить ввод, затем проверить введённое значение.
Оператор continue
Оператор continue завершает текущую итерацию цикла
и переводит выполнение к следующей итерации.
В цикле while после continue программа переходит
к проверке условия.
В цикле for после continue сначала выполняется
третья часть заголовка, затем проверяется условие.
for (i = 1; i <= 10; i++)
{
if (i % 2 == 0)
{
continue;
}
printf("%d\n", i);
}
Этот цикл выводит только нечётные числа. Если i чётное,
выполняется continue, и вызов printf пропускается.
break и continue: разница
| Оператор | Что делает |
|---|---|
break |
полностью завершает ближайший цикл |
continue |
завершает только текущую итерацию и переходит к следующей |
for (i = 1; i <= 10; i++)
{
if (i == 5)
{
break;
}
printf("%d\n", i);
}
Этот цикл выведет 1 2 3 4, затем завершится.
for (i = 1; i <= 10; i++)
{
if (i == 5)
{
continue;
}
printf("%d\n", i);
}
Этот цикл выведет все числа от 1 до 10, кроме 5.
Цикл с накоплением суммы
Очень распространённая задача — накопить сумму в цикле. Для этого используется переменная-накопитель.
#include <stdio.h>
int main(void)
{
int n;
int i;
int value;
int sum = 0;
printf("Сколько чисел ввести? ");
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
printf("Введите число %d: ", i);
scanf("%d", &value);
sum += value;
}
printf("Сумма = %d\n", sum);
return 0;
}
Перед циклом sum обязательно получает значение 0.
Если этого не сделать, программа будет прибавлять числа к неопределённому
начальному значению.
Цикл с накоплением произведения
Для произведения используется похожая схема, но начальное значение
накопителя должно быть 1, а не 0.
#include <stdio.h>
int main(void)
{
int n;
int i;
int product = 1;
printf("Введите n: ");
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
product *= i;
}
printf("Произведение от 1 до n = %d\n", product);
return 0;
}
Если начать произведение с нуля, результат всегда останется нулём.
Цикл с поиском количества
Ещё один типичный приём — подсчёт количества элементов, удовлетворяющих условию.
#include <stdio.h>
int main(void)
{
int n;
int i;
int value;
int count = 0;
printf("Сколько чисел ввести? ");
scanf("%d", &n);
for (i = 1; i <= n; i++)
{
scanf("%d", &value);
if (value > 0)
{
count++;
}
}
printf("Положительных чисел: %d\n", count);
return 0;
}
Здесь переменная count увеличивается только тогда,
когда введённое число больше нуля.
Вычисление ряда
Циклы часто используются для приближённых вычислений. Например, можно суммировать члены ряда до тех пор, пока очередной член не станет достаточно малым.
#include <stdio.h>
int main(void)
{
double x;
double eps;
double sum;
double term;
int i;
printf("Введите x: ");
scanf("%lf", &x);
printf("Введите eps: ");
scanf("%lf", &eps);
i = 1;
sum = 1.0;
term = x;
while (term > eps || term < -eps)
{
sum += term;
i++;
term = term * x / i;
}
printf("Сумма = %f\n", sum);
return 0;
}
В этом примере цикл продолжается, пока модуль очередного члена ряда
больше заданной точности eps. Проверка записана как:
term > eps || term < -eps
Это означает: член ряда либо больше eps, либо меньше
-eps, то есть по модулю ещё достаточно велик.
Пустое тело цикла
Тело цикла может быть пустым оператором.
while (условие)
;
Такой приём используется редко. Он означает, что вся работа выполняется в условии или в заголовке цикла.
for (i = 0; i < 10; i++)
;
Этот цикл просто увеличит i до 10, ничего не делая
в теле.
В учебных программах пустые тела циклов лучше использовать осторожно, потому что одиночную точку с запятой легко поставить случайно.
Лишняя точка с запятой после заголовка цикла
Лишняя точка с запятой после while или for
создаёт пустое тело цикла и часто приводит к ошибке.
int i = 1;
while (i <= 5);
{
printf("%d\n", i);
i++;
}
Здесь тело цикла — это пустой оператор сразу после while.
Блок в фигурных скобках уже не относится к циклу.
Если i равно 1, такой цикл станет бесконечным,
потому что i внутри настоящего тела цикла не изменяется.
Правильно:
int i = 1;
while (i <= 5)
{
printf("%d\n", i);
i++;
}
Вложенные циклы: первое представление
В теле цикла может находиться другой цикл. Такие циклы называются вложенными.
for (i = 1; i <= 3; i++)
{
for (j = 1; j <= 4; j++)
{
printf("*");
}
printf("\n");
}
Эта программа выводит прямоугольник из звёздочек:
****
****
****
Внешний цикл отвечает за строки, внутренний — за символы внутри каждой строки.
Подробно массивы и вложенные циклы будут рассматриваться в следующем пункте, но уже сейчас полезно понимать, что цикл может быть частью тела другого цикла.
break и continue во вложенных циклах
Во вложенных циклах break и continue действуют
только на ближайший цикл, внутри которого они написаны.
for (i = 1; i <= 3; i++)
{
for (j = 1; j <= 5; j++)
{
if (j == 3)
{
break;
}
printf("%d ", j);
}
printf("\n");
}
Здесь break завершает только внутренний цикл по j.
Внешний цикл по i продолжает работу.
Результат:
1 2
1 2
1 2
Как выбрать тип цикла
| Ситуация | Удобный цикл |
|---|---|
| нужно повторять действие, пока условие истинно | while |
| тело должно выполниться хотя бы один раз | do while |
| есть счётчик с понятным началом, концом и шагом | for |
| нужно проверять выход в середине тела | while (1) + break |
Это не строгие правила, а практические рекомендации. Одну и ту же задачу часто можно решить разными видами циклов.
Типичные ошибки
Ошибка 1. Забыли изменить счётчик
int i = 1;
while (i <= 10)
{
printf("%d\n", i);
}
Значение i не меняется, поэтому цикл не завершается.
Ошибка 2. Лишняя точка с запятой после while
while (i <= 10);
{
printf("%d\n", i);
i++;
}
Цикл имеет пустое тело. Блок ниже выполнится отдельно, а не в цикле.
Ошибка 3. Неправильное начальное значение суммы
int sum;
for (i = 1; i <= n; i++)
{
sum += i;
}
sum не инициализирована. Правильно:
int sum = 0;
Ошибка 4. Неправильное начальное значение произведения
int product = 0;
for (i = 1; i <= n; i++)
{
product *= i;
}
Произведение всегда останется нулём. Правильно:
int product = 1;
Ошибка 5. Потеря изменения перед continue
int i = 0;
while (i < 10)
{
if (i % 2 == 0)
{
continue;
}
printf("%d\n", i);
i++;
}
Если i равно 0, выполнится continue,
и i++ не произойдёт. Цикл станет бесконечным.
Лучше:
int i = 0;
while (i < 10)
{
i++;
if (i % 2 == 0)
{
continue;
}
printf("%d\n", i);
}
Практические рекомендации
- Пиши тело цикла в фигурных скобках.
- Следи, чтобы условие цикла когда-нибудь становилось ложным.
- Для суммы начальное значение обычно
0. - Для произведения начальное значение обычно
1. - Для циклов со счётчиком чаще всего удобен
for. - Для повторного ввода минимум один раз часто удобен
do while. - Не ставь точку с запятой сразу после заголовка
while,forилиdo while, если не нужен пустой оператор. - Используй
break, если нужно полностью выйти из цикла. - Используй
continue, если нужно пропустить только текущую итерацию. - Во вложенных циклах помни:
breakзавершает только ближайший цикл.
Мини-разбор программы
Программа вводит положительное n, затем считает сумму
чисел от 1 до n.
#include <stdio.h>
int main(void)
{
int n;
int i;
int sum = 0;
while (1)
{
printf("Введите n > 0: ");
scanf("%d", &n);
if (n > 0)
{
break;
}
printf("Ошибка ввода.\n");
}
for (i = 1; i <= n; i++)
{
sum += i;
}
printf("Сумма от 1 до %d равна %d\n", n, sum);
return 0;
}
Разберём программу:
- первый цикл
while (1)используется для проверки ввода; breakзавершает цикл, когда введено корректноеn;- цикл
forперебирает значенияiот 1 доn; sum += iнакапливает сумму;- после цикла результат выводится через
printf.
Что нужно запомнить
- Цикл нужен для многократного выполнения операторов.
whileпроверяет условие до выполнения тела.do whileпроверяет условие после выполнения тела.- Тело
do whileвыполняется минимум один раз. forудобен для циклов со счётчиком.- В
forлюбое из трёх выражений может отсутствовать, но точки с запятой остаются. - Если условие в
forотсутствует, оно считается истинным. while (1)иfor (;;)создают бесконечные циклы.breakполностью завершает ближайший цикл.continueпропускает оставшуюся часть текущей итерации.- Во вложенных циклах
breakиcontinueотносятся к ближайшему циклу. - Для суммы накопитель обычно инициализируют нулём.
- Для произведения накопитель обычно инициализируют единицей.
Самопроверка перед переходом дальше
- Для чего нужны циклы?
- Чем отличается
whileотdo while? - Почему тело
do whileвыполняется хотя бы один раз? - Из каких трёх частей обычно состоит заголовок
for? - Что произойдёт, если в
forне указать условие? - Как записать бесконечный цикл через
while? - Как записать бесконечный цикл через
for? - Что делает оператор
break? - Что делает оператор
continue? - Почему для суммы начальное значение обычно
0? - Почему для произведения начальное значение обычно
1? - Почему опасна лишняя точка с запятой после заголовка цикла?