Цикл фор в си

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

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

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

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

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

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

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

CppStudio.com
0 1 2 3 4 5 6 7 8 9

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

Язык Си для начинающих / #5 — Циклы и операторы в них

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

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

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

#include 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 int main() < int i = 0; do < /* Напечатает сообщение и завершит работу*/ printf( «Привет! Я цикл do whilen» ); >while ( i != 0 ); getchar(); >

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

Цикл do..while

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

do < // действия цикла >while (условие);
#include 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 int main(void) < int i = 6; while (i >0) < printf(«%d n», i); i—; >return 0; >

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

Циклы в Си.

На этом уроке мы познакомимся с циклическими алгоритмами и циклом For в си. Когда нужно выполнить определенные набор команд несколько раз, в Си используются циклы
Когда известно число повторений используется в Си оператор for
for (присваиваем счетчику начальное значение; условие на счетчик; оператор изменения счетчика )
// набор команд, который будет повторяться
>

Цикл for в си будет выполняться до тех пор, пока будет выполняться условие на счетчик.
Часто используется оператор изменения счетчика переменная счётчика ++, он увеличивает переменную счетчика цикла на 1.
Переменная, отвечающая за счетчик цикла, часто называется просто переменной цикла.Ее можно использовать внутри цикла.
Пример программы 9 Программа на си выводит числа от 1 до 20
#include
#include
main()
int i;
for (i=1; i printf («%d «, i);// выводим переменную цикла
>
getch();
>
Вложенные циклы в Си.
В Си один цикл for можно вставлять в другой цикл for.
for (счетчик внешнего цикла; условие на счетчик внешнего цикла; изменение счетчика внешнего цикла)
// внутренний цикл
for (счетчик внутреннего цикла; условие на счетчик внутреннего цикла; изменение счетчика внутреннего цикла)
// набор команд, который будет повторяться
>
>
Пример программы 10. Запрашивается ширина и высота прямоугольника , рисуется прямоугольник заданных размеров с помощью символа *.
В этой программе внешний цикл используется для того чтобы выводились все строки, для отображения каждой строки используется внутренний цикл.
// рисуем прямоугольник из *

#include
#include
int main()
int i,j;// счетчики циклов
int a, b; // размеры прямоугольника
// задаем размеры прямоугольника
printf(«Введите ширинуn «);
scanf(«%d»,
printf(«Введите высоту n»);
scanf(«%d»,
// внешний цикл пробегаем по всем строкам
for (i=1; i // внутренний цикл для каждой строки
for (j=1; j printf («*»);// отображаем * в одну строку
>
// переход на следующую строку
printf(«n»);
>
getch();
>

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

// рисуем треугольник из *
#include
#include
int main()
int i,j;// счетчики циклов
int a, b; // размеры прямоугольника
// задаем размеры прямоугольника
printf(«Введите сторону треугольникаn»);
scanf(«%d»,

// внешний цикл пробегаем по всем строкам
for (i=1; i // внутренний цикл для каждой строки
for (j=1; j printf («*»);// отображаем * в одну строку
>
// переход на следующую строку
printf(«n»);
>
getch();
>

Вернуться к содержанию Перейти к следующему уроку Цикл с условием в Си

Цикл for

Представим синтаксис заголовка цикла for языка программирования C так:

for (часть1; часть2; часть3)

Вот так будет выглядеть программный код, выводящий таблицу символов на экран, в котором используется цикл for :

unsigned char a; for (a = 31; a 128; a++) { if (a % 10 == 0) printf(«n»); printf(«%4d-%c», a, a); } printf(«n»);

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

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

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

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

#define N 10 int arr[N] = {6, 5, -4, 3, -7, 2, 7, 0, 3, 9}; int new_arr[N], i, j; for (i=0; iN; i++) { if (arr[i] == 0) { printf(«nIt contains zero»); break; } // не обязательно printf(«%d «, arr[i]); } printf(«n»);

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

for(i=0, j=0; iN; i++) { if (arr[i] 0) continue; new_arr[j] = arr[i]; printf(«%d «, new_arr[j]); j++; } printf(«n»);

В данном случае использование continue совсем не очевидно с точки зрения надобности, т. к. легко можно обойтись без него, если изменить условие при if на противоположное, удалить continue , а оставшийся код поместить в тело оператора if .

Курс с решением задач:
pdf-версия

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

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

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

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

int i = 0; do < printf(«%dn», i); i++; >while(i < 10);

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

Численное интегрирование функции

∫ a 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 #include 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

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

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

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

int i = 0; while ( i++
int i = 0; while ( ++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 #include int main() < int num = 0; int max = num; printf(«To quit, enter 0n»); /*бесконечный цикл*/ while (1) < printf(«Please, enter number: «); scanf(«%d», /*условие выхода из цикла*/ 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 #include 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», if (input 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», if (n < 0 || n>100) < printf(«bad number, try againn»); continue; >else < break; >> while (1);

Цикл for

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

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

int i; for (i = 1; i

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

float num; for (num = 5.3f; num > 0f; num -= 0.2)

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

#include #include 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

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

double x = a; for (; x

Более того, используя оператор 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). Найдём максимум её производной на отрезке. Как найти производную функции численно? Очевидно, по определению). Производная функции в точке — это тангенс угла наклона касательной.

Численное дифференцирование функции

f 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 α

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

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

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

#include #include #include 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

График производной функции x*sin(x)

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

[edit] Keywords

The expression statement used as loop-statement establishes its own block scope, distinct from the scope of init-clause , unlike in C++:

for (int i = 0; ; ) { long i = 1; // valid C, invalid C++ // . }

It is possible to enter the body of a loop using goto. When entering a loop in this manner, init-clause and cond-expression are not executed. (If control then reaches the end of the loop body, repetition may occur including execution of cond-expression .)

[edit] Example

Run this code
#include #include enum { SIZE = 8 }; int main(void) { int array[SIZE]; for(size_t i = 0 ; i SIZE; ++i) array [i] = rand() % 2; printf(«Array filled!n»); for (size_t i = 0; i SIZE; ++i) printf(«%d «, array[i]); putchar(‘n’); }
Array filled! 1 0 1 1 1 1 0 0

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

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

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

Цикл 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

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

int n, p; . . . p = 1; do < p *= 2; >while (2*p

Программа работает неверно при 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)

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

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

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

    do <
    БлокОпераций;
    > while (Условие);

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

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    #include // для использования функции system()
    int main()
    int num; // объявляем целую переменную для числа
    system( «chcp 1251» ); // переходим на русский язык в консоли
    system( «cls» ); // очищаем экран
    do printf( «Введите число от 0 до 10: » ); // приглашение пользователю
    scanf( «%d» , // ввод числа
    > while ((num 10)); // повторяем цикл пока num 10
    printf( «Вы ввели число %d» , num); // выводим введенное значение num — от 0 до 10
    getchar(); getchar();
    return 0;
    >

    Цикл do. while

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

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

    for (Инициализация; Условие; Модификация)
    БлокОпераций;
    >

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

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

    Эти три операции записываются в скобках и разделяются точкой с запятой ; ;. Как правило, параметром цикла является целочисленная переменная.

    Инициализация параметра осуществляется только один раз — когда цикл for начинает выполняться.

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

    Модификация параметра осуществляется в конце каждого выполнения тела цикла. Параметр может как увеличиваться, так и уменьшаться.

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    #define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
    #include
    int main()
    int k; // объявляем целую переменную key
    int sum = 0; // начальное значение суммы равно 0
    printf( «k = » );
    scanf( «%d» , // вводим значение переменной k
    for ( int i=1; i // цикл для переменной i от 1 до k с шагом 1
    sum = sum + i; // добавляем значение i к сумме
    >
    printf( «sum = %dn» , sum); // вывод значения суммы
    getchar(); getchar();
    return 0;
    >

    Оцените статью
    TutShema
    Добавить комментарий