Цикл с предусловием выполняется так. Оператор цикла с предусловием

Теги: Си циклы. C loops. Цикл с постусловием. Цикл с предусловием. Цикл со сщётчиком. while. do while. for. break. continue

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

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

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

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

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

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

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

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

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

Int i = 0; while (i > 0) { printf("%d\n", i); i++; }

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

Int i; while (i < 10) { printf("%d\n", i); i++; }

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

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

Int i = 0; while (i < 10) printf("%d\n", i++);

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

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

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

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

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

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

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

Рис. 1 Численное интегрирование функции ∫ a b f ⁡ x d x

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

∫ a b f ⁡ x d x = ∑ i = a b f ⁡ i h

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

левых прямоугольников" src="/images/c_loop_rectangles_left.png" alt="Численное интегрирование функции методом
левых прямоугольников"> Рис. 2 Численное интегрирование функции методом
левых прямоугольников

Пусть искомой функцией будет 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 < b) { x += h; sum += x*x * h; } правых прямоугольников" src="/images/c_loop_rectangles_right.png" alt="Численное интегрирование функции методом
правых прямоугольников"> Рис. 3 Численное интегрирование функции методом
правых прямоугольников

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

трапеций" src="/images/c_loop_integral_trapezium.png" alt="Численное интегрирование функции методом
трапеций"> Рис. 4 Численное интегрирование функции методом
трапеций

Приближение с помощью трапеций на самом деле является кусочной аппроксимацией кривыми первого порядка (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 #include int main() { int num = 0; int max = num; printf("To quit, enter 0\n"); /*бесконечный цикл*/ 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 #include int main() { int i = 0; int positiveCnt = 0; float sum = 0.0f; float input; printf("Enter 10 numbers\n"); 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 again\n"); continue; } else { break; } } while (1);

Цикл for

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

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

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

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

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

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

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

#include #include #include 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"); }

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

Ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 [email protected] Stepan Sypachev students

Всё ещё не понятно? – пиши вопросы на ящик

В чем сложность?: Заранее не определено и неизвестно, сколько цифр нужно убрать, т.е. сколько шагов необходимо сделать.
Как выполнить: Надо перестать отделять цифры, когда n = 0 , т.е. надо выполнять пока n > 0

Решение примера на Паскале:


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

Блок-схема, соответствующая циклу while в Паскале:

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

• Здесь оператор, стоящий после служебного слова do , образует тело цикла и будет выполняться, пока значение "условия" равно true (истина).
• Если операторов должно быть несколько, тогда необходимо применять .
• Условие пересчитывается каждый раз при входе в цикл.
• Непосредственно условием цикла while может быть переменная или .
• Операторы тела цикла while выполнятся только в том случае, если условие будет истинно, если условие ложно — они игнорируются, и программа продолжается с тех операторов, которые стоят уже после конструкции. Таким образом, это существенное отличие цикла с предусловием от .

Рассмотрим использование цикла while в Паскале на решенном примере:

Пример: Печатать «ноль» указанное количество раз

Показать решение:

1 2 3 4 5 6 7 8 9 10

var i, n: integer ; begin write ("kolichestvo znakov" ) ; readln (n) ; i: = 1 ; while i<= n do begin {составной оператор} write (0 ) ; i: = i+ 1 end ; end .

var i,n:integer; begin write ("kolichestvo znakov"); readln(n); i:=1; while i<=n do begin {составной оператор} write(0); i:=i+1 end; end.

Задача 3. Ввести целое число и найти сумму его цифр.
Пример: Введите целое число: 1234 Сумма цифр числа 1234 равна 10.

Можно использовать сложные условия:

Задача 4. Вычислять с использованием цикла while квадратные корни из чисел 900, 893, 886, 879 и т.д. до тех пор, пока это можно делать.

Детальный разбор работы цикла While в Паскале рассмотрен в видеоуроке:

Пример:

которые по модулю больше 0,001 :

Алгоритм:

Задача 5: Вычислить сумму элементов следующей последовательности с точностью 0,001 :

Результат: S = 1.157

Вложенные циклы в Паскале

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

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

Рассмотрим пример:

Пример: Вывести таблицу умножения, используя вложенные циклы в паскале.

Показать решение:

const n = 9; {размер таблицы} var i, j:integer; begin for i:=1 to n do {номера строк} begin for j:=1 to n do {номера столбцов} write(i*j:4); writeln; {переход на новую строку} end; end.

Произведение в Паскале

Точно также, как существует для сложения, для умножения в паскале тоже существует специальная конструкция:

Произведение вычисляется по рекуррентному выражению:

где P – промежуточные произведения

Y — сомножители

Рассмотрим пример вычисления факториала числа в Паскале с использованием цикла while .

Пример цикла While в Паскале для вычисления факториала 10! (10!=1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 )

1 2 3 4 5 6 7 8 9 10 11 12

var fact, n : integer ; begin fact : = 1 ; {начальное значение факториала =0! } n : = 1 ; {начальное значение для условия } while n<= 10 do {условие } begin {начало тела конструкции с составным оператором } fact : = fact* n; {вычисление факториала n! } n : = n + 1 {n должно меняться в теле конструкции} end ; {конец тела цикла } writeln (’10 != ’, fact) ; {вывод результата расчета } end .

var fact, n: integer; begin fact:= 1; {начальное значение факториала =0! } n:= 1; {начальное значение для условия } while n<=10 do {условие } begin {начало тела конструкции с составным оператором } fact:= fact*n; {вычисление факториала n! } n:= n + 1 {n должно меняться в теле конструкции} end; {конец тела цикла } writeln(’10!= ’,fact); {вывод результата расчета } end.

Здесь необходимо обратить внимание на то, что присваивание n:= 1 стоит до цикла, если этого не сделать, то условие будет работать некорректно, так как переменная n будет пуста.

Программа возведения в степень числа в Паскале

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

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

Таким образом, возведение числа n в степень d можно выразить так:
n d = n 1 * n 2 * n 3 * … * n d , где нижние индексы просто указывают очередное по счету число n .

Еще необходимо учесть следующее:

• число в нулевой степени равняется 1
• если показатель степени отрицателен, т.е. d n d = 1 / (n 1 * n 2 * n 3 * … * n d)

Т.е., решая программу на Паскале, учитываем:

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

Задача 6. Вычислить в Паскале степень числа, используя цикл while .

Тема 4

Операторы цикла

Назначение операторов цикла

Линейные алгоритмы и алгоритмы с ветвлениями не позволяют во многих случаях эффективно использовать одну из главных составляющих производительности компьютера – его быстродействие (до 10 9 операций в секунду и более). Для этого необходимы программы, в которых отдельные фрагменты выполняются многократно. Одним из наиболее простых средств организации повторного выполнения серии команд являются циклы .

Многие явления природы, алгоритмы человеческой деятельности (в частности, вычислительные алгоритмы) цикличны по своей сути.

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

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

1. Циклы с предусловием (пока – while );

2. Циклы с параметром (для – to/downto );

3. Циклы с постусловием (до – repeat/until ).

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

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

Цикл – "пока" используют в том случае, когда необходимо, чтобы вначале проверялось некоторое условие, а затем, если условие истинно, выполнялись некоторые действия. В процессе выполнения этих действий происходит изменение значений переменных, входящих в указанное условие в качестве операндов. Поэтому при многократном выполнении цикла происходит изменение значения логического выражения-условия с TRUE на FALSE . В этом случае выполнение цикла заканчивается, и выполняется первый оператор, стоящий после оператора цикла. Если при записи условия или операторов, выполняемых в цикле, была допущена ошибка, то в такой ситуации возможно зацикливание – значение логического выражения никогда не станет FALSE и, как следствие, группа операторов в цикле будет выполняться "вечно".

Цикл – "пока" служит для организации многократного выполнения группы операторов (тела цикла) до тех пор, пока остается истинным условие выполнения цикла. Цикл с предусловием имеет следующий формат:

while <условие> do

<оператор>;

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

Выполняется этот цикл следующим образом. Вычисляется значение выражения-условия. Если оно истинно (принимает значение TRUE ), то выполняется тело цикла. В противном случае выполняется оператор, стоящий после оператора цикла "пока" (т.е. тело цикла выполняется до тех пор, пока значение условия не станет равным FALSE ).

Замечания :

1. В качестве тела цикла может быть использован любой оператор, в том числе и составной. Это дает возможность циклически повторять не одно, а несколько действий. В этом случае конструкция цикла "пока" приобретает вид:

while <условие> do

<оператор_1>;

<оператор_n>;

2. Если <условие> в операторе while имеет значение FALSE уже при первой проверке, то тело цикла не выполняется ни разу.

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

Когда в алгоритме некоторое действие нужно выполнить несколько раз, используются циклы. В программирование цикл - это многократное повторение определенных инструкций. Циклы состоят из заголовка и тела. Заголовок содержит в себе условия, которые определяют работу цикла, а тело – повторяющиеся действия. В ЯП Pascal есть три вида циклов:

цикл с параметром;

цикл с предусловием;

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

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

For - цикл с параметром

Цикл с параметром, известный также как цикл со счетчиком, используется при известном количестве повторений. Он имеет две формы записи:

1. For <счетчик>:=< начальное значение> To <конечное значение> Do <тело цикла>;
2. For <счетчик>:=<начальное значение> Downto <конечное значение> Do <тело цикла>;

Счетчик – это переменная порядкового типа. Начальное и конечное значение должны быть того же типа, что и счетчик. Тело выполняется до тех пор пока условие истинно.

Формы записи, представленные выше, отличаются словами To и Downto . Если Вы используете цикл с To, то значение счетчика с каждым шагом будет увеличиваться на единицу, а если с Downto, то уменьшаться. Из этого следует, что в первом варианте начальное значение не должно превышать конечное, во втором - верно противоположное. В программе ниже, указанное пользователем количество раз, будут выводиться символы.

1 2 3 4 5 6 7 8 9 10

program for_primer; uses crt; var i, x: integer ; begin write (‘X=’ ) ; readln (x) ; for i:= 1 to x do write (#3 , #6 ) ; readkey; end .

Здесь тело цикла не заключено в Begin-End, так как оператор всего один. Но если их будет больше, то операторные скобки обязательны. Стоит также отметить, что счетчик по выходу из цикла не будет иметь определенного значения, но если цикл закончиться раньше положенного, то счетчик сохранит последнее, записанное в него значение.

While – цикл с предусловием

Оператор While – начинает описание цикла с предусловием. Такой вид цикла нужен, в тех алгоритмах, где число повторений неизвестно заранее. В общем виде он выглядит так:

While <выражение> Do <тело цикла>;

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

Пример программы написанный с использованием цикла While:

В данном коде использовался составной оператор Begin-End, так как операторов в теле цикла несколько.

Repeat – цикл с постусловием

Главной особенностью цикла с постусловием (часто встречается название: цикл-ДО) является выполнение его тела минимум один раз. Это связано с тем, что условие записывается в конце и соответственно вначале выполнится тело, а затем провериться условие. Формально он выглядит так:

<тело цикла>

Until <условие>

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

1 2 3 4 5 6 7 8 9 10 11 12

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

Повторяемый блок вычислений называют телом цикла. В теле цикла должно быть обеспеченоизменение значения счетчика , чтобы он мог завершиться. Если тело цикла состоит более, чем из одного оператора, онозаключается в операторные скобки begin ... end;. Однократное выполнение тела цикла называют егошагом .

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

Цикл с предусловием : сначала проверяется условие, затем, в зависимости от того, истинно оно или ложно, либо выполняется тело цикла, либо следует переход к оператору, следующему за телом цикла. После завершения тела цикла управление вновь передается на проверку условия. Естественно, предполагается, что в теле цикла было обеспечено некоторое изменение входящих в условие переменных – в противном случае произойдетзацикливание и программа "зависнет".

Цикл с постусловием : сначала выполняется тело цикла, затем управление передается на проверку условия. В зависимости от истинности или ложности условия, тело цикла выполняется повторно или же происходит переход к оператору, следующему за телом цикла. Всё, сказанное о возможном зацикливании для цикла с предусловием, справедливо и для цикла с постусловием.

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

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

while логическое_выражение do begin

{операторы тела цикла}

Работу цикла можно описать словами: "пока логическое выражение истинно, повторяется тело цикла ".

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

Общая запись цикла с постусловием следующая:

{операторы тела цикла}

until логическое_выражение;

Работает цикл с постусловием следующим образом: "тело цикла повторяется до тех пор, пока логическое выражение не станет истинным ". Обратите внимание, что, в отличие отwhile, циклrepeatв Паскале работает, пока условиеложно . Это отличие подчеркивается использованием ключевого словаuntil("до тех пор, покане ") вместоwhile("до тех пор, пока"). Кроме того, в виде исключения, тело циклаrepeat, даже если оно состоит из нескольких операторов, можноне заключать в операторные скобки.

Довольно часто циклы взаимозаменяемы. Представим, например, что для каждого из значений переменной x=1,2,…,20, нужно выполнить некоторый расчет (математически этот закон измененияxможно записать как
или
). Покажем общий вид цикловwhileиrepeat:

while x<=20 do begin {операторы расчета}

{операторы расчета}

Как видно из листинга, управляющей переменной xв обоих случаях присвоено начальное значение1, оба цикла изменяют значениеxи, соответственно, условие цикла, операторомx:=x+1;, но для циклаrepeatусловие "перевернуто" ("покаxне станет больше20"), а тело не заключено в операторные скобки.

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