Циклы в delphi 7

Цикл – это многократно повторяющаяся последовательность действий. Первый цикл, с которым мы познакомимся в этом уроке называется While…Do (делай пока верно условие).

Синтаксис:

While условие Do
begin
//тело цикла
end;

Сейчас нам нужно открыть Delphi и создать новый проект. Кидаем на форму компоненты Button и Label:

Пример формы

Создаем на кнопке процедуру OnClick и первое, что нам надо сделать – это ввести переменную A типа Integer:

procedure TForm1.Button1Click(Sender: TObject);
var A:integer;
begin
…

Теперь между ключевыми словами begin и end установим значение переменной A равное 1:

A:=1;

И сейчас мы напишем сам цикл, с условием A100, то есть пока A не равно 100 будет выполняться цикл.
Если же А = 100 – цикл остановится:

While A100 do
begin
//Тело цикла
end;

Далее, нам нужно что-то сделать в теле цикла. Давайте будем увеличивать значение переменной A на единицу и выводить значение переменной в Label.
Вместо комментария (//Тело цикла) мы напишем:

A:=A+1;
Label1.Caption:=IntToStr(A);

Общий вид кода:

procedure TForm1.Button1Click(Sender: TObject);
var A:integer;
begin
A:=1; //Присваеваем единицу
While A 100 do //Пока А не равно 100 – делаем
begin
A:=a+1; //прибавляяем единицу
Label1.Caption:=IntToStr(a); //Выводим значение А
end;
end;

Компилируем программу, нажимаем на кнопку и видим, что лабел показывает нам сотню. Но почему сразу сотню? Почему не 1,2,3,4 и так до ста.
Дело в том, что цикл выполняется на столько быстро, что мы не замечаем как лабел выводит нам сначала 1 потом 2 и потом 3.
По этому мы видим только сотню – конечный результат. Кто-то может подумать, что так не интересно :).
Хорошо, сейчас сделаем так, чтобы видеть как Delphi выполняет цикл.

Дописываем после строки

Label1.Caption:=IntToStr(a);

Вот эти две строчки

Application.ProcessMessages;
sleep(100);

Они делают следующие:

Application.HandleMessage – это метод, позволяющий выводить значения переменных во время работы цикла.
Не смотря на то, что мы и так выводим переменную в лабел, этот метод необходим.

sleep(100); – функция Sleep() говорит программе, что нужно поспать, как бы заморозиться на какое-то количество миллисекунд. Миллисекунды указываются в скобках. В секунде 1000 миллисекунд.

Общий вид кода:

Компилируйте и проверяйте.

С циклом While мы закончили, теперь разберем цикл со счетчиком или другое его название For…To…Do.
Данный цикл удобно применять, когда нам точно известно кол-во повторений.

Синтаксис:

For переменная счетчик:=Выражение №1 To выражение №2 Do
begin
//тело цикла
end;

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

Первым делом нам нужно добавить переменную S типа Integer.

procedure TForm1.Button1Click(Sender: TObject);
var A, S:integer;
begin
…

Далее, пишем программу, которая будет считать сумму чисел от 1 до 100.

То есть имеется ряд чисел 1 2 3 4 5 6 7 … 100.

Программа будет складывать эти числа между собой, то есть 1+2+3+4+5+6+7+…+100.

Стираем цикл While и пишем цикл For, но перед ним присвойте переменной S ноль:

For A:=1 to 100 do
begin
//Тело цикла
end;

Этот цикл повторит действия в теле 100 раз.

В тело цикла мы запишем:

S:=s+a;

Программа будет считать сумму чисел от 1 до 100, прибавляя к переменной S переменную счетчик A.

И после цикла выводим результат в лабел.

Label1.Caption:=IntToStr(S);

Общий вид:

procedure TForm1.Button1Click(Sender: TObject);
var A, S:integer;
begin
S:=0; //Присваеваем ноль
For A:=1 to 100 do
begin
S:=s+a; //Вычисления
end;
Label1.Caption:=IntToStr(S);
end;

У цикла For есть цикл двойник, он может считать в обратном порядке. Для этого нужно изменить ключевое слово To на DownTo

Пример той же самой программы, но с обратным счетчиком:

procedure TForm1.Button1Click(Sender: TObject);
var A, S:integer;
begin
S:=0; //Присваеваем ноль
For A:=100 downto 1 do
begin
S:=s+a; //Вычисления
end;
Label1.Caption:=IntToStr(S);
end;

Далее. Знакомимся с циклом Repeat.

Синтаксис:

Repeat
//Тело цикла
Until условие;

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

Стираем цикл For в нашей программе и пишем цикл Repeat:

procedure TForm1.Button1Click(Sender: TObject);
var A, S:integer;
begin
S:=0; //Присваеваем ноль
a:=0;

Repeat
a:=a+1;
S:=s+a; //Вычисления
Until a=100; //цикл будет выполняться пока a не достигнет 100

Label1.Caption:=IntToStr(S);
end;

Эта программа выполнит тоже самое что и предыдущая.

Ну вот мы и закончили обучение циклам! Сейчас выучим 2 команды для управления ими.

Сразу приведу пример программы, а потом прокомментирую что и как в ней работает:

procedure TForm1.Button1Click(Sender: TObject);
var A, S:integer;
begin
S:=0; //Присваеваем ноль
For A:=1 to 1000 do
begin
S:=s+a; //Вычисления
if S>100 then break else continue;
end;
Label1.Caption:=IntToStr(S);
end;

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

Экспериментируйте и всё получится. Жду комментов 😉

Задание на закрепление: напишите программу, которая вычислит сумму двухзначных чисел и выведет ее в Label.

Ну вот и всё! Удачи!
Встретимся в следующем уроке!

Источник

Это логика расчета факториала. Давайте перенесем ее на язык программирования 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. Теперь посмотрим поэтапно, что здесь происходит.

На первом этапе переменная index равна 0. sum тоже равна нулю, значит, выполнится операция sum:=o+o. Результат sum = о;
На втором этапе index увеличена на 1, значит, выполнится действие sum: =о+1. Результат sum = 1.
Здесь index увеличена на 1 и уже равна 2, a sum = 1. Значит, выполнится действие Sum: =1+2. Результат Sum = 3.
Здесь index увеличена на 1 и уже равна 3, a sum = 3. Значит, выполнится действие sum: =3+3. Результат sum = б.
Здесь index увеличена на 1 и уже равна 4, a sum = 6. Значит, выполнится действие Sum: =4 + 6. Результат Sum = 10.
Здесь 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. Попробуйте точно так же самостоятельно нарисовать блок-схему для данного примера и мысленно пройдите ее по шагам.

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

Источник

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

Цикл for Delphi

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

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

Цикл for Delphi

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

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

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

откуда

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

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

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

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

Пример 1.

Пример 2.

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

Циклы в delphi 7

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

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

Цикл for Delphi

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

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

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

Цикл for Delphi

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

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

Похожие записи:
История Delphi
Процедуры Delphi
Ошибки открытия файлов Delphi
Оператор goto Delphi
Цикл repeat Delphi

Источник

/Полезная информация–>

/Текст пишем здесь–>

&nbsp&nbsp&nbsp Программирование в среде Delphi 7. Циклы в Object Pascal

Продолжим тему создания простых приложений на Delphi 7 в рамках написания программы “Записная книга”. Только
в отличии от предыдущего урока,
постараемся использовать уже более серьёзный подход в написании программ, будем использовать базы данных для хранения информации.

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

Открываем среду разработки Delphi 7 и устанавливаем кнопку на форму. Но перед этим сделаем всё по правилам!
Проект сохраним в новой рабочей папке, свойство Caption формы изменим в инспекторе объектов на “Примеры циклов”.
Название формы – значение свойства Name изменим с Form1 на FCicle.
Сохраним файлы проекта.

Первая кнопка понадобится нам для демонстрации работы цикла for.

Cреда программирования Delphi 7

Кликаем один раз по кнопке в редакторе форм, тогда в “Инспекторе объектов” отобразятся свойства кнопки. Вообще, когда кликаем по
компоненту на форме, в окне “Object Inspector” отображаются свойства выбранного компонента. Я, в качестве примера, изменяю свойство Font у кнопки,
выделяя шрифт жирным и увеличивая его размер. Потом справа от кнопки поставим компонент TEdit и, примыкающий к строке редактирования,
компонент TUpDown, находящийся на вкладке Win32 палитры компонентов.

Компонент TUpDown на вкладке Win32 палитры компонентов

Для экземпляра UpDown1 в свойстве
Associate выбираем Edit1. Теперь, регулируя стрелками, мы можем изменять значение в строке редактирования. Укажем, что это значение параметра цикла,
поставив метку с соответствующей надписью над Edit1.

Заготовка формы для цикла for

Делаем двойной щелчок мыши по кнопке Button1, и перед нами в окне кода появляется шаблон процедуры обработчика события
нажатия на кнопку Button1Click. Начнём писать наш цикл. Пусть перед нами стоит задача посчитать сумму натурального ряда чисел от 1
до значения которое мы укажем в строке Edit1. Ниже представлен код.

procedure TFCicle.Button1Click(Sender: TObject);
Var
  i, S: Integer;
begin
  S := 0;
  for i := 1 to StrToInt(Edit1.Text) do
    S := S + i;

ShowMessage(IntToStr(S));
end;

Сперва определяем две локальные переменные (эти переменные используются только внутри события нажатия на кнопку). Переменная i – это
счётчик цикла. Переменная S – результирующая сумма, изначально, после объявления, имеет значение равное нулю. Всё-таки лучше иметь привычку сумму всегда обнулять.
Затем в цикле, счётчик принимает последовательно значения 1, 2, 3 и т. д. до StrToInt(Edit1.Text). Здесь мы преобразовываем строковое значение, которое ввели в строке редактирования, в
целочисленное значение, посредством функции StrToInt. Если целочисленному (integer) значению попытаться присвоить
строковое значение, то возникнет ошибка компиляции, программа не запустится! Так вот, каждый раз в цикле присваивая последовательно значения
счётчика i значению суммы S, мы получаем в итоге требуемый результат. Если в строку Edit1 поставить 1, то цикл выполнится 1 раз. А если поставить значение
меньшее начальному значению счётчика, в данном случае это 1, то цикл вообще не выполнится. Ошибки не возникнет.
Окончательно выводим результат с помощью процедуры ShowMessage. В качестве параметра в неё нужно передать строку, поэтому целочисленное значение
переменной S преобразовываем в строку функцией IntToStr.

У компонента TUpDown есть свойства Min и Max, определяющие минимальное и максимальное значение.
По умолчанию это 0 и 100, можно изменить на своё усмотрение.

Если мы введём в строку редактирования не число, а какой-либо символ, то будет выдана ошибка после нажатия на кнопку. Потому что в качестве параметра
для функции StrToInt необходимо передавать целое значение. Чтобы оградить пользователя от этой ошибки, нужно просто не дать ему возможности вводить
символы в эту строку с клавиатуры. Кликаем по строке Edit1, жмём F11, выбираем вкладку Events “Инспектора объектов”, два раза кликаем на событии
OnKeyPress. Это событие, когда нажата клавиша на клавиатуре. В этом событии у нас есть возможность обработать
вводимый символ, изменить его значение. Пишем следующий код.

procedure TFCicle.Edit1KeyPress(Sender: TObject; var Key: Char);
begin
if not (Key in [‘0’..’9′, #8]) then
Key := #0;
end;

Переменная Key – это вводимый символ, его мы можем менять в зависимости от ситуации в нашем рассматриваемом событии. Нам нужно не пропускать все символы
кроме цифр и клавишу стирания символа, которая имеет код #8. Здесь стоит поговорить о символьном типе данных Char. Именно такой тип имеет
переменная Key. Символ в Delphi пишется в апострофах, например, ‘z’. Так же символ можно указать в виде его кода после значка решётки #. Символ
‘z’ можно указать так же в виде кода #122. Так вот, если Key не попадает в множество символов, состоящих из цифр и клавиши стирания, то мы
присваиваем ей значение символа #0, это будет означать, что ничего не введено, ввод символа блокируется. Множества в Object Pascal указываются
в квадратных скобках, например, множество латинских символов в нижнем регистре: [‘a’..’z’], или через запятую несколько символов [‘a’, ‘b’, ‘f’, ‘z’].
Условие вхождения в множество обеспечивается такой конструкцией: if переменная in [множество] then. В нашем случае мы указали not – отрицание условия.

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

К примеру вот так:
  for i := 1 to n do
    begin
      Процедура1(i, набор параметров);
      for j := 1 to m do
        begin
          Процедура2(i, j, набор параметров);
          Процедура3(i, j, набор параметров);
        end;
    end;

Перейдём к изучению других циклов. Цикл с пост-условием: repeat … until (условие). И цикл
с пред-условием: while (условие) do …

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

Добавляем на форму ещё одну кнопку или копируем предыдущую при помощи сочетания клавиш Ctrl + C и Ctrl + V.
В случае копирования все свойства для новой кнопки сохраняются, в частности останется тот же шрифт (свойство Font).
Два раза кликаем на эту кнопку Button2 и вставляем в шаблон для события нажатия на кнопку наш код с циклом Repeat.

procedure TFCicle.Button2Click(Sender: TObject);
Var
  i, S: Integer;
begin
  S := 0;
  i := 0;
  Repeat
     Inc(i); //i := i + 1;
     S := S + i;
  Until i = StrToInt(Edit1.Text);

ShowMessage(IntToStr(S));
end;

Как работает этот цикл. Счётчик цикла мы вводим самостоятельно. Сумму и счётчик предварительно обнуляем.
Далее увеличиваем счётчик i на 1 процедурой Inc(i), которая работает так же как и в случае такого присвоения: i := i + 1,
но делается это немного быстрее. При малых значениях витков цикла это быстродействие “незаметно для глаза”. Потом прибавляем
к нашей сумме S новое значение счётчика i на каждом витке цикла, пока не будет выполнено условие, стоящее после ключевого слова
Until, то есть пока значение i не станет равным значению, введённому в строку редактирования.

Для этого случая стоит отметить, что если оставить нулевое значение в строке параметра цикла, то
на первом шаге цикла наш счётчик уже станет равным 1 и условие i = StrToInt(Edit1.Text); не будет выполнено никогда, программа зависнет!
Поэтому поставим перед циклом условие. Пусть наш цикл будет выполняться только если значение параметра цикла больше нуля.

procedure TFCicle.Button2Click(Sender: TObject);
Var
  i, S: Integer;
begin
  S := 0;
  i := 0;
  if StrToInt(Edit1.Text) > i then
    Repeat
       Inc(i); //i := i + 1;
       S := S + i;
    Until i = StrToInt(Edit1.Text);

ShowMessage(IntToStr(S));
end;

Цикл с пред-условием

Разместим ещё кнопку на форме.

Окончательный вариант формы

Два раза кликаем на кнопку Button3 и вставляем код с циклом while в обработчик события.

procedure TFCicle.Button3Click(Sender: TObject);
Var
  i, S: Integer;
begin
  S := 0;
  i := 0;
  while i do
   &nbspbegin
       Inc(i); //i := i + 1;
       S := S + i;
   &nbspend;

ShowMessage(IntToStr(S));
end;

Цикл выполняется, пока выполняется условие i , и это условие проверяется в самом начале цикла!
Тело цикла (набор действий внутри цикла) располагается между ключевыми словами begin и end.

Архив с файлами проекта можно скачать здесь f_d7_4.rar

Вернуться к списку статей, посвящённых программированию в Delphi 7

Вы так же можете подписаться на бесплатную рассылку о новых статьях на сайте.

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

Наверх

Перейти к списку статей по программированию в среде Delphi 7

Свяжитесь с нами!

/Текст пишем здесь–>

/Полезная информация–>

Источник