Программирование в Delphi:циклы, условия, собственные типы

Программирование в Delphi:циклы, условия, собственные типы

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

Также мы поговорим о собственных типах, которые мы можем сами заводить и использовать, а также разберём структуры (записи).

Условия

При решении задач иногда необходимо, чтобы определённые действия выполнялись только в определённых случаях. Для этого нам поможет конструкция условий. Выглядит она так: if <логический тип> then <действие, если под if стоит True> else <действие, если под if стоит False>;

Также конструкция может существовать и без else: if <логический тип> then <действие, если под if стоит True>;

В конструкциях также могут использоваться глобальные блоки begin..end! Они нужны для того, чтобы при выполнении (или не выполнении) условия выполнялось не одно действие, а группа действий. Выглядит это примерно так: if <логический тип> then begin

<действие 1, если под if стоит True>

<действие 2, если под if стоит True>

···········································

<действие n, если под if стоит True> end else begin

<действие 1, если под if стоит False>

<действие 2, если под if стоит False>

···········································

<действие n, если под if стоит False> end;

Обратите внимание, что если директива end стоит перед else, то точку с запятой ставить не нужно!

Теперь, в конструкции if..then стоит логический тип, т. е. True или False. Например, есть переменная fl, и мы можем узнать, чему она равна: if fl then begin

A:=1;

B:=1; end else begin

A:=2;

B:=100500; end;

Помимо переменной, в конструкции if..then может стоять логическое выражение: равенство =, больше >, меньше <, больше или равно >=, меньше или равно <=, не равно <>, и and, или or, не not и т. д. Например, if A = 0 then if (A >= 0) and (C = 'F') and not fl then

И так далее. Конструкции могут быть как совершенно простые, так и достаточно сложные.

Развёрнутые условия

Данный способ работает только для порядковых переменных. В нашем случае теперь будет не 2 значения (True и False), а несколько. Конструкция выглядит так: case <порядковый тип> of

<значение 1>: <действие 1>;

<значение 2>: <действие 2>;

···········································

<значение N>: <действие N>; else

<действие>; end;

Обратите внимание, что begin у нас нет, его заменяет слово case! Блок else также может отсутствовать: case <порядковый тип> of

<значение 1>: <действие 1>;

<значение 2>: <действие 2>;

···········································

<значение N>: <действие N>; end;

А ещё могут присутствовать глобальные блоки begin..end: case <порядковый тип> of

<значение 1>: begin

<действие 1-1>;

<действие 1-2>;

·······································

<действие 1-N>; end;

<значение 2>: begin

<действие 2-1>;

<действие 2-2>;

·······································

<действие 2-N>; end;

···········································

<значение N>: begin

<действие N-1>;

<действие N-2>;

·······································

<действие N-N>; end; else begin

<действие 1>;

<действие 2>;

·········································

<действие N>; end; end;

Пример использования: case k of

1: begin

A:=1;

B:=1; end;

10: begin

A:=10;

B:=100500; end; else begin

A:=100500;

B:=100; end; end;

Циклы

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

Логический цикл «while» while <логический тип> do <действие>; while <логический тип> do begin

<действие 1>;

<действие 2>;

···········································

<действие N>; end;

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

K:=10; while k <= 100 do k:=k*k;

WriteLn(k);

Логический цикл «repeat» repeat

<действие 1>;

<действие 2>;

···········································

<действие N>; until <логический тип>;

Отличие от цикла while в том, что не нужны глобальные блоки begin..end, а условие проверяется в конце цикла, а не в начале, хотя, если честно, цикл while мне нравится больше.

Порядковый цикл «for» for <порядковая переменная>:=<значение 1> to <значение 2> do <действие>; for <порядковая переменная>:=<значение 1> to <значение 2> do begin

<действие 1>;

<действие 2>;

···········································

<действие N>; end;

Данный цикл — самый полезный из всех циклов. Каждый шаг в цикле увеличивается порядковая переменная от <значение 1> на 1 до тех пор, пока она не станет равна <значение 2>. Таким образом мы можем не только ограничить количество действий в цикле, но и использовать эту переменную внутри цикла. Например: k:=1; for i:=4 to 10 do k:=k*i+i;

Если <значение 2> меньше <значение 1>, то цикл не сработает вообще. Если нужно сделать цикл в обратную сторону, то вместо to используйте downto.

Такие циклы также очень помогают при работе с массивами, например: for i:=1 to 10 do WriteLn(A[i]);

В работе с циклами иногда нужно сделать досрочный выход из цикла. Для этого используется процедура Break. Например: for i:=1 to 100 do begin k:=k*i; if k>0 then Break; end;

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

Собственные типы

По аналогии с блоком var, существует блок type, который и помогает нам в объявлении новых типов. Конструкция выглядит так: type

<название типа> = <описание типа>;

Например, можно объявить такие типы: type

TWeek = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);

TMassive = array [1..100] of Cardinal;

TTen = 1..10;

После этого эти типы можно будет использовать: var

Week: TWeek;

A, B: TMassive; k: TTen;

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

Структуры

Новый тип данных, который достаточно удобен и несколько улучшит понимание объектов в Delphi. Структура может состоять из процедур, функций (их мы разберём в следующем уроке), а также переменных и параметров. Объявляются структуры в блоке type: type

TRec = record end;

Пример простенькой структуры: type

TFood = record

Breakfast: String;

Lunch: String;

Dinner: String; end;

Завтрак, обед, ужин.

Вот пример работы со структурами: program SimpleProgram;

{$APPTYPE CONSOLE} type

TFood = record

Breakfast: String;

Lunch: String;

Dinner: String; end; var

Food: array [1..7] of TFood; i: Integer; begin for i:=1 to 7 do begin

Write('Enter breakfast [',i,']: ');

ReadLn(Food[i].Breakfast);

Write('Enter lunch [',i,']: ');

ReadLn(Food[i].Lunch);

Write('Enter dinner [',i,']: ');

ReadLn(Food[i].Dinner); end;

Randomize; i:=Random(7)+1;

Write('Today you must eat: ',Food[i].Breakfast,' ',Food[i].Lunch,' ',Food[i].Dinner);

ReadLn; end.

Вводятся завтраки, обеды, ужины и выводится случайный завтрак/обед/ужин на сегодня. Просто и понятно, я думаю.

Обращение к элементам структуры, как видите, идёт через точку. Также может быть структура в структуре.

Type

TRec1 = record k: Integer; s: String; f: Char; end;

TRec2 = record

A: array [1..10] of Integer; r: TRec1; end; var abc: TRec2;

Тогда обращение к элементу k идёт так: abc. r.k;

Надеюсь, достаточно понятно объяснил, как работают структуры. Они нам ещё пригодятся.

Некоторые полезные функции и процедуры

Break — прерывает работу всего цикла

Continue — прерывает работу текущего захода в цикл, запуская его с начала

FillChar(<массив>,<число элементов>,<элемент>) — заполняет массив элементами


Карта сайта


Информационный сайт Webavtocat.ru