Циклы в турбо делфи

Чтобы понять, как работает цикл for Delphi, рассмотрим одну задачу. Предположим, что необходимо разработать программу, вычисляющую значение функции y=5*x*x-7 в следующих точках: x=-1, x=-0.5, x=0, x=0.5, x=1 (таблицу выведем в поле метки Label1 формы приложения). Напишем процедуру, которая решит поставленную задачу (представим один из ее вариантов):

Как Вы можете заметить, в тексте данной процедуры группа инструкций

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

А теперь сравним два варианта процедуры:

1. Для создания второго варианта потребовалось меньше усилий в процессе набора;
2. Процедура в втором варианте более гибкая: для увеличения количества строк в отображаемой таблице, к примеру, до 15, остается лишь в строке провести замену числа 5 на число 15.

Применение цикла for Delphi эффективно тогда, когда некоторая последовательность действий выполняется несколько раз (если заранее известно количество повторений). Цикл for Delphi имеет общий вид:

откуда

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

Определить, сколько раз (обозначим это число за m) повторяются инструкции цикла, можно, воспользовавшись следующей формулой:

Примеры цикла for Delphi:

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

Пример 1.

Пример 2.

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

Если внимательно приглядеться к приведенному алгоритму, то можно заметить, что если конечное значение счетчика не превышает его начального значения, то инструкции между служебными словами begin и endвыполняться не будут. Нельзя не отметить, что после того, как завершилось очередное выполнение инструкции тела цикла, увеличение счетчика циклов происходит автоматически. Переменная счетчик может быть использована внутри тела цикла, но менять переменную-счетчик нельзя.

Пример 3. После того, как выполнены следующие инструкции

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

Пример 4. В качестве примера приведем программу, производящую вычисление суммы первых десяти элементов ряда 1+1/2+1/3+1/4+ … +1/n (свяжем значение i-того элемента данного ряда с его номером при помощи формулы 1/i).

Таким образом, в диалоговом коне программы необходимо присутствие как минимум двух компонент: поля меткиLabel1 и командной кнопки Button1. Чтобы вычислить сумму первых десяти членов ряда и вывести полученный результат, воспользуемся процедурой обработки событий Onclick (ее код представление ниже).

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

Заметка. Если необходимо, чтобы значения счетчика не увеличивалось, а уменьшалось, то необходимо в инструкции for слово to заменить на слово downto.

Похожие записи:

• Особенности Delphi
• Константы Delphi
• Ввод из файла Delphi
• Назначение файла Delphi
• Вывод в файл Delphi

Источник

Это логика расчета факториала. Давайте перенесем ее на язык программирова­ния Delphi. Цикл в Delphi оформляется следующим образом:

for счетчик := начальное_значение to конечное_значение do действие;

После слова for нужно присвоить какой-нибудь переменной начальное значе­ние. Эта переменная будет использоваться в качестве счетчика выполнения цикла.

Закажи видеокурс по Delphi прямо сейчас и получи 106 видеоуроков! Кликни сюда:

ЗАКАЗАТЬ

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

for…to…do Действие1

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

Хочешь больше таких видеоуроков – тогда скачай прямо сейчас их бесплатно – СКАЧАТЬ БЕСПЛАТНО.

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

var index:Integer; sum:Integer; EndCount:Integer; begin Sum: =0; for index:=0 to 5 do Sum:=Sum+ index; end;

В этом примере объявляются две переменные index и sum типа “целое число”. Сначала переменной sum присваивается значение 0. После этого запускается цикл, в котором переменная index будет изменяться от 0 до 5. Теперь посмотрим поэтапно, что здесь происходит.

1. На первом этапе переменная index равна 0. sum тоже равна нулю, значит, вы­полнится операция sum:=o+o. Результат sum = о;
2. На втором этапе index увеличена на 1, значит, выполнится действие sum: =о+1. Результат sum = 1.
3. Здесь index увеличена на 1 и уже равна 2, a sum = 1. Значит, выполнится дейст­вие Sum: =1+2. Результат Sum = 3.
4. Здесь index увеличена на 1 и уже равна 3, a sum = 3. Значит, выполнится дейст­вие sum: =3+3. Результат sum = б.
5. Здесь index увеличена на 1 и уже равна 4, a sum = 6. Значит, выполнится дейст­вие Sum: =4 + 6. Результат Sum = 10.
6. Здесь index увеличена на 1 и уже равна 5, a sum = 10. Значит, выполнится дей­ствие Sum: =5+10. Результат sum = 15.

Заметьте, что мы не увеличиваем значение переменной index, используя для этого определенные команды. Значение увеличивается автоматически, потому что эта переменная объявлена счетчиком в цикле for.

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

Компонент Edit1 переименован в EndEdit, a Edit2 переименован в ResuitEdit. Теперь по нажатии кнопки (обработчик события onclick для кнопки, которое генерируется, когда пользователь нажал на кнопке) пишем код, представленный в листинге:

procedure TFontil. CalculateButtonCl ick (Sender: TObj ect) ; var index:Integer; sum: Integer; EndCount:Integer; begin Sum: =0; EndCount:=StrToInt(EndEdit.Text); for index:=0 to EndCount do Sum: = Sum+ index; ResuitEdit.Text:=IntToStr(Sum) ; end;

В принципе, текст тот же самый. Единственная разница заключается в том, что цикл запускается, начиная от 0 до числа, введенного в компонент EndEdit. EndEdit содержит текст, а нам нужно превратить его в число, поэтому мы используем функцию strToint для преобразования строки в число. Эта функция работает так же, как и intTostr, которая наоборот преобразовывала число в строку.

Результат преобразования сохраняется в переменной EndCount:

EndCount := StrToint(EndEdit.Text);

После этого запускается цикл, в котором переменная index будет изменятся от 0 ДО значения EndCount (в котором находится ЧИСЛО, введенное В EndEdit).

for index:=0 to EndCount do

Запустите программу и введите в строку Конечное значение число 5. После этого нажмите на кнопку, и в строке результата должно появиться число 15.

Здесь необходимо еще отметить то, что после цикла for будет выполняться только одно действие. Например, если вы захотите выполнить два действия подряд, то вы должны заключить их в скобки begin и end, как это показано в следующем примере.

for index:=0 to EndCount do begin Sum: = Sum+ Index; Sum: =Sum+1; end;

Здесь на каждом шаге цикла sum увеличивается еще на единицу. Если вы по­пробуете написать так:

for index:=0 to EndCount do Sum: =Sum+Index; Sum:=Sum+1;

то выполняться в цикле будет только строка sum:=sum+index. Вторая строка Sum: =sum+i выполнится только по окончании цикла.

СОВЕТ. Если вы что-то не поняли в предыдущем примере, вернитесь к главе, где описывались блок-схемы. Там был рассмотрен пример, который работает как цикл for.. .to.. .do. Попробуйте точно так же самостоятельно нарисовать блок-схему для данного примера и мысленно пройдите ее по шагам.

Помоги проекту! Расскажи друзьям об этом сайте:

Источник

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

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

Для обработки нескольких элементов массива, программисты очень часто используют циклы. Циклы позволяют совершать ряд однотипных действий или операций. В языке программирования Pascal/Delphi существует всего 3 вида циклов: for, while, repeat. Их работу мы и разберем в следующем примере:

Пусть массив содержит 100 целочисленных переменных integer. Объявление такого массива в разделе var будет выглядеть следующим образом:

[cc lang=»delphi»]var a: array [0..99] of integer;[/cc]

Требуется посчитать кол-во элементов массива, значение которых больше 10.

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

Цикл for:

[cc lang=»delphi»]var i,n:integer;

begin

n:=0;

for i:=0 to 99 do

if a[i]>10 then inc(n);

end;[/cc]

Цикл for использует для своей работы переменную i типа integer. «for i:=0 to 99 do» означает, что в первой итерации цикла (сначала) i присвоится «0», а затем i будет увеличиваться с каждой итерацией цикла на 1 и, когда достигнет 99, после прохождения последней итерации, цикл закончится. Содержимое цикла идет либо после ключевого слова «do» и может указываться между ключевыми словами «begin» и «end». Внутри цикла мы проверяем, является i-ый элемент в массиве a большим 10. Если да, то увеличиваем показатель n на единицу. Перед циклом n нужно обнулить, т.е. присвоить нулю, чтобы счет начинался с нуля. Если необходимо, чтобы итерации в цикле шли в обратном порядке (от 99 до 0), то цикл приобретет следующий вид:

[cc lang=»delphi»]

for i:=99 downto 0 do

if a[i]>10 then inc(n);

end;[/cc]

Цикл While:

[cc lang=»delphi»]n:=0;

i:=0;

while i10 then inc(n);

inc(i);

end;[/cc]

В этом цикле мы вручную увеличиваем счетчик итераций i, и пока iЦикл Repeat:

[cc lang=»delphi»]n:=0;

i:=0;

repeat

if a[i]>10 then inc(n);

inc(i);

until i=99;[/cc]

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

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

[cc lang=»delphi»]

var a: array [0..99] of integer;

i: integer;

begin

randomize; // инициализация генератора чисел

for i:=0 to 99 do begin

a[i]:=random(100); // присваиваем элементу массива случайное целочисленное число (от 0 до 99)

end;

end;

[/cc]

[note]Стоит отметить, что наиболее часто в коде используют цикл for (особенно при обработке массивов), потому что его преимуществом перед другими циклами является то, что в него уже встроен счетчик итераций, что делает код более удобным, освобождая его от лишних «inc(i)», «i:=0″… Особенно это удобно при использовании двойных циклов – да-да, бывают и тройные и четвертные – циклы могут вкладываться в другие циклы, когда нужно обработать сложные структуры.[/note]

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

Циклы в Java

Циклы в С++

Гидра ссылка

Источник

Эх, раз, ещё раз, Ещё много-много раз!

Цыганская песня о циклах

Терпенье и труд всё перетрут.

Пословица

Очень часто в программах встречаются ситуации, когда одни и те же дей­ствия нужно повторить многократно. Для таких случаев в языке Delphiприпасены аж три оператора циклов – for, whileи repeat.

Примеры циклов мы можем найти и в повседневной жизни: вре­мена года (циклически сменяют друг друга весна – лето – осень – зима), время суток (утро – день – вечер – ночь), фазы Луны, враще­ние планет вокруг Солнца и Солнечной системы вокруг центра Га­лактики, спортивные состязания, учебный год, режим дня, дыхание и кровообращение, часы, биоритмы активности человека – можно даже утверждать, что уникальны именно неповторяющиеся собы­тия, а не циклические.

Оператор FOR

Цикл forвстречается в программах чаще других. Его используют, когда число повторений оператора заранее известно.

Цикл forзаписывается в одной из форм:

forпеременная:= начальное значение to конечное значение doоператор; forпеременная:= начальное значение downtoконечное значение doоператор;

Оператор (или составной оператор) называется телом цикла. Число по­вторений (они также называются итерациями) определяется переменной (управляющей переменной, счётчиком цикла, параметром цикла), которая автоматически увеличивается или уменьшается при каждом выполнении тела цикла.

Переменная цикла – это локальная переменная порядкового типа (обыч­но целого). Она не должна изменяться в теле цикла (да вы и не сможете этого сделать – Delphiне позволит!), но её значение может использоваться в выражениях внутри цикла.

Первая форма действует так:

1.Переменной цикла присваивается начальное значение.

2.Текущее значение переменной цикла сравнивается с её конечным значением. Если оно меньше или равно конечному значению, то выполняется тело цикла – оператор(ы). Если больше, то выполнение цикла заканчивается и управление переходит к следующему за структурой forоператору.

3.Если цикл не завершён в п.2, то значение переменной цикла увели­чивается на 1 и цикл возвращается к п.2.

Понятно, что выполнение цикла forрано или поздно закончится. Более то­го, он может вообще не выполняться ни разу, если начальное значение сразу больше конечного, либо будет выполнен только 1 раз, если началь­ное значение равно конечному.

Важно помнить, что после завершения цикла значение переменной цикла не определено, то есть её нельзя использовать в выражениях!

Вторая форма действует аналогично, за исключением того, что в п.3 зна­чение переменной цикла уменьшается на 1. Оператор forс downtoне бу­дет выполнен ни разу, если начальное значение переменной цикла мень­ше конечного.

Рассмотрим простой цикл, считающий до пяти:

procedure 5; var i: integer; begin for i:= 1 to 5 do //^ Заголовок цикла (inttostr(i) ); //^ Тело цикла end;

Здесь i- переменная цикла (их обычно именуют буквами i, j, к, l, m, n).

Начальное значение переменной цикла равно 1, конечное 5.

Таким обра­зом, цикл будет выполнен 5 раз, при этом на экране будут напечатаны числа 1 2 3 4 5

Оператор FOR… IN

В последних версиях Delphiпоявилась новая разновидность оператора цикла For. Оператор For… inперебирает все элементы коллекции – это могут быть символы строки, элементы массивов и записей.

for переменная in коллекция do оператор;

В языке C# подобный оператор называется foreach.

Переменная цикла должна быть объявлена в том же блоке, что и оператор цикла, а её тип должен быть совместим с типом элемен­тов в коллекции.

Изменять значение переменной цикла внутри цикла нельзя!

Установите на форме текстовое поле Edit1, щёлкните по кнопке Button1 и напишите код в методе Button1Click:

procedure TForm2.Button1Click(Sender: TObject); var s: string; ch: char; begin s:= Edit1.Text; for ch in s do ListBox1.Items.Add(ch); end;

Здесь мы считываем строку, которую ввёл пользователь в текстовое поле, в цикле for .inперебираем все символы этой строки и добавляем их в спи­сок

И для этого нам даже не нужно знать длину строки – оператор for…inуме­ет работать самостоятельно!

Очень часто в программах приходится перебирать и элементы массива. Дополним нашу программу целочисленным массивом arr, в который по­местим восемь первых простых чисел:

var Form2: TForm2; arr: array[1..8] of integer = (2,3, 5, 7, 11, 13, 17, 19); implementation {$R *.dfm} procedure TForm2.Button1Click(Sender: TObject); var s: string; ch: char; i: integer; begin s:= Editl.Text; if s <> ‘Editl’ then for ch in s do ListBoxl.Items.Add(ch) else for i in arr do end;

В метод Button1Clickдобавим проверку строки в текстовом поле. Если пользователь не ввёл строку, то мы печатаем элементы массива (Рис. У8.3), в противном случае – строку.

Оператор WHILE

Любовь – кольцо, а у кольца Начала нет и нет конца

Песня о зацикливании

Цикл while называется также циклом с предусловием и имеет следую­щий вид:

while выражение do оператор;

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

Работает он так:

1. Вычисляется логическое выражение.

2. Если оно ложно (значение равно FALSE), то выполнение цикла за­канчивается.

3. Если оно истинно (значение равно TRUE), то выполняется оператор и управление передаётся в п.1.

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

Как мы видим, цикл заканчивается, когда условие станет ложным. А по­чему изменяется значение выражения? – Да потому, что изменились зна­чения переменных, входящих в это условие. И это может произойти только в теле цикла. Отсюда грустный вывод: цикл whileможет вообще никогда не закончиться, и программа зациклится навечно, что очень часто и бы­вает!

Пример 1. Найдём все числа Фибоначчи, которые не больше некоторого заданного числа n.

Результаты вычислений мы будем выводить в список lstProtocol задавать нужное нам число от 2 до 99999 в компоненте speNUM а понуждать программу к этому – с помощью кнопки sbtGo:

Вводим в однострочныйй редактор число и попадаем в процедуру обработки:

procedure TfrmMain.sbtGoClick(Sender: TObject); var n: integer; begin n:= speNum.Value; fibo(n); end; Здесь вызывается процедура, которая и проводит нужные нам расчёты: //РЕШИТЬ ЗАДАЧУ procedure fibo(n: integer); var f,f1,f2: integer; begin f:=0; f1:=1; f2:=1; frmMain.lstProtokol.Clear; while f2 <= n do begin frmMain.lstProtokol.Items.add(inttostr(f2)); f2:= f1 + f; f:=f1; f1:=f2; end; end;

Чтобы понять, как действует в этом примере оператор while, уде­лим немного времени числам Фибоначчи (а эти числа очень инте­ресны!). Нетрудно догадаться, что их открыл Фибоначчи (он же Леонардо Пизанский), средневековый математик, внимательно наблюдавший за размножением кроликов.

Первые два числа равняются 1:

f1:=1; f2:=1;

а все последующие равны сумме двух предыдущих, то есть третье число 1 + 1 = 2, четвёртое 1 + 2= 3, пятое 2 + 3 = 5 и так далее, до бесконечности:

f2:= f1+f; f:=f1; f1:=f2;

А цикл while f2 <= n do только проверяет, не достигло ли очередное число Фибоначчи заданного нами предела.

Исходный код программы находится в папке fibonacci.

Оператор REPEAT

Цикл repeatназывается также циклом с постусловием и имеет следую­щий вид:

repeat оператор untilвыражение;

Выражение (условие выполнения цикла) должно быть логического типа.

Оператор repeatдействует почти так же, как while, но с одним важным отличием: условие продолжение цикла проверяется после выполнения оператора. Это значит, что цикл обязательно будет исполнен по крайней мере 1 раз, даже если логическое выражение истинно с самого начала.

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

Работает оператор repeat так:

1. Выполняется оператор в теле цикла.
2. Вычисляется логическое выражение. Если оно ложно (значение рав­но FALSE), то управление передаётся в п.1. Если оно истинно (значе­ние равно TRUE), то выполнение цикла заканчивается.

Теперь мы можем найти и второе различие циклов whileи repeat: первый заканчивается, когда условие не выполняется (значение выражения ста­новится равным FALSE), второй – когда условие выполняется (значение выражения становится равным TRUE).

Пример 2. Найдём все числа Фибоначчи, которые не больше некоторого заданного числа n.

Внешне («интерфейсно») программа ничем не отличается от первого при­мера, но теперь мы найдём числа Фибоначчи с помощью оператора repeat:

//РЕШИТЬ ЗАДАЧУ procedure fibo(n: integer); var f,f1,f2: integer; begin f:=0; f1:=1; f2:=1; frmMain.lstProtokol.Clear; repeat frmMain.lstProtokol.Items.add(inttostr(f2)); f2:= f1 + f; f:=f1; f1:=f2; until f2 >= n; end;

Легко заметить, что нам пришлось изменить только небольшую часть ко­да: заменить один оператор цикла другим и «инвертировать» условие продолжения цикла. Как говорится, лёгким движением руки whileпре­вращается в элегантный repeat!

Исходный код программы находится в папке fibonacci2.

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

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

for . . . //начало первого цикла begin for . . . //начало второго цикла begin for . . . //начало третьего цикла begin end; //конец третьего цикла end; //конец второго цикла

Как и всегда, отступами выделяйте отдельные циклы! Вложенных циклов может быть любое количество и это могут быть не только циклы for, но и whileи repeatв любых сочетаниях.

Пример. В своё время мне пришлось на городской олимпиаде по матема­тике решать такую задачу: Подсчитать, сколько раз пятёрка входит в представление чисел от 1 до 1000 в виде произведения простых чисел: 2, 3, 5, 7, 11,. (например, 24 = 2 * 2 * 2 * 3; 25 = 5 * 5). Мы не на олимпиаде, по­этому пусть задачу решает компьютер, а мы составим для него простень­кую программу:

//РЕШИТЬ ЗАДАЧУ procedure TfrmMain.sbtGoClick(Sender: TObject); var i, n, n5: integer; begin n5:=0; for i:= 1 to 1000 do begin //проверяем все заданные числа n:= i; while TRUE do begin if n mod 5 = 0 then begin n:= n div 5; inc(n5); end else break; end; end; frmMain.lstProtokol.Items.add(inttostr(n5)); end;

Здесь мы легко найдём цикл for, в котором перебираются все заданные числа, и вложенный в него бесконечный цикл while, который и подсчиты­вает их делители. Если число делится нацело на 5, то увеличиваем счёт­чик на 1, иначе переходим к проверке следующего числа. Олимпиадный «подвох» этой задачи заключается в том, что полученное после деления на 5 число опять может быть кратно 5, то есть его опять нужно проверить. Если это обстоятельство не учесть, то число пятёрок можно было бы под­считать мгновенно: 1000 : 5 = 200. Таким образом, в первой тысяче чисел ровно 200 делятся на 5. Ещё 40 делятся на 25 (5*5), 8 – на 125 (5*5*5) и од­но – на 625 (5*5*5*5). Зная ответ, и задачу легко решить, а я на олимпиаде намаялся

Помоги проекту! Расскажи друзьям об этом сайте:

Источник