5.4. Операторы языка

С одним из наиболее часто используемых операторов языка Object Pascal - оператором присваивания мы уже познакомились (см. п. 3.3.3). Ниже рассматриваются остальные операторы.

5.4.1. Составной оператор и пустой оператор

Составной оператор - это последовательность произвольных операторов программы, заключенная в операторные скобки - зарезервированные слова begin ... end. Составные операторы - важный инструмент Object Pascal, дающий возможность писать программы по современной технологии структурного программирования (без операторов перехода goto).

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

Функция Trim не определена в версии 1. Вместо указанной единственной строки в этом случае

следует написать:[while post' ', edinput.Text)>0 do

system.delete(edinput.Text, post' ', edinput.Text), 1);

StrToint(edinput.Text);]

begin

begin

begin

end;

end;

end;

Фактически весь раздел операторов, обрамленный словами begin ... end, представляет собой один составной оператор. Поскольку зарезервированное слово end является закрывающей операторной скобкой, оно одновременно указывает и конец предыдущего оператора, поэтому ставить перед ним символ “;” необязательно. Наличие точки с запятой перед end в предыдущих примерах означало, что между последним оператором и операторной скобкой end располагается пустой оператор. Пустой оператор не содержит никаких действий, просто в программу добавляется лишняя точка с запятой. В основном пустой оператор используется для передачи управления в конец составного оператора: как и любой другой, пустой оператор может быть помечен, и ему можно передать управление.

5.4.2. Условный оператор

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

Структура условного оператора имеет следующий вид:

if <условие> then <оператор1> else <оператор2>;

где if/ then/ else - зарезервированные слова (если, то, иначе);

<условие> - произвольное выражение логического типа;

<оператор1>, <оператор2> - любые операторы языка Object Pascal.

Условный оператор работает по следующему алгоритму. Вначале вычисляется условное выражение <условие>. Если результат есть True (истина), то выполняется <оператор1>, а <оператор2> пропускается; если результат есть False (ложь), наоборот, <оператор1> пропускается, а выполняется <оператор2>. Например:

var

X, Y, Max: Integer;

begin .

if X > Max then

Y := Max else

Y := X;

….

end;

При выполнении этого фрагмента переменная y получит значение переменной х, если только это значение не превышает мах, в противном случае y станет равно мах.

Условными называются выражения, имеющие одно из двух возможных значений: истина или ложь. Такие выражения чаще всего получаются при сравнении переменных с помощью операций отношения =, <>, >, >=, <, <=. Сложные логические выражения составляются с использованием логических операций and (логическое И), or (логическое ИЛИ) и not (логическое НЕ). Например:

if (а > b) and (b <> 0) then ...

В отличие от других языков программирования в Object Pascal приоритет операций отношения меньше, чем у логинеёкйх" операции, по этому отдельные составные части сложного логического вьфажёния⁵ заключаются в скобки. Например, такая запись предыдущего оператора будет неверной:

if a>b and b <> 0 then ...// Ошибка так как фактически (с учетом приоритета операции) компилятор будет транслировать такую строку:

if a>(b and b)<>0 then...

Часть else <оператор2> условного оператора может быть опущена. Тогда при значении True условного выражения выполняется <оператор1>, в противном случае этот оператор пропускается:

var

X, Y, Max: Integer;

begin

if X > Мах then Мах := X;

Y := X;

end;

В этом примере переменная y всегда будет иметь значение переменной х, а в мах запоминается максимальное значение X.

Поскольку любой из операторов <оператор1> и <оператор2> может быть любого типа, в том числе и условным, а в то же время не каждый из “вложенных” условных операторов может иметь часть else <оператор2>, то возникает неоднозначность трактовки условий. Эта неоднозначность в Object Pascal решается следующим образом:

любая встретившаяся часть else соответствует ближайшей к ней сверху по тексту программы части then условного оператора. Например:

var

a,b,c,d : Integer;

begin a := 1;

b := 2;

с := 3;

d := 4;

if a < b then // Да

if с < d then // Да

if с < 0 then // Нет

с := 0 // Этот оператор не выполняется

else

а := b; // а равно 2

if а < b then // Да

if с < d then // Да

if с < 0 then // Нет

с := 0 // с равно 0

else //if с < О else //if с < d

else // If a < b

а := b; // Этот оператор не выполняется

end;

 

Учебная программа INTTEST

Игра “Угадай число”: программа случайным образом выбирает целое число в диапазоне О... 1000 и запоминает его. Пользователь пытается угадать его и вводит свое число. Сравнив ввод с запомненным числом, программа сообщает - больше, меньше или равно введенное число запомненному. Ввод продолжается до угадывания, после чего программа предлагает сыграть еще раз.

Поскольку пользователь вводит только числа, изменим форму fmExample: как и в предыдущей программе intmult вместо компонента edinput типа TEdit поместим на форму одноименный компонент типа TMaskEdit. Выберите опцию File | New | Application, щелкните по компоненту edinput и удалите его с помощью клавиши Delete, затем поместите на его место компонент MaskEdit (страница Additional), назовите его edInput (свойство Name) и в его свойство

EditMask поместите строку

0999;1;

В секцию private описания класса fmExampie поместите объявление целочисленного поля х:

private

{ Private declarations }

X: Integer;

Для обработчика события OnActivate формы fmExampie Напишите такой код:

procedure TfmExample.FormActivate(Sender: TObject);

begin

X := Random (1001) ; // Загадываем случайное число

edinput.SetFocus; // Передаем строке edinput фокус ввода

Caption := 'Угадай целое число в диапазоне О...1000';

IbOutput.Caption :== 'Введите число:';

end;

Поместите в обработчик события onciick кнопки bbRun такой код:

procedure TfmExample.bbRunClick(Sender: TObject);

var

Y: Integer;

begin

if edinput.Text = '' then

Exit; // Если нет входного текста, прекращаем работу

// Преобразуем ввод в число:

Y := StrToInt(Trim(edInput.Text));

edinput.Text := ''; // Очищаем ввод

edinput.SetFocus; // Устанавливаем фокус ввода

{ Параметр Tag = 0 означает угадывание числа, иначе - ответ на вопрос, будет ли пользователь играть после угадывания }

if Tag = 0 then

if X < Y then // Угадывание числа

mmOutput.Lines.Add('X < '+IntToStr(Y))

else if X > Y then

mmOutput.Lines.Add('X > '+IntToStr (Y))

else // X = Y begin

mmOutput.Lines.Add("X = +IntToStr(Y));

MessageBeep(MB_OK); // Звук для привлечения внимания

IbOutput.Caption :='Вы угадали! Введите 1, если хотите повторить:';

Tag := 1; // Следующий ввод - ответ на вопрос

end;

else // Анализ ответа

if Y = 1 then

begin

X := Random(1001); // Новое число

IbOutput.Caption := 'Введите число:';

Tag := 0; // Следующий ввод - угадывание

edinput.SetFocus

end

else

Close;

end;

Комментарий к программе

При активизации окна программы обработчик FormActivate с помощью оператора

Х := Random(1001) ;

помещает в поле X случайное целое число в диапазоне от 0 до 1001 -1 = 1000 (параметр обращения к генератору псевдослучайных чисел Random на единицу больше верхней границы диапазона).

Каждый компонент Delphi имеет целочисленное свойство Tag, которым программист может распоряжаться по своему усмотрению. Программа использует это свойство формы fmExampie для разделения алгоритма обработки события OnClick кнопки bbRun на два варианта: пользователь угадывает число (тад = 0) или отвечает на предложение сыграть еще раз (тад = 1). В момент создания экземпляра класса TfmExmple - объекта fmExample - все его поля обнуляются, поэтому первоначально Tag = 0 и программа анализирует угадывание числа. При угадывании срабатывает составной оператор

begin

mmOutput.Lines.Add('X = Ч-IntToStr(Y)) ;

MessageBeep(MB OK); // Звук для привлечения внимания

IbOutput.Caption :='Вы угадали! Введите 1, если хотите повторить:';

Tag := 1; // Следующий ввод - ответ на вопрос

end

и Tag получает значение 1 (стандартная процедура MessageBeep заставляет звуковую систему ПК издать короткий звуковой сигнал).

Теперь очередной щелчок по кнопке bbRun будет означать, что пользователь подготовил ответ на вопрос, и программа анализирует его. Если пользователь ввел число отличное от 1, произойдет обращение к методу close формы fmExample и программа прекратит работу.

5.4.3. Операторы повторений

В языке Object Pascal имеются три различных оператора, с помощью которых можно запрограммировать повторяющиеся фрагменты программ.

Счетный оператор цикла FOR имеет такую структуру:

for <параметр цикла> := <нач_знач> to <кон знач> do <оператор>;

Здесь for, to, do - зарезервированные слова (для, до, выполнить);

<параметр_цикла> - переменная типа Integer (точнее, любого по-, рядкового типа, см. гл. 7); <нач_знач> - начальное значение - выражение того же типа; <кон_знач> - конечное значение - выражение того же типа; <оператор> - произвольный оператор Object Pascal.

При выполнении оператора for вначале вычисляется выражение <нач_знач> и осуществляется присваивание <параметр_цикла> := <нач_знач>. После этого циклически повторяется:

• проверка условия <параметр_цикла> <= <кон_знач>; если условие не выполнено, оператор for завершает свою работу;

• выполнение оператора <оператор>;

• наращивание переменной <параметр_цикла> на единицу.

Учебная программа INTSLJMM

В качестве иллюстрации применения оператора for рассмотрим программу, осуществляющую ввод произвольного целого числа n и вычисление суммы всех целых чисел от 1 до N.

Для нового приложения (опция File | New | Application) создайте такой обработчик bbRunСlick:

procedure TfmExample.bbRunClick(Sender: TObject);

var

i,N,Sum : Integer;

begin

try // Преобразуем ввод с контролем правильности:

N := StrToInt(edInput.Text);

except // Следующие операторы выполняются, если есть ошибка ShowMessage('Ошибка ввода целого числа');

dinput.SelectAll; // Выделяем неверный ввод

Exit // Завершаем работу обработчика

end;

edInput.Text :=' ';

edinput.SetFocus;

Sum := 0; // Начальное значение Sum

for i := 1 to N

do // Цикл формирования суммы

Sum := Sum+i;

mmOutput.Lines.Add('Сумма всех целых чисел '+'в диапазоне 1...'+IntToStr(N)+' равна '+IntToStr(Sum));

end;

Комментарий к программе

Прежде всего обратите внимание на операторы

try // Преобразуем ввод с контролем правильности:

N := StrToInt(edinput.Text);

except // Следующие операторы выполняются, если есть ошибка ShowMessage("Ошибка ввода целого числа');

edinput.SelectAll; // Выделяем неверный ввод

Exit // Завершаем работу обработчика

end;

С помощью зарезервированных слов try (попробовать), except (исключение) и end реализуется так называемый защищенный блок. Такими блоками программист может защитить программу от краха при выполнении потенциально опасного участка (подробнее см. п. 14.1). В отличие от предыдущих программ мы не изменили компонент edinput, поэтому пользователь может ввести в нем произвольный текст. Если этот текст не содержит правильное представление целого числа, попытка выполнить оператор

N := StrToInt(edInput.Text);

в обычной программе привела бы к аварийному завершению программы. Чтобы этого не произошло, мы защитили этот оператор, расположив его за try и перед except. Если ошибки нет, все операторы, стоящие за except и до end, пропускаются и обработчик нормально срабатывает. Если обнаружена ошибка, возникает так называемая исключительная ситуация (исключение) и управление автоматически передается оператору, стоящему за except, - начинается обработка исключения. Вначале с помощью стандартной процедуры ShowMessage мы сообщаем пользователю об ошибке[Если вы запустите программу из среды Delphi, исключение будет сначала перехвачено средой и на экране появится сообщение на английском языке о характере и месте возникновения ошибки. В этом случае закройте окошко с сообщением и нажмите F9 - программа продолжит свою работу, и вы увидите окно процедуры ShowMessage.], затем с помощью edInput. SeiectAll выделяем ошибочный текст в компоненте edinput и, наконец, с помощью вызова стандартной процедуры Exit аварийно завершаем работу обработчика (но не программы!).

Отметим также два обстоятельства. Во-первых, условие, управляющее работой оператора for, проверяется перед выполнением оператора <оператор>: если условие не выполняется в самом начале работы оператора for, исполняемый оператор не будет выполнен ни разу. Другое обстоятельство - шаг наращивания параметра цикла строго постоянен и равен (+1). Существует другая форма оператора:

for <пар_цик>: = <нач_знач>downto <кон_знач>do <оператор>;

Замена зарезервированного слова to на downto означает, что шаг наращивания параметра цикла равен (-1), а управляющее условие Приобретает вид <параметр__цикла> = <кон_знач>.

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

Sum := 0;

if N >= 0 then

for i := 1 to N do

Sum := Sum + i

else

for i := -1 downto N do

Sum := Sum + i ;

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

Оператор цикла WHILE с предпроверкой условия:

while <условие> do <оператор>;

Здесь while, do - зарезервированные слова {пока [выполняется условие], делать), <условие> - выражение логического типа; <оператор> - произвольный оператор Object Pascal.

Если выражение <условие> имеет значение True, то выполняется <оператор>, после чего вычисление выражения <условие> и его проверка повторяются. Если <условие> имеет значение False, оператор while прекращает свою работу.

Учебная программа EPSILON

Программа отыскивает так называемое “машинное эпсилон” -такое минимальное, не равное нулю вещественное число, которое после прибавления его к 1,0 еще дает результат, отличный от 1,0. Замечу, что для хранения и преобразования дробных чисел в Object Pascal предназначены так называемые вещественные типы (см. гл. 7). В учебной программе используется один из этих типов - Real, занимающий 8 смежных байт и представляющий дробные (вещественные) числа в диапазоне от 10-³²⁴ до 10+³⁰⁸ с точностью 15... 16 значащих цифр¹⁰ .

У читателя, привыкшего к непрерывной вещественной арифметике, может вызвать недоумение утверждение о том, что в дискретной машинной арифметике всегда существуют такие числа o<x<eps, что i,o+x°i,o. Дело в том, что внутреннее представление типа Real может дать “лишь” приблизительно 10¹⁹ возможных комбинаций значащих разрядов в отведенных для него 8 байтах. Конечно же, это очень большое число, но оно несопоставимо с бесконечным множеством вещественных чисел. Аппроксимация бесконечного непрерывного множества вещественных чисел конечным (пусть даже и очень большим) множеством их внутреннего машинного представления, и приводит к появлению “машинного эпсилон”.

Для нового приложения (опция File I New I Application) создайте такой обработчик bbRunСlick:

procedure TfmExample.bbRunClick(Sender: TObject) ;

var

Epsilon: Real;

begin

Epsilon := 1;

while l+Epsilon/2>l do

Epsilon := Epsilon/2;

IbOutput.Caption := 'Машинное эпсилон = '+FloatToStr(Epsilon)

end;

Комментарий к программе

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

var

X : Integer; begin

X := 4/2; // Ошибка!Вещественный результат нельзя

// присвоить целой переменной

end;

Стандартная функция FloatToStr преобразует вещественное число в строку символов.

Оператор цикла REPEAT... UNTIL с постпроверкой условия:

repeat <тело цикла> Until <условие>;

Здесь repeat, until - зарезервированные слова (повторять [до тех пор}, пока [не будет выполнено условие]); <тело_цикла> - произвольная последовательность операторов Object Pascal; <условие> - выражение логического типа.

Операторы <тело_цикла> выполняются хотя бы один раз, после чего вычисляется выражение <условие>: если его значение есть False, операторы <тело_цикла> повторяются, в противном случае оператор repeat... until завершает свою работу.

Обратите внимание: пара repeat... unti1 подобна операторным скобкам begin ... end, поэтому перед until ставить точку с запятой необязательно.

Замечу, что для правильного выхода из цикла условие выхода должно меняться внутри операторов, составляющих тело цикла while или repeat... until. Следующие циклы никогда не завершатся “естественным” способом:

while True do begin

end;

и

repeat

until False;

Для гибкого управления циклическими операторами for, while и repeat в состав Object Pascal включены две процедуры без параметров:

break - реализует немедленный выход из цикла; действие процедуры заключается в передаче управления оператору, стоящему сразу за концом циклического оператора;

continue - обеспечивает досрочное завершение очередного прохода цикла; эквивалент передачи управления в самый конец циклического оператора.

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

5.4.4. Оператор выбора

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

Структура оператора выбора такова:

case <ключ_выбора> of <список_выбора> [else <операторы>] end;

Здесь case, of, else, end - зарезервированные слова (случай, из, иначе, конец); <ключ_выбора> - ключ выбора (выражение порядкового типа); <список_выбора> - одна или более конструкций вида:

<константа_выбора> : <оператор>;

<константа_выбора> - константа того же типа, что и выражение <ключ_выбора>; <оператор> - произвольный оператор Object Pascal.

Оператор выбора работает следующим образом. Вначале вычисляется значение выражения <ключ_выбора>, а затем в последовательности операторов <список_выбора> отыскивается такой, которому предшествует константа, равная вычисленному значению. Найденный оператор выполняется, после чего оператор выбора завершает свою работу. Если в списке выбора не будет найдена константа, соответствующая вычисленному значению ключа выбора, управление передается операторам, стоящим за словом else. Часть else <операторы> можно опускать. Тогда при отсутствии в списке выбора нужной константы ничего не произойдет, и оператор выбора просто завершит свою работу.

Любому из операторов списка выбора может предшествовать не одна, а несколько констант выбора, разделенных запятыми. Например:

var

ch : Char;

begin

case ch of

'n','N','H','H': IbOutput.Caption := 'Нет';

'у','Y','д','Д': IbOutput.Caption := 'Да';

end

end;

Учебная программа CALC

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

Для упрощения ввода операндов и знака поместим на нашу учебную форму еще два компонента. Выберите File | New | Application, переименуйте компонент ibinput в ibinputi и сделайте его свойство width (длина) равным 121 (стандартная длина компонентов Edit), a свойство Left (слева) - 64. Справа от компонента ibinputi поместите компонент comboBox (страница Standard), назовите его cbSign (свойство Name) и установите для него width =41. Раскройте диалоговое окно свойства items этого компонента и введите четыре строки со знаками математических действий в такой последовательности:

+

-

*

/

И, наконец, справа от cbSign разместите еще один компонент Edit (страница Standard) и назовите его edinput2. He забудьте очистить свойства Text у всех трех компонентов.

Рис. 5.7. Окно программы CALC

Для обработчика события bbRunciick введите такой текст:

procedure TfmExample.bbRunClick(Sender: TObject);

var

X, Y, Z: Real;

begin

{ Блокируем работу, если не введены операнды и не выбрано действие }

if (edInputl.Text='') or (edlnput2.Text='') or (cbSign.Itemlndex<0) then Exit;

// Проверяем правильность ввода 1-го операнда:

try // Начало защищенного блока

Х := StrToFloat(Trim(edinputi.Text));

except // Обработка ошибки

ShowMessage('Ошибочная запись числа: '+edlnputl.Text);

edinputi.SelectAll;

Exit;

end; // Конец защищенного блока

// Проверяем правильность ввода 2-го операнда:

try // Начало защищенного блока

Y := StrToFloat(Trim(edlnput2.Text));

except // Обработка ошибки

ShowMessage('Ошибочная запись числа: '+edlnput2.Text);

edlnput2.SelectAll ;

Exit;

end;

// Конец защищенного блока

// Все правильно: вычисляем результат

case cbSign.Itemlndex of

0: Z := X + Y;

1: Z := X - Y;

2: Z := X * Y;

3: try

Z := X / Y; except

Z := l.le+38; // Бесконечность при делении на О

end;

end;

// Показываем результат

IbOutput.Caption := Trim(edinputi.Text)+' '+ cbSign.Items[cbSign.Itemlndex]+' '+ Trim(edlnput2.Text)+' = ';

if Z >= l.le+38 then

IbOutput.Caption := IbOutput.Caption+'бесконечность'

else

IbOutput.Caption := IbOutput.Caption+FloatToStr(Z);

mmOutput.Lines.Add(IbOutput.Caption) ;

// Очищаем ввод edinputi.Text := '';

ed!nput2.Text := ' ';

cbSign.ItemIndex := -1;

end;

Комментарий к программе

В качестве операндов в программе выбраны переменные вещественного типа Real. Символьное представление значений Real в общем случае имеет вид:

±ЦЦЦЦЦ.ДДДДДе+ППП

Здесь ± - знак + или -; ццццц - цифры целой части числа; ддддд -цифры дробной части; ппп - цифры десятичного порядка. Символ е (E) в такой записи читается как “умножить на 10 в степени”. Например, 1. 1e+38 читается: “один и одна десятая умножить на 10 в степени плюс тридцать восемь”. Следует учесть, что компилятор Delphi в качестве разделителя целой и дробной частей всегда использует символ “.”, в то время как аналогичный разделитель в Windows зависит от выбранной страны, и для России им обычно является запятая “,”. Это означает, что вещественные константы в тексте программы вы всегда должны записывать с разделителем “.”, а при вводе пользователем программы вещественных чисел он должен использовать разделитель Windows (этот разделитель можно выбрать В Windows 32 С помощью Пуск | Настройка 1 Панель управления | Язык и стандарты).

Поскольку правильная форма записи вещественного числа гораздо богаче формы записи целого, использовать однострочный редактор с маской для фильтрации вещественных чисел невозможно, поэтому в программе используются обычные редакторы edInput1 и edInput2. В этой ситуации контроль за правильностью записи приходится возлагать на функцию преобразования strToFioat (эта функция преобразует строку в вещественное число). Если функция обнаружит ошибку в записи вещественного числа, она инициирует исключительную ситуацию, которая обычно приводит к аварийному завершению работы программы. Чтобы этого не произошло, используются защищенные блоки (см. комментарий к программе INITSUMM). Таким же блоком защищается операция деления: если число долится на ноль или на очень малую величину, результату присваивается большая положительная величина 1,1*10⁺³⁸. При выводе сообщения эта величина заменяется на слово “бесконечность”.

Для выбора операции в программе используется компонент Combовох - раскрывающийся список выбора. Свойство items этого компонента хранит набор строк, которые определяют список выбора. Эти строки пронумерованы начиная с нуля (в нашем случае cbSign.Items[0] = '+', a cbSign. Items [3] = '/'). Номер выб-ранной строки содержит свойство cbSign.ItemIndex, а если не выбрана ни одна строка, это свойство содержит -1. Программа контролирует выбор за счет условия

cbSign.ItemIndex<0

при проверке операндов, а также в операторе case:

case cbsign.itemindex of

Если вы ввели строки cbSign. items в нужной последовательности, индекс выбранной строки будет соответствовать номеру операции (0 - +, 1- -, 2 - * и 3 - /), и над операндами будет выполнено требуемое действие.

5.4.5. Метки и операторы перехода

Можно теоретически показать, что рассмотренных операторов вполне достаточно для написания программ любой сложности. В этом отношении наличие в языке операторов перехода кажется излишним. Более того, современная технология структурного программирования основана на принципе “программировать без GOTO”: считается, что злоупотребление операторами перехода затрудняет понимание программы, делает ее запутанной и сложной в отладке. Тем не менее в некоторых случаях использование операторов перехода может упростить программу.

Оператор перехода имеет вид:

goto <метка>;

Здесь goto - зарезервированное слово (перейти [на метку]); <метка> - метка.

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

Метка располагается непосредственно перед помечаемым оператором и отделяется от него двоеточием. Оператор можно помечать несколькими метками, которые в этом случае отделяются друг от друга двоеточием. Перед тем как появиться в программе, метка должна быть описана. Описание меток состоит из зарезервированного слова label (метка), за которым следует список меток:

Label

loop, Ibl, lb2;

begin

goto Ibl;

 

loop: .........

Ibl:lb2: ......

......

goto lb2;

end;

Действие оператора goto состоит в передаче управления соответствующему меченному оператору.

При использовании меток необходимо руководствоваться следующими правилами:

• метка, на которую ссылается оператор goto, должна быть описана в разделе описаний, и она обязательно должна встретиться где-нибудь в теле программы;

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