Циклы

В прошлом выпуске мы освоили расширения конструкции if...then...else, а именно процедуру goto.

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

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

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

Итак, решение программы очевидно:

  1. Мы читаем в переменную строку.

  2. Десять раз выводим ее на экран.

  3. Завершаем программу.

Все вроде ясно. Читать строку мы будем процедурой Readln, как завершить программу тоже не вопрос. А вот как вывести строку 10 раз? Можно десять раз написать процедуру Writeln. Но это ОЧЕНЬ громоздко и нерационально. Здесь желательно как-нибудь застопорить программу - тот ее кусок, который выводит 10 раз строку, чтобы он повторялся сам. Для этого и используются циклы! Они позволяют "зацикливать программу", то есть заставляют ее повторяться несколько раз - столько, сколько нужно пользователю.

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

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


Цикл FOR

Чтобы продемонстрировать, как работает этот цикл, давайте напишем программу, приведенную выше:

Program Example;
var
I: Byte;
S: String;
begin
Write('Введите сроку: ');
Readln(S);
For I := 1 to 10 do
Writeln(S);
Readln;
end.

Посмотрите внимательно на программу. Видите слово FOR? Это и есть начало цикла. Обясняю его синтаксис:

  1. Цикл начинается словом FOR.

  2. После него идет присваивание какой-нибудь переменной начального значения. Именно начиная с этого значения и будет происходить отсчет.

  3. Далее идет слово TO.

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

  5. В конце заголовка цикла ставиться слово do.

  6. После этого идут все действия, которые должны быть зациклены. Здесь действует тоже правило, что и в конструкции if...then...else - про вложенность. То есть если после слова do должно быть несколько действий, а не одно, то все они заключаются в конструкцию begin ... end; Помните об этом, иначе циклы не будут правильно работать - выполняться будет только первое действие, а остальные будут затронуты только после выполнения цикла.

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

Необходимо написать программу, которая будет увеличивать значение введенной переменной на 10, распечатывая при это каждый свой шаг, т.е. ее вывод должен быть таким (для примера возьмем, что мы ввели число 7):

А+1 = 8;

А+2 = 9;

А+3 = 10;

А+4 = 11;

.............

A+10 = 17

;

Решение я обяснять по шагам не буду (ни к чему это, верно?), а сразу приведу текст программы:

Program Example;
var
A: Integer;
I: Byte;
begin
Write('Введите число: ');
Readln(A);
For I := 1 to 10 do
Writeln( I,' . ',A,' + ',I,' = ',A+I);
Readln;
end.

Обратите внимание на строку Writeln(I,' . ',A, ' + ' ,I, ' = ' ,A+I); - здесь я привожу ее более крупным шрифтом, чтобы было легче разобраться. Она хорошо демонстрирует множественность параметров процедуры Writeln, не так ли? Кроме того, обратите внимание, что я использую процедуру Writeln, а не Write - для того, чтобы переносить строку после каждого вывода. Таким образом строки будут выводиться в столбик.

Заметьте также, что я использую в цикле тип Byte. Дело в том, что Byte занимает меньше памяти, чем Integer или Word, тем самым программа становиться оптимизированнее. Мы ведь заранее знаем, что в цикле значение не перевалит через 10, верно? Зачем же использовать типы, способные хранить значения гораздо большие?

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

For I := 1 to 10 do

Что при этом будет происходит с переменной i?

1. Она будет приравнена к единице;

2. Она будет увеличиваться на единицу с каждым новым началом цикла (это называется итерацией - новый проход;), пока не станет равна 10.

Обратили внимание, она будет увеличиваться? А вот если написать так:

For I := 10 to 1 do

Переменная ведь должна уменьшаться? Судя по значениям - да. Но если так написать в программе, цикл не будет выполнен. Паскаль не выдаст ошибки, программа пойдет на выполнение, но цикл работать не будет. Почему? Просто в цикле For при каждой новой итерации (проходе) Паcкаль увеличивает на 1 переменную и проверяет - она больше заданного конечного значения? Если да, цикл завершен. Вот и здесь - переменная I увеличивается на 1, она теперь равна 11, то есть больше конечного значения (больше 1), цикл завершен. То есть он пуст - работать не будет. Начальное значение сразу же становиться больше конечного.

Однако, иногда необходимо, чтобы переменная в цикле уменьшалась. Например, модифицированный вариант предыдущей программы - уменьшать на 10 значение введенной переменной. Как же поступить? Именно для этих целей и существует расширение синтаксиса цикла FOR, которое позволяет уменьшать значения, то есть задавать "от большего к меньшему".

Для того, чтобы использовать эту возможность, Вам необходимо заменить служебное слово to словом downto, то есть оформление станет таким:

For I := 10 downto 1 do

Просто, верно? Но тем не менее работа цикла совсем меняется. Давайте теперь модифицируем нашу программу, т.е. сделаем, чтобы она уменьшалась на 10. Только уменьшать будем с 10 до 1, а не с 1 до 10, как мы делали ранее. Сделаем еще одно, чтобы усовершенствовать программу: так как мы будет вычитать сразу 10 из введенного числа, не хотелось бы, чтобы оно было меньше 10. Зачем, скажете вы? Пусть будет... Да нет, возьмем это просто как условие, чтобы хоть как-то расширить интерфейс. Итак, мы будем проверять введенное число на больше/меньше нуля, после чего вычитать из него числа от 10 до 1. Пример программы:

Program Example;
label
L1;
var
A: Integer;
I: Byte;
begin
L1:
Write('Введите число: ');
Readln(A);
if A <= 10 then goto L1;
For I := 10 downto 1 do
Writeln(A,' - ',I,' = ',A-I);
Readln;
end.

Вот и все. Разберитесь в этой программе, здесь вам все знакомо.

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

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



Опубликовал admin
16 Ноя, Воскресенье 2003г.



Программирование для чайников.