Инструкция for в языке си это

• блока проверки условия повторения цикла
• тела цикла

• while — цикл с предусловием;
• do…while — цикл с постусловием;
• for — параметрический цикл (цикл с заданным числом повторений).

Общая форма записи

Если Условие выполняется (выражение, проверяющее Условие, не равно нулю), то выполняется БлокОпераций, заключенный в фигурные скобки, затем Условие проверяется снова.
Последовательность действий, состоящая из проверки Условия и выполнения БлокаОпераций, повторяется до тех пор, пока выражение, проверяющее Условие, не станет ложным (равным нулю). При этом происходит выход из цикла, и производится выполнение операции, стоящей после оператора цикла.

Пример на Си: Посчитать сумму чисел от 1 до введенного k

Результат выполнения

При построении цикла while, в него необходимо включить конструкции, изменяющие величину проверяемого выражения так, чтобы в конце концов оно стало ложным (равным нулю). Иначе выполнение цикла будет осуществляться бесконечно (бесконечный цикл).

Пример бесконечного цикла

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

Например, если в приведенном выше коде программы ввести k=-1, то получим результат

Цикл с постусловием do…while

Общая форма записи

Цикл do…while — это цикл с постусловием, где истинность выражения, проверяющего Условие проверяется после выполнения Блока Операций, заключенного в фигурные скобки. Тело цикла выполняется до тех пор, пока выражение, проверяющее Условие, не станет ложным, то есть тело цикла с постусловием выполнится хотя бы один раз.

Использовать цикл do…while лучше в тех случаях, когда должна быть выполнена хотя бы одна итерация, либо когда инициализация объектов, участвующих в проверке условия, происходит внутри тела цикла.

Пример на Си. Проверка, что пользователь ввел число от 0 до 10

Результат выполнения:

Параметрический цикл for

Общая форма записи

for — параметрический цикл (цикл с фиксированным числом повторений). Для организации такого цикла необходимо осуществить три операции:

• Инициализация — присваивание параметру цикла начального значения;
• Условие — проверка условия повторения цикла, чаще всего — сравнение величины параметра с некоторым граничным значением;
• Модификация — изменение значения параметра для следующего прохождения тела цикла.

Результат выполнения

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

Параметры, находящиеся в выражениях в заголовке цикла можно изменить при выполнении операции в теле цикла, например

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

Пример на Си:

Результат выполнения

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

В Си допускаются вложенные циклы, то есть когда один цикл находится внутри другого:

Пример: Вывести числа от 0 до 99, по 10 в каждой строке

Результат выполнения

Рекомендации по выбору цикла

Операторы прерывания и продолжения цикла break и continue

Результат выполнения

Пример на Си: Вывести числа от 0 до 99 исключая числа, оканчивающиеся на 5 или 8

Оператор безусловного перехода goto

Общая форма записи

Выполнение оператора goto вызывает передачу управления в программе операции, помеченной Меткой. По сути Метка является идентификатором адреса операции, которой должно быть передано управление. Для отделения Метки от Операции используется двоеточие — :.
Метка может располагаться в программе как до оператора goto, так и после него. Имена Меток образуются по тем же правилам, что и имена переменных.

Пример на Си: Вывести все целые числа от 5 до 0.

Результат выполнения

Использование оператора goto в программах на Си без крайней необходимости не рекомендуется, поскольку это может повлечь за собой ряд ошибок, связанных с плохой читаемостью кода программы. Использование операторов цикла позволяет практически полностью исключить необходимость использования оператора goto.

Назад: Язык Си

Циклы

Последнее обновление: 03.01.2023

Циклы позволяет выполнить одно действие множество раз в зависимости от определенного условия. В языке Си есть следующие типы циклов:

• for

• while

• do…while

Цикл for

Цикл for имеет следующее формальное определение:

for (инициализация; условие; приращение;)
{
    // тело цикла
}

заголовок цикла состоит из трех частей. Первая часть — инициализация выполняется один раз при начале выполнения цикла и представляет установку
начальных условий, как правило, это инициализация счетчиков — специальных переменных, которые используются для контроля за циклом.

Вторая часть — условие, при соблюдении которого выполняется цикл. Зачастую в качестве условия используется операция сравнения, и если она
возвращает ненулевое значение (то есть условие истинно), то выполняется тело цикла, а затем вычисляется выражение_3.

Третья часть — приращение задает изменение параметров цикла. Обычно здесь происходит увеличение счетчиков цикла.

Рассмотрим стандартный цикл for и для этого выведем числа с 0 до 5 на консоль:

#include <stdio.h>

int main(void)
{
	for (int i = 0; i < 6; i++)
	{
		printf("%d", i);
	}
	return 0;
}

Первая часть объявления цикла — int i = 0 — создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип
int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 0.
В данном случае это то же самое, что и объявление переменной.

Вторая часть — условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 6.

И третья часть — приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i—. Можно изменять на другое значение: i+=2.

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

Каждый отдельный проход цикла называется итерацией. То есть в примере выше было 6 итераций.

Усложним цикл и выведем квадраты чисел от 0 до 8:

#include <stdio.h>
int main(void)
{
	for (int i = 0; i < 9; i++)
	{
		printf("%d * %d = %d n", i, i,  i * i);
	}
	return 0;
}

Здесь блок цикла сработает 9 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.

0 * 0 = 0
1 * 1 = 1
2 * 2 = 4
3 * 3 = 9
4 * 4 = 16
5 * 5 = 25
6 * 6 = 36
7 * 7 = 49
8 * 8 = 64

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

int i = 1;
for ( ; i < 9 ; )
{
	printf("%d * %d = %d n", i, i,  i * i);
	i++;
}

Формально определение цикла осталось тем же, только теперь первое и третье выражения в определении цикла отсутствуют:
for (; i < 9;). Переменная-счетчик определена и инициализирована вне цикла, а ее приращение происходит в самом цикле.

Можно определять вложенные циклы. Например, выведем таблицу умножения:

#include <stdio.h>
int main(void)
{
	for (int i=1; i < 10; i++)
	{
		for(int j = 1; j < 10; j++)
		{
			printf("%d t", i * j);
		}
		printf("n");
	}
	return 0;
}

Цикл do..while

В цикле do..while сначала выполняется код цикла, а потом происходит проверка условия в инструкции while.
И пока это условие истинно, то есть не равно 0, то цикл повторяется.

do
{
	// действия цикла
}
while (условие);

Например:

#include <stdio.h>
int main(void)
{
	int i = 6;
	do
	{
		printf("%d", i);
		i--;
	}
	while (i > 0);
	return 0;
}

Здесь код цикла сработает 6 раз, пока i не станет равным нулю. Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий, даже если перед первым выполнением
условие в инструкции while не будет истинно. То есть мы можем написать:

int i = -1;
do
{
	printf("%d", i);
	i--;
}
while (i > 0);

Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.

Цикл while

В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то есть не равно 0, то код цикла выполняется:

while(условие){
	// выполняемые инструкции, если условие истинно
}

Например, выведем на консоль все числа от 6 до 1:

#include <stdio.h>
int main(void)
{
	int i = 6;
	while (i > 0)
	{
		printf("%d n", i);
		i--;
	}
	return 0;
}

Здесь, пока истинно условие i > 0, будут выполняться действия цикла — printf("%d n", i) и i--

Операторы continue и break

Иногда возникает необходимость выйти из цикла до его завершения. В этом случае можно воспользоваться оператором
break. Например:

int i = 1;
for ( ; ; )
{
	printf("%d * %d = %d n", i, i,  i * i);
	i++;
	if (i > 5) break;
}

Здесь когда значение переменной i достигнет 5, осуществляется выход из цикла с помощью оператора break.

В отличие от оператора break, оператор continue производит переход к следующей итерации. Например, нам надо посчитать сумму только нечетных чисел из некоторого диапазона:

#include <stdio.h>
int main(void)
{
	int result = 0;
	for (int i=0; i<10; i++)
	{
		if (i % 2 == 0) continue;
		result +=i;
	}
	printf("result = %d", result);	// 25
	return 0;
}

Чтобы узнать, четное ли число, мы получаем остаток от целочисленного деления на 2, и если он равен 0, то с помощью оператора continue переходим к следующей итерации цикла.
А если число нечетное, то складываем его с остальными нечетными числами.

Введение. Циклы с предусловием.

При решении практических задач постоянно возникает необходимость в повторении действия заданное количество раз, или до достижения какого-либо условия. Например, вывести список всех пользователей, замостить плоскость текстурой, провести вычисления над каждым элементом массива данных и т.п.
В си для этих целей используются три вида циклов: с предусловием, постусловием и цикл for со счётчиком (хотя, это условное название, потому что счётчика может и не быть).

Любой цикл состоит из тела и проверки условия, при котором этот цикл должен быть прекращён. Тело цикла — это тот набор инструкций, который необходимо повторять. Каждое повторение цикла называют итерацией.

Рассмотрим цикл с предусловием.

int i = 0;

while (i < 10) {
	printf("%dn", i);
	i++;
}

Этот цикл выполняется до тех пор, пока истинно условие, заданное после ключевого слова while.
Тело цикла — это две строки, одна выводит число, вторая изменяет его.
Очевидно, что этот цикл будет выполнен 10 раз и выведет на экран
0
1
2
3
и так далее до 9.

Очень важно, чтобы условие выхода из цикла когда-нибудь выполнилось, иначе произойдёт зацикливание, и программа не завершится.
К примеру

int i = 0;

while (i < 10) {
	printf("%dn", i);
}

В этом цикле не изменяется переменная i, которая служит для определения условия останова, поэтому цикл не завершится.

int i = 0;

while (i > 0) {
	printf("%dn", i);
	i++;
}

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

int i;

while (i < 10) {
	printf("%dn", i);
	i++;
}

У этого примера неопределённое поведение. Так как переменная i заранее не инициализирована, то она хранит мусор, заранее неизвестное значение. При различном содержимом переменной i будет меняться поведение.

Если тело цикла while содержит один оператор, то фигурные скобки можно опустить.

int i = 0;

while (i < 10)
	printf("%dn", i++);

Здесь мы инкрементируем переменную i при вызове функции printf.
Следует избегать такого стиля кодирования. Отсутствие фигурных скобок, особенно в начале обучения, может приводить к ошибкам. Кроме того, код читается хуже, да и лишние скобки не сильно раздувают листинги.

Циклы с постусловием.

Цикл с постусловием отличается от цикла while тем, что условие в нём проверяется после выполнения цикла, то есть этот цикл будет повторён как минимум один раз (в отличие от цикла while, который может вообще не выполняться). Синтаксис цикла

do {
	тело цикла
} while(условие);

Предыдущий пример с использованием цикла do будет выглядеть как

int i = 0;

do {
	printf("%dn", i);
	i++;
} while(i < 10);

Давайте рассмотрим пример использования цикла с постусловием и предусловием. Пусть нам необходимо проинтегрировать функцию.

b

f
⁡

x

d
x

Интеграл — это сумма бесконечно малых. Мы можем представить интеграл как сумму, а бесконечно малые значения просто заменить маленькими значениями.

∫
a

b

f
⁡

x

d
x

=

∑

i
=
a

b

f
⁡

i

h

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

Пусть искомой функцией будет

x
2

.
Нам понадобятся следующие переменные. Во-первых, аккумулятор sum для хранения интеграла. Во-вторых, левая и правая границы a и b, в третьих — шаг h. Также нам понадобится текущее значение аргумента функции x.

Для нахождения интеграла необходимо пройти от a до b с некоторым шагом h, и прибавлять к сумме площадь прямоугольника со сторонами f(x) и h.

#include<conio.h>
#include<stdio.h>

int main() {
	double sum = 0.0;
	double a = 0.0;
	double b = 1.0;
	double h = 0.01;
	double x = a;
	
	while (x < b) {
		sum += x*x * h;
		x += h;
	}
	
	printf("%.3f", sum);
	getch();
}

Программа выводит 0.328.

Решение

∫
0

1

x
2

d
x

=

x
3

3

|
0

1

=

1

3

≈
0.333

Если посмотреть на график, то видно, что каждый раз мы находим значение функции в левой точке. Поэтому такой метод численного интегрирования называют методом левых прямоугольников. Аналогично, можно взять правое значение. Тогда это будет метод правых прямоугольников.

while (x < b) {
	x += h;
	sum += x*x * h;
}

Сумма в этом случае будет равна 0.338. Метод левых и правых прямоугольников не очень точен. Мы фактически аппроксимировали (приблизили) гладкий график монотонно возрастающей функции гистограммой.
Если немного подумать, то аппроксимацию можно проводить не только суммируя прямоугольники, но и суммируя трапеции.

Приближение с помощью трапеций на самом деле является кусочной аппроксимацией кривыми первого порядка (ax+b). Мы соединяем точки на графике с помощью отрезков. Можно усложнить,
соединяя точки не отрезками, а кусками параболы, тогда это будет метод Симпсона. Если ещё усложнить, то придём к сплайн интерполяции, но это уже другой, очень долгий разговор.

Вернёмся к нашим баранам. Рассмотрим 4 цикла.

int i = 0;
while ( i++ < 3 ) {
	printf("%d ", i);
}

int i = 0;
while ( ++i < 3 ) {
	printf("%d ", i);
}

int i = 0;
do {
	printf("%d ", i);
} while(i++ < 3);

int i = 0;
do {
	printf("%d ", i);
} while(++i < 3);

Если выполнить эти примеры, то будет видно, что циклы выполняются от двух, до четырёх раз. На это стоит обратить внимание, потому что неверное изменение счётчика цикла часто приводит к ошибкам.

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

Давайте решим простую задачу. Пользователь вводит числа до тех пор, пока не будет введено число 0, после этого выводит самое большое из введённых.
Здесь есть одна загвоздка. Сколько чисел введёт пользователь не известно. Поэтому мы создадим бесконечный цикл, а выходить из него будем с помощью оператора break. Внутри цикла мы будем получать от пользователя данные и выбирать максимальное число.

#include<conio.h>
#include<stdio.h>

int main() {
	int num = 0;
	int max = num;
	
	printf("To quit, enter 0n");
	/*бесконечный цикл*/
	while (1) {
		printf("Please, enter number: ");
		scanf("%d", &num);
		/*условие выхода из цикла*/
		if (num == 0) {
			break;
		}
		if (num > max) {
			max = num;
		}
	}
	
	printf("max number was %d", max);
	getch();
}

Напомню, что в си нет специального булевого типа. Вместо него используются числа. Ноль — это ложь, все остальные значения – это истина.
Цикл while(1) будет выполняться бесконечно. Единственной точкой выхода из него является условие

if (num == 0)

В этом случае мы выходим из цикла с помощью break;
Для начала в качестве максимального задаём 0. Пользователь вводит число, после чего мы проверяем, ноль это или нет. Если это не ноль, то сравниваем его с текущим максимальным.

Бесконечные циклы используются достаточно часто, так как не всегда заранее известны входные данные, либо они могут меняться во время работы программы.

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

#include<conio.h>
#include<stdio.h>

int main() {
	int i = 0;
	int positiveCnt = 0;
	float sum = 0.0f;
	float input;

	printf("Enter 10 numbersn");
	while (i < 10) {
		i++;
		printf("%2d: ", i);
		scanf("%f", &input);

		if (input <= 0.0) {
			continue;
		}

		sum += input;
		positiveCnt++;
	}

	printf("Sum of %d positive numbers = %f", positiveCnt, sum);
	getch();
}

Пример кажется несколько притянутым за уши, хотя в общем он отражает смысл оператора continue. В этом примере переменная positiveCnt является счётчиком положительных чисел, sum сумма, а input — временная переменная для ввода чисел.

Вот ещё один пример. Необходимо, чтобы пользователь ввёл целое число больше нуля и меньше 100. Пока необходимое число не будет введено, программа будет продолжать опрос.

do {
	printf("Please, enter number: ");
	scanf("%d", &n);
	if (n < 0 || n>100) {
		printf("bad number, try againn");
		continue;
	} else {
		break;
	}
} while (1);

Одним из самых используемых является цикл со счётчиком for. Его синтаксис

for (<инициализация>; <условие продолжения>; <изменение счётчика>){
	<тело цикла>
}

Например, выведем квадраты первых ста чисел.

int i;
for (i = 1; i < 101; i++) {
	printf("%d ", i*i);
}

Одним из замечательных моментов цикла for является то, что он может работать не только с целыми числами.

float num;
for (num = 5.3f; num > 0f; num -= 0.2) {
	printf("%.2f ", num);
}

Этот цикл выведет числа от 5.3 до 0.1.
Цикл for может не иметь некоторых «блоков» кода, например, может отсутствовать инициализация, проверка (тогда цикл становится бесконечным) или изменение счётчика.
Вот пример с интегралом, реализованный с применением счётчика for

#include<conio.h>
#include<stdio.h>

int main() {
	double sum = 0.0;
	double a = 0.0;
	double b = 1.0;
	double h = 0.01;
	double x;
	
	for (x = a; x < b; x += h) {
		sum += x*x * h;
	}
	
	printf("%.3f", sum);
	getch();
}

Давайте рассмотрим кусок кода

double x ;

for (x = a; x < b; x += h) {
	sum += x*x * h;
}

Его можно изменить так

double x = a;

for (; x < b; x+=h) {
	sum += x*x*h;
}

Более того, используя оператор break, можно убрать условие и написать

double x;
for (x = a;; x += h){
	if (x>b){
		break;
	}
	sum += x*x*h;
}

или так

double x = a;
for (;;){
	if (x > b){
		break;
	}
	sum += x*x*h;
	x += h;
}

кроме того, используя оператор «,», можно часть действий перенести

double x ;
for (x = a; x < b; x += h, sum += x*x*h) ;

ЗАМЕЧАНИЕ: несмотря на то, что так можно делать, пожалуйста, не делайте так! Это ухудшает читаемость кода и приводит к трудноуловимым ошибкам.

Давайте решим какую-нибудь практическую задачу посложнее.
Пусть у нас имеется функция f(x). Найдём максимум её производной на отрезке.
Как найти производную функции численно? Очевидно, по определению). Производная функции в точке — это тангенс угла наклона касательной.

x

′

=

d
x

d
y

Возьмём точку на кривой с координатами (x; f(x)), сдвинемся на шаг h вперёд, получим точку (x+h, f(x+h)), тогда производная будет

d
x

d
y

=

f
⁡
(
x
+
h
)
—
f
⁡

x

(
x
+
h
—
x
)

=
tg
⁡
α

То есть, отношение малого приращения функции к малому приращению аргумента.
Внимательный читатель может задать вопрос, почему мы двигаемся вперёд по функции, а не назад. Ну пойдёмте назад

d
x

d
y

=

f
⁡

x

—
f
⁡
(
x
—
h
)

h

=
tg
⁡
β

Возьмём среднее от этих двух значений, получим

f
⁡
(
x
+
h
)
—
f
⁡
(
x
—
h
)

2h

В общем-то теперь задача становится тривиальной: идём от точки a до точки b и находим минимальное значение производной, а также точку, в которой производная принимает это значение.
Для решения нам понадобятся, как и в задаче с интегралом, переменные для границ области поиска a и b, текущее значение x и шаг h.
Кроме того, необходимо максимальное значение maxVal и координата maxX этого максимального значения.
Для работы возьмём функцию

x
•
sin
⁡
x

#include<conio.h>
#include<math.h>
#include<stdio.h>

int main() {
	double a      = 0;
	double b      = 3.0;
	double h      = 0.001;
	double h2     = h * 2.0;
	double maxVal = a*sin(a);
	double maxX   = a;
	double curVal;
	double x;

	// Проходим по всей области от a до b
	// и ищем максимум первой производной
	// Используем функцию x*sin(x)
	for (x = a; x < b; x += h) {
		curVal = ( (x+h)*sin(x+h)-(x-h)*sin(x-h) )/h2;
		if (curVal > maxVal) {
			maxVal = curVal;
			maxX = x;
		}
	}

	printf("max value = %.3f at %.3f", maxVal, maxX);
	getch();
}

На выходе программа выдаёт
max value = 1.391 at 1.077

Численное решение даёт такие же (с точностью до погрешности) результаты, что и наша программа.

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

Рассмотрим пример, где циклы вложены друг в друга. Выведем таблицу умножения.

#include<conio.h>
#include<math.h>
#include<stdio.h>

int main() {
	int i, j;

	// Для каждого i
	for (i = 1; i < 11; i++) {
		// Выводим строку из произведения i на j
		for (j = 1; j < 11; j++) {
			printf("%4d", i*j);
		}
		// После чего переходим на новую строку
		printf("n");
	}

	getch();
}

В этом примере в первый цикл по переменной i вложен второй цикл по переменной j. Последовательность действий такая: сначала мы входим в цикл по i, после этого для текущего i 10 раз подряд осуществляется вывод чисел. После этого необходимо перейти на новую строку.
Теперь давайте выведем только элементы под главной диагональю

for (i = 1; i < 11; i++) {
	for (j = 1; j < 11; j++) {
		if (j > i) {
			break;
		}
		printf("%4d", i*j);
	}
	printf("n");
}

Как вы видите, оператор break позволяет выйти только из текущего цикла. Этот пример может быть переписан следующим образом

for (i = 1; i < 11; i++) {
	for (j = 1; j <= i; j++) {
		printf("%4d", i*j);
	}
	printf("n");
}

В данном случае мы используем во вложенном цикле счётчик первого цикла.

Q&A

Логические операторы

Циклы используются для многократного повторения кусков кода. Возможность повторения определенных фрагментов кода — это одна из основных и в тоже время важных задач, которые приходится решать программисту. Большинство программ или сайтов используют циклы, например — для вывода новостной информации  или объявлений. То есть в таких задачах необходимо выполнять постоянно операции чтения и записи, и для того чтобы не дублировать один и тот же код на помощь приходят циклы. Циклы достаточно просто объявляются в коде, однако они выполняют сложные задачи, всего лишь простым повторением.

Чтобы приступить к изучению циклов, убедитесь в том, что вы хорошо понимаете концепцию истинных и ложных значений в языке программирования Си. Потому как это будет жизненно необходимо в использовании циклов, ведь в циклах также как и в операторах выбора присутствуют условные выражения. В языке Си существует три типа циклов: for, while, do while. Каждый из них имеет свои конкретные применения. Все они описаны ниже.

Самый часто используемый цикл — это цикл for, его структура показана ниже:

for ( /*инициализация переменной; условие; изменение значения переменной*/ ) {
  // тело цикла (тут находится код который будет повторяться)
}

Инициализация переменной позволяет либо объявить переменную и присвоить ей значение либо присвоить значение уже существующей переменной. Во-вторых, значение этой переменной сообщает программе — истинно или ложно условие цикла. И пока условие цикла — истинно, цикл должен продолжать повторяться. Управляющую переменную обязательно необходимо как-то изменять, иначе цикл будет бесконечный, например можно обновлять её так: i++, i = i + 2 или даже так i = random(5). Обратите внимание, что каждую секцию в заголовке цикла, отделяет точка с запятой , что очень важно. Также отметим, что каждый из разделов может быть пустым, хотя точки с запятой все еще должны быть там. Если условие не пустое, то оно оценивается как истинное и цикл будет выполняться до тех пор, пока что-то не сделает условие цикла — ложным. Давайте рассмотрим простой пример использования цикла for.

#include <stdio.h>

int main()
{
    int i;
    /* Цикл будет работать до тех пор, пока i < 10, при этом после каждой итерации переменная i будет инкрементироваться(увеличиваться на 1)*/
    for ( i = 0; i < 10; i++ ) {
        /* Имейте ввиду что условие проверяется перед каждым повторением, 
            то есть работа цикла остановится когда переменная i будет равна 10*/   
        printf( "%dn", i );
    }
    getchar();
}

Собственно, результат работы программы:

Эта программа представляет собой очень простой пример использования цикла. переменной i присваивается ноль, и пока i меньше 10 на экран печатается значения переменной i, после этого к переменной i прибавляется единица и все снова повторяется до тех пор, пока условие не станет ложным. Имейте в виду, что значение переменной i увеличивается после выполнения кода в теле цикла запускается в первый раз.

Цикл while — очень простой цикл, вот его структура:

while ( /*условие*/ )
{
   // тело цикл - тут находится код, который необходимо повторять
}

Тело цикла начинает выполняться, если условие цикла — истинно. Условие представляет собой логическое выражение, например х == 1 или х! = 7 (х не равно 7). То есть условие может быть абсолютно любым — любое сочетание логических выражений. Вот пример составного условия — x == 3 || x > 10, это условие будет истинным, если икс будет равен трем или икс будет больше 10. Обратите внимание, что while имеет раздела инициализации или раздела изменения управляемой переменной, поэтому перед использованием этого цикла, сначала необходимо объявить переменную, которая будет проверяться в условии цикла и в теле цикла изменять значение этой переменной. Собственно, давайте рассмотрим простой пример с использованием цикла while:

#include <stdio.h>

int main()
{
  int var = 0;  /* обязательно сначала объявляем переменную */

  while ( var < 10 ) { /* пока значение переменной var меньше 10 */
      printf( "%dn", var );
      var++;             /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет - бесконечным) */
  }
  getchar();
}

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

Есть еще один тип циклов — do while. Этот цикл полезен, когда необходимо выполнить код по крайней мере — 1 раз. Рассмотрим его структуру:

do {
   // тело цикла
} while ( /*условие*/ );

Структура очень простая, как видите условие находится в конце цикла ,соответственно и проверка условия будет выполняться после того, как выполнятся код в теле цикла. Обратите внимание, что условие проверяется в конце цикла, а не в начале, так что блок кода в теле цикла будет выполнен по крайней мере один раз. Если условие истинно, цикл прыгает обратно в начало и снова выполняет его. Цикл do while почти ничем не отличается от цикла while, за исключением того, что тело цикла гарантированно выполняется хотя бы один раз. Цикл while сначала проверяет условие, а потом выполняет блок кода в теле, конечно же, если условие — истинно, В то время как do while сначала выполняет код в теле цикла, а затем проверяет условие, и если оно — истинное, то он продолжает работать. Пример работы цикла do while показан ниже:

#include <stdio.h>

int main()
{
  int i = 0;

  do {
    /* Напечатает сообщение и завершит работу*/
      printf( "Привет! Я цикл do whilen" );
  } while ( i != 0 );
  getchar();
}

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

Операторы break и continue

Эти два ключевых слова очень важны для циклов, они могут управлять повторениями в цикле. Оператор break делает принудительный выход из цикла, даже когда условие цикла — истинно. Оператор break удобно использовать, когда необходимо выйти из цикла при особых обстоятельствах. Оператор continue нужен если необходимо пропустить какой-то блок кода, но при этом не прекращать работу цикла. Подробно об операторах вы можете прочитать в разделе С++: статья про оператор continue, статья про оператор break.

Цикл for

Популярный в других языках программирования арифметический цикл в языке Си реализуется с помощью цикла for. Он выглядит следующим образом:

for (инициализация; условие продолжения; итератор)
    тело цикла;

Инициализация выполняется один раз перед первой проверкой условия продолжения и первым выполнением тела цикла. Условие продолжения проверяется перед каждым выполнением тела цикла. Если условие истинно, то выполняется тело цикла, иначе цикл завершается. Итератор выполняется после каждого выполнения тела цикла (перед следующей проверкой условия продолжения).

Поскольку условие продолжения проверяется перед выполнением тела цикла, цикл for является, подобно циклу while, циклом с предусловием. Если условие продолжения не выполняется изначально, то тело цикла не выполняется ни разу, а это хорошо как с точки зрения надежности программы, так и с точки зрения простоты и эстетики (поскольку не нужно отдельно рассматривать исключительные случаи).

Рассмотрим пример суммирования массива с использованием цикла for:

double a[100]; // Массив a содержит не более 100 эл-тов
int n;         // Реальная длина массива a (n <= 100)
double sum;    // Переменная для суммы эл-тов массива
int i;         // Переменная цикла
. . .
sum = 0.0;
for (i = 0; i < n; ++i) {
    sum += a[i]; // Увеличиваем сумму на a[i]
}

Здесь целочисленная переменная i используется в качестве переменной цикла. В операторе инициализации переменной i присваивается значение 0. Условием продолжения цикла является условие i<n. Итератор ++i увеличивает переменную i на единицу. Таким образом, переменная i последовательно принимает значения 0, 1, 2,…, n-1. Для каждого значения i выполняется тело цикла.

В большинстве других языков программирования арифметический цикл жестко связан с использованием переменной цикла, которая должна принимать значения из арифметической прогрессии. В Си это не так, здесь инициализация, условие продолжения и итератор могут быть произвольными выражениями, что обеспечивает гораздо большую гибкость программы. Конструкцию цикла for можно реализовать с помощью цикла while:

for (инициализация; условие; итератор;)
{
    тело цикла;             
}

инициализация;
while (условие) {
    тело цикла;
}

Например, фрагмент с суммированием массива реализуется с использованием цикла while следующим образом:

for (i=0; i < n; ++i)
{
    sum += a[i];  
}

i = 0;
while (i < n) {
    sum += a[i];
   ++i;
}

В принципе, конструкция цикла for не нужна: она реализуется с помощью цикла while, он проще и понятнее. Однако большинство программистов продолжают использовать цикл for. Связано это, скорее всего, с традицией и привычками, поскольку в более ранних языках программирования, например, в первых версиях Фортрана, арифметический цикл был основным, а цикл while приходилось реализовывать с помощью операторов if и goto.

Операция «запятая» и цикл for

В цикле for

for (инициализация; условие продолжения; итератор)
    тело цикла;

в качестве инициализации и итератора можно использовать любые выражения, в частности, операцию присваивания = и операцию увеличения значения переменной на единицу ++. Как быть, если необходимо выполнить несколько действий при инициализации или в итераторе? Можно, конечно, использовать цикл while, но любители цикла for поступают другим образом. Для этого язык Си предоставляет операцию » запятая «, которая позволяет объединить несколько выражений в одно. У операции » запятая » два аргумента, которые вычисляются последовательно слева направо. Результатом операции является последнее вычисленное, т.е. правое, значение. Пример:

int x, y, z;
x = 5;
z = (y = x + 10, ++x);  // y = 15, x = 6, z = 6

Здесь при вычислении выражения в скобках сначала вычисляется первое подвыражение y = x+10, в результате которого в y записывается значение 15, значение первого подвыражения также равно 15. Затем вычисляется стоящее после запятой второе подвыражение ++x, в результате чего значение x увеличивается и становится равным 6, значение второго подвыражения также равно 6. Значением операции » запятая » является значение второго подвыражения, т.е. 6. В результате значение 6 присваивается переменной z.

Наличие операции » запятая » отражает эстетскую сторону первоначального варианта языка Cи 70-х годов XX века: в нем почти любая запись имела какой-то смысл. Позже программисты пришли к пониманию того, что надежность программы важнее краткости и изящества, и приняли более строгий ANSI -стандарт языка Си 1989 г., который несколько ограничил свободу творчества в области Си-программ.

Тем не менее, операцию » запятая » по-прежнему можно использовать в заголовке цикла for, когда нужно выполнить несколько действий при инициализации или в итераторе. Например, фрагмент суммирования массива

sum = 0.0;
for (i = 0; i < n; ++i) {
    sum += a[i];
}

можно переписать следующим «эстетским» образом:

for (sum = 0.0, i = 0; i < n; sum += a[i], ++i);

Здесь тело цикла вообще пустое, все действия вынесены в заголовок цикла! Лучше избегать такого стиля программирования: он ничего не добавляет в смысле эффективности готовой программы, но делает текст менее понятным и, таким образом, увеличивает вероятность ошибок.

Конструкции, которые лучше не использовать

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

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

Цикл do…while

Цикл do…while имеет вид

do
    действие;
while (условие);

Действие лучше всегда обрамлять фигурными скобками, даже когда оно состоит только из одного оператора, например,

do {
    x *= 2;
} while (x < n);

Цикл do…while является циклом с постусловием. Сначала выполняется тело цикла и только после этого проверяется условие продолжения цикла. Если условие истинно, то тело цикла повторяется, и так до бесконечности, пока условие не станет ложным. Таким образом, тело цикла выполняется всегда, даже если условие ложно с самого начала. Это является потенциальным источником ошибок. Лучше всегда использовать цикл с предусловием while (прежде чем прыгнуть, лучше сначала посмотреть, куда прыгаешь!).

Приведем пример ошибочного использования цикла do…while. Пусть переменная n содержит целое положительное число. Надо записать в целочисленную переменную p максимальную степень двойки, не превосходящую n. Ранее этот фрагмент уже был реализован с помощью цикла while (раздел 3.5.5):

int n, p;
. . .
p = 1;
while (2*p <= n) {
    p *= 2;
}

Попытка использовать цикл do…while может привести к ошибке:

int n, p;
. . .
p = 1;
do {
    p *= 2;
} while (2*p <= n);

Программа работает неверно при n = 1 (в переменную p записывается двойка вместо единицы), поскольку тело цикла do…while всегда выполняется один раз независимо от истинности условия, которое проверяется лишь после выполнения тела цикла. Такого рода ошибки в «крайних» ситуациях наиболее опасны в программировании: программа правильно работает почти во всех ситуациях, кроме нескольких исключений. Но известно, что большинство катастроф происходит как раз в результате исключительного стечения обстоятельств!

Оператор switch (вычисляемый goto)

Оператор switch имеет следующий вид:

switch (выражение) {
    case значение_1:
        фрагмент_1;
    case значение_2:
        фрагмент_2;
    case значение_3:
        фрагмент_3;
    . . .
    default:        // Необязательный фрагмент
        фрагмент_N;
}

Выражение должно быть дискретного типа (целое число или указатель). Значения должны быть константами того же типа, что и выражение в заголовке. Оператор switch работает следующим образом:

1. сначала вычисляется значение выражения в заголовке switch ;
2. затем осуществляется переход на метку » case L:», где константа L совпадает с вычисленным значением выражения в заголовке;
3. если такого значения нет среди меток внутри тела switch, то
   • если есть метка » default:», то осуществляется переход на нее;
   • если метка » default:» отсутствует, то ничего не происходит.

Подчеркнем, что после перехода на метку » case L:» текст программы выполняется последовательно. Например, при выполнении фрагмента программы

int n, k;
n = 2;
switch (n) {
    case 1:
        k = 2;
    case 2:
        k = 4;
    case 3:
        k = 8;
}

переменной k будет присвоено значение 8, а не 4. Дело в том, что при переходе на метку » case 2:» будут выполнена сначала строка

и затем строка

что делает приведенный фрагмент совершенно бессмысленным (оптимизирующий компилятор вообще исключит строки » k = 2; » и » k = 4; » из кода готовой программы!). Чтобы исправить этот фрагмент, следует использовать оператор

Так же, как и в случае цикла, оператор break приводит к выходу из фигурных скобок, обрамляющих тело оператора switch. Приведенный фрагмент надо переписать следующим образом:

int n, k;
n = 2;
switch (n) {
    case 1:
        k = 2;
        break;
    case 2:
        k = 4;
        break;
    case 3:
        k = 8;
        break;
}

В результате выполнения этого фрагмента переменной k будет присвоено значение 4. Если бы значение n равнялось 1, то k было бы присвоено значение 2, если n равнялось бы 3, то 8. Если n не равно ни 1, ни 2, ни 3, то ничего не происходит.

Оператор switch иногда совершенно необосновано называют оператором выбора. На самом деле, для выбора следует использовать конструкцию if…else if..., см. раздел 3.5.3. Например, приведенный фрагмент лучше реализовать следующим образом:

if (n == 1) {
    k = 2;
}
else if (n == 2) {
    k = 4;
}
else if (n == 3) {
    k = 8;
}

Оператор switch по сути своей является оператором перехода goto с вычисляемой меткой. Ему присущи многие недостатки goto, например, проблемы с инициализацией локальных переменных при входе в блок. Кроме того, switch не позволяет записывать условия в виде логических выражений, что ограничивает сферу его применения. Рекомендуется никогда не использовать оператор switch: выбор в стиле if…else if... во всех отношениях лучше!

Язык Си. Циклы. Операторы перехода (break, continue, return, goto)

Циклы. Операторы перехода (break, continue, return, goto)

лекция № 4 — циклы for, do_while, while

В языке Си существует 3 вида циклов.

while( проверка условия );

do{}while( проверка условия );

for( ; проверка условия ; ){}

while(); — перед выполнением тела, идет проверка какого-либо условия,результатом проверки которой является — выполнять тело цикла или нет. предусловие.

do{}while();  проверка условия выполняется в конце тела. постусловие

for( ;проверка условия ; ){} — проверка условия выполняется в конце тела. предусловие

Цикл for имеет 3 секции, разделенных с помощью ;.

for( инициализация (выполняется один раз, в начале цикла); 

проверка условия(выполняется каждый раз перед выполнением тела) ;

выполняется каждый раз после выполнения тела).

В инициалицации можно объявлять переменные(счетчики циклов), или инициализировать какие-то глобальные счетчики каким-то стартовым значением.

Телом цикла называется блок {}, внутри которого находятся инструкции, которые нужно выполнять циклично (определенное колличество раз).

Если инструкций больше чем одна, и они разделены ; то тело оборачивается блоком {}, если же инструкция одна то тело в эти скобки можно не оборачивать. Это справедливо для циклов с предусловием.

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

#include <stdio.h>
int main()
{
  int i = 0;
 
  while(i)
    printf("loop 1n");         // блок {} не обязателен, одна инструкция
 
  i = 1;
  while(i < 3)
  {
    printf("loop 2 : %in", i);// блок {} обязателен, больше одной инструкции
    i++;
  }
 
  do
  {
    printf("loop 3 : %in", i);
    i--;
  }while(i);
 
  for(i = 3; i; i--)           
    printf("loop 4 : %in", i); // блок {} не обязателен, одна инструкция
 
  for(int i1 = 0, j1 = 10;
      i1 != j1;
      i1++, j1--)
    printf("loop 5 : %i - %in", i1, j1);
 
  return 0;
}
 

#include <stdio.h>
int main()
{
  while(1)
  {
    // come instructions
  }
  return 0;
}

Также существуют операторы перехода — break, continue, return, goto

break — завершает выполнение цикла.

int main()
{
  int i = 0;
  while(1)
  {
    if(i > 100)
      break;       // завершить цикл
    ++i;
  }
  return 0;
}

int main()
{
  int i = 0;
  while(i != 11)
  {
    if(i > 2)
      continue;
    ++i;
  }
  return 0;
} 

void foo_a(int aCounterStart, int aCounterEnd, int aExtraCondition)
{
  for(int i = aCounterStart; i < aCounterEnd; ++i)
  {
    if(i == aExtraCondition)
      return;
  }
}
 
int foo_b(int aCounterStart, int aCounterEnd, int aExtraCondition)
{
  for(int i = aCounterStart; i < aCounterEnd; ++i)
  {
    if(i == aExtraCondition)
      return -1;
  }
  return 1;
}
 
int main()
{
  foo_a(0, 4, 4);
  foo_b(0, 4, 2);
  return 0;
}
 

#include <stdio.h>
int main()
{
int i = 0;
 
for(i = 0; i < 10; ++i)
  printf("%in", i);
 
printf("----------------------------------------nn");
 
goto init;
 
init:
  i = 0;
  goto check_condition;
 
check_condition:
  if(i < 10)
    goto loop_body;
  else
    goto loop_exit;
 
loop_body:
  printf("%in", i);
  goto end_body;
 
end_body:
  ++i;
  goto check_condition;
 
loop_exit:
  return 0;
}
 

В языке Си, как и в большинстве других языков, существует 3 вида циклов. Каждый из них выполняет одну и ту же роль, но записывается по-разному. Рассмотрим все три цикла.

Цикл For

В цикле for все условия записываются в одном месте, что очень удобно во многих случаях. Стандартная запись такого цикла выглядит следующим образом:

for (int i = 0; i < 10; i++)
	printf("%dn", i);

В объявлении цикла записывается следующее: переменная цикла, её начальное значение и диапазон. В примере выше будут выведены числа от 0 до 10.

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

Цикл While

Суть цикла while не особо отличается от цикла for. Единственное отличие заключается в способе записи цикла. В while необходимо прописать лишь условие, а все остальные параметры записываются вне цикла:

int i = 1; // Создание переменной
while (i <= 10) { // Здесь только условие
	printf("%dn", i);
	i++; // Увеличение переменной
}

Цикл Do While

Цикл схож с циклом while по форме написания, но при этом работает немного по-другому. Цикл do..while будет выполнен один раз сто процентов, а дальше проверит условие и если оно верно, то цикл будет выполняться дальше:

int x = 13;
do {
	x--;
	printf("%dn", i);
} while (x > 10);

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

Операторы для работы в циклах

Существует два основных оператора для работы в циклах:

• Оператор break — служит для выхода из цикла полностью;
• Оператор continue — пропускает лишь одну итерацию и не выходит из цикла.