Введение
Данное справочное пособие создано с целью поддержки базового курса программирования с использованием КП. И так как базовый курс не предполагает глубокого изучения инструментальных возможностей языка, данное пособие не включает ряд имеющихся возможностей, например ничего не говорится о процедурах-методах, некоторые возможности даны кратко, без технических деталей, например конструкция открытого массива.
Данного материала однако вполне достаточно, для базового курса, кроме того, предполагается приобретение навыка самостоятельного изучения технического руководства, навыка обязательного для каждого программиста, поэтому некоторые детали, например список предопределенных процедур, пропущен полностью. В случае необходимости информация о предопределенных процедурах должна быть взята учеником из технического руководства BlackBox. Впрочем это не должно вызывать затруднений. Кроме того, часть теоретического материала будет дана в иллюстративных задачах практического курса.
Необходимо также иметь ввиду, при использовании данного пособия, что оно создано, для начинающих изучать КП и даже может быть для впервые начинающих программирование, поэтому мы при составлении справочника отказались от строгой нотации, в целях достижения большей прозрачности. Отход от строгого формализма иногда ведет к неоднозначности в понимании терминов и правил. Для профилактики таких ситуаций справочник снабжен достаточным количеством примеров.
Кроме того, дополнительные примеры иллюстрирующие те или иные возможности языка будут даны вам и в практическом курсе. Так же в практический курс вынесена информация и по использованию некоторых библиотек КП/ББ например, некоторые графические возможности и работа с файлами данных.
Структура
программы
Единицей программного проекта является модуль, содержащий несколько списков компонент:
MODULE Имя модуля;
IMPORT Список импортируемых модулей;
TYPE Список типов;
VAR Список переменных;
Список процедур
END Имя модуля.
Пример:
MODULE
example;
IMPORT StdLog; (*Импортируется модуль вывода*)
VAR
a: INTEGER; (*общие переменные модуля*)
PROCEDURE MyProcedure*;
VAR a: INTEGER; (*Локальные переменные процедуры*)
BEGIN
(*Тело процедуры*)
END MyProcedure;
END example.
Обратите
внимание, что END завершающий
программную конструкцию: модуль
или процедуру должен содержать имя
этой программной конструкции. Есть
небольшое различие между
завершением модуля и завершением
процедуры. Описание процедуры
завершается точкой с запятой,
описание модуля завершается
точкой.
Список
процедур может быть сколь угодно
велик. Процедуры, помеченные
звездочкой являются доступными за
пределами модуля, то есть из других
модулей и из командной строки.
Процедуры без звездочки могут
использоваться только в пределах
того модуля, в котором они описаны.
Список
переменных может быть создан, как
для процедуры, в этом случае
объявляемые переменные называются
локальными, так и для модуля, в этом
случае переменные называются
глобальными. Область видимости
локальной переменной – процедура,
в списке которой данная переменная
объявлена. Область видимости
глобальной переменной – модуль.
Если и в списке переменных модуля и
в списке переменных некоторой
процедуры объявлена переменная с
одним и тем же именем, то в теле
процедуры данное имя обозначает
локальную переменную процедуры.
MODULE example;
IMPORT StdLog; (*Импортируется модуль вывода*)
VAR
a: INTEGER; (*общие переменные модуля*)
PROCEDURE
MyProcedure*;
VAR
a: INTEGER; (*Локальные переменные процедуры*)
BEGIN
a:=1;
(*присвоена 1 локальной переменной*)
END
MyProcedure;
END example.
Переменные
объявленные с одинаковыми именами
в разных процедурах, являются
разными переменными в силу разной
области видимости (для каждой
переменной только своя процедура).
Время
жизни переменной равно времени
выполнения процедуры. По
завершению работы процедуры –
память занятая локальными
переменными очищается.
Процедура может содержать собственный список типов и собственные процедуры. То есть описание процедуры состоит из следующих компонентов:
PROCEDURE имя процедуры(список формальных параметров): тип возвр. значения
TYPE список типов
VAR список переменных
Список собственных процедур
BEGIN
Тело процедуры
END Имя
процедуры;
Собственная процедура может вызываться в теле данной процедуры и может вызываться процедурами стоящими в списке процедур после неё. Пример
PROCEDURE
example;
PROCEDURE
p1;
BEGIN
END
p1;
PROCEDURE
p2;
BEGIN
END
p2;
BEGIN
END example;
Процедуры p1 и p2 могут быть вызваны в теле процедуры example и дополнительно к этому процедура p1 Может быть вызвана в теле процедуры p2, но никак не наоборот.
Величины
и типы данных КП
Объявление
величин
Для того, чтобы величину (константу, переменную) можно было использовать в программе, она должны быть объявлена, то есть задано имя, и тип для переменной и имя и значение для константы.
Константы
Константа – это величина, чьё значение определяется единожды и более не меняется. Константа может быть строкой, числом и вычисляемым выражением, если значение выражения возможно вычислить на этапе компиляции, то есть если константное выражение использует только константы: числовые или именованные. Ниже примеры правильно объявленных констант.
CONST
a=2.3454;
b='ffff';
g=67;
c=g+a;
Константа ‘a’ есть действительное число, константа ‘b’ строка символов, константа ‘g’ – целое число, константа ‘c’ представляет собой константное выражение, значение которого будет вычислено на этапе компиляции, на том основании, что значения констант ‘g’ и ‘a’ известны к моменту расчета константы ‘c’. Результатом вычисления будет действительное число. Ключевое слово CONST помечает блок описания констант.
Переменные
Переменная – это величина, чье значение определяется в процессе работы программы и может быть изменено. Для объявления переменной, кроме имени необходимо определить тип. Объявление выглядит следующим образом:
VAR
Имя переменной: Тип
Ключевое слово VAR помечает блок описания переменных, после VAR располагается список переменных. Тип переменной это либо один из базовых типов, либо сложный тип, либо тип определенный программистом.
Базовые
типы КП
§ BOOLEAN логические значения TRUE и FALSE
§ SHORTCHAR литеры набора Latin?1 (0X .. 0FFX)
§ CHAR литеры набора Unicode (0X .. 0FFFFX)
§ BYTE целые
§ SHORTINT короткие целые
§ INTEGER целые
§ LONGINT длинные целые
§ SHORTREAL короткие вещественные числа
§ REAL вещественные числа
§ SET множества целых чисел из диапазона от 0 до MAX(SET)
КП – жестко типизируемый язык. Это означает, что нельзя значение любой переменной присвоить любой другой переменной. Компилятор имеет свое представление о том, какой тип какому может соответствовать и некоторые из присвоений окажутся запрещенными. Например, если имеет место следующее объявление:
a: INTEGER;
b: REAL;
c: LONGINT
то
b:=a правильно
a:=b ошибка
c:=b ошибка
b:=c правильно
Общее же правило таково:
Больший тип := Меньший тип – есть законное присвоение.
Под большим и соответственно меньшим типом понимаются типы, требующие больше (соответственно меньше) памяти. Проще говоря, переменную A можно присвоить переменной B в том случае, если для A необходимо памяти столько же, сколько для В или меньше. Это называется структурная эквивалентность. Но данное правило действует только для числовых типов. Символьные и логические переменные присваивать числовым (и наоборот) нельзя.
Тип массив
Синтаксис:
Имя = ARRAY
N1, N2, ….Nm OF Type
N1, N2, ….Nm – Верхние границы индексов. Значения индексов находятся в интервале от 0 до Ni
Type – тип элементов массива. Один из базовых типов или собственных, созданных программистом.
Примеры
объявлений
a: ARRAY 5 OF INTEGER – массив из пяти целых чисел
a: ARRAY 5, 5 OF REAL – двумерный массив из 25 действительных чисел
Необходимо помнить, что КП жестко типизируемый язык. Это означает, обязательное выполнение ряда правил для присваивания. Для присваивания элементов массивов правила проверки типов такие же, как и для присваивания обычных переменных. Для присваивания массива (как целого) другому массиву правила несколько жестче. Если например дано такое объявление:
a: ARRAY 5 OF
INTEGER;
b: ARRAY 5
OF INTEGER;
то выполнение следующего присваивания:
a:=b;
будет объявлено ошибочным. Объявленные типы, хотя внешне и выглядят одинаково, будут признаны компилятором разными. Тот же оператор присваивания окажется законным при следующем объявлении:
a, b: ARRAY
5 OF INTEGER;
Второй вариант объявления, который компилятор воспримет, как эквивалентное выглядит так:
a: MyType;
b: MyType;
или a,b: MyType;
где MyType это собственный тип созданный программистом. Для нашего случая
MyType=ARRAY
5 OF INTEGER;
Подробнее о собственных типах несколько позже.
Компилятор берет на себя ряд функций по отслеживанию правильного использования индексов. Например, если дано следующее объявление:
a: ARRAY 5
OF INTEGER;
то следующий оператор присваивания
a[7]:=1;
будет объявлен, как ошибочный. Но необходимо помнить, что во время исполнения программы компилятор уже не работает, поэтому выйти за границы объявления массива достаточно просто. Это можно сделать например вот так:
n:=8;
a[n]:=1;
эта группа операторов не содержит ошибки с точки зрения компилятора, но тем не менее, здесь явно происходит выход за границы определения массива, что приведет к ошибке во время исполнения программы.
Если в объявлении массива не указана его длина, то это называется открытый массив. Такой тип массива может быть использован только как базовый тип для указателя.
Пример объявления открытого массива:
a: ARRAY OF
INTEGER;
Тип
запись
Синтаксис:
Имя = RECORD
список полей
END;
Список полей это список любых допустимых в КП объявлений величин. Пример объявления:
a: RECORD
b:
INTEGER;
c: ARRAY
7 OF CHAR;
END;
Доступ к элементу записи осуществляется через точку. Вот так:
Имя записи . Имя компонента
Для нашего примера это будет выглядеть так:
a.b:=1;
a.c[1]:=’d’;
Запись может быть элементом массива. Пример:
a: ARRAY 5
OF RECORD
a: INTEGER;
f: ARRAY 5 OF BYTE;
END;
В этом случае доступ к, например, компоненту f может быть выполнен следующим образом:
a[1].f[1]:=1;
Указательный
тип
Синтаксис:
Имя = POINTER
TO Type.
Переменные, имеющие указательный тип, принимают в качестве значений указатели на переменные некоторого типа, каковой называется базовым типом и должен быть типом записей или типом массивов.
В момент объявления, память под переменную не выделяется. Выделение памяти производится в момент создания переменной посредством процедуры NEW. При этом, если базовый тип представляет собой массив с заданной длиной или тип записи, то следует выполнять оператор NEW(Указатель), если же базовый тип – это открытый массив, то следует выполнять оператор NEW(Указатель, n1, n2,…nm) где список величин записанных после Указателя это список длин по каждой из размерностей создаваемого массива.
Тип
цепочек литер
Значения типов цепочек литер - последовательности литер, оканчивающиеся нуль-литерой (0X). Длина цепочки — это количество литер в ней, исключая нуль-литеру. Цепочки могут либо быть константами, либо храниться в массиве литерного типа.
Тип
определенный программистом
Собственный тип – это тип, сконструированный из имеющихся типов. Общий вид описания типа выглядит следующим образом:
TYPE
Имя типа = Описание типа
Например, в качестве описания типа можно взять описание массива:
mas
= ARRAY 10 OF REAL
Идентификатор mas обозначает не новую переменную, а новый тип, и уже его можно использовать для объявления новых переменных. Например, следующее объявление:
VAR
a:mas;
будет объявлением массива, несмотря на то, что описание массива явным образом здесь уже отсутствует. В создании нового типа могут участвовать не только базовые типы и сложные, но и собственные типы программиста созданные ранее. Пример ниже:
TYPE
a=ARRAY
10 OF INTEGER;
b=ARRAY
10 OF a;
VAR
c:b;
d:a;
В данном случае объявлены две сложные конструкции ‘d’ – массив из 10 целых чисел и ‘c’ массив из 10 массивов целых чисел.
Операции
и выражения
Логические
операции
OR логическое ИЛИ
& логическое И
~
отрицание
Эти операции применимы к операндам типа BOOLEAN и дают результат типа BOOLEAN. Второй операнд логического ИЛИ вычисляется только если результат первого равен FALSE. Второй операнд логического И вычисляется, только если результат первого равен TRUE.
Арифметические операции
+ сумма
- разность
* произведение
/ вещественное частное
DIV целое частное
MOD остаток
Операции +, -, * и / применимы к операндам числовых типов. Типом результата будет REAL в случае операции деления (/) или если один из операндов имеет тип REAL. В противном случае типом результата будет SHORTREAL, если тип одного из операндов — SHORTREAL, LONGINT если тип одного из операндов — LONGINT, или INTEGER в любом другом случае. Операции DIV и MOD применимы только к целым операндам.
Операции над множествами
+ объединение
- разность (x - y = x * (-y))
* пересечение
/ симметричная разность (x / y = (x-y) + (y-x))
Отношения
= равно
# неравно
< меньше
<= меньше или равно
> больше
>= больше или равно
IN принадлежность множеству
IS проверка типа
Выражения в КП составляются из операндов и операций. Операндом называется величина, именуемая либо простым, либо составным именем, либо это может быть константное выражение. Операции, применяемые в выражении должны соответствовать типу операндов. Выполнение операций осуществляется в соответствии с их приоритетом, последовательность операций с одинаковым приоритетом выполняется слева направо.
Циклические
конструкции КП
Цикл с
параметром
Данную форму цикла иногда еще называют циклом с шагом. Его функциональное назначение – отсчитать некоторое количество операций выполнения тела цикла. Телом же цикла называется последовательность команд записанных между заголовком и ключевым словом END завершающим запись цикла. Параметр цикла часто называют управляющей переменной, но мы для краткости обозначения будем использовать термин «параметр»
Синтаксис:
FOR параметр
:= выражение1 TO выражение2 BY выражение3
DO
Тело цикла
END;
При первом входе в цикл, выполняется расчет всех выражений заголовка. Результаты расчета запоминаются и изменить значения выражений в процессе работы тела цикла уже нельзя. Рассмотрим следующий пример.
b:=10;
FOR
a:=1 TO b DO
b:=6;
END;
Тело данной циклической конструкции будет выполнено 10 раз, несмотря на то, что переменная b являющаяся выражением конечного значения параметра изменяется в теле цикла. Точно также на процесс выполнения не окажет влияния изменение и других выражений. Однако воздействие на параметр окажет существенное влияние на ход выполнения. Например, следующий цикл:
FOR
a:=1 TO 9 DO
a:=a+1;
END;
будет исполняться менее чем 9 раз. Однако, воздействие на параметр чревато проблемами, так как логика изменения параметра существенно изменится. А если тело цикла реализует собой сложную логику, то уследить за параметром может оказаться непростой задачей. Поэтому, если есть необходимость изменять параметр с каким-то шагом, то лучше воспользоваться ключевым словом BY. Тогда, например, предыдущий вариант цикла может выглядеть так:
FOR a:=1 TO 9 BY 2 DO
END;
Если же процесс изменения параметра несет в себе более сложную логику, чем изменение с фиксированным шагом, то есть смысл подумать о использовании других форм цикла.
Циклы с параметром могут вкладываться друг в друга, как впрочем и любые другие языковые конструкции, но так как цикл с параметром имеет в своем описании особенную переменную, это создает небольшую проблему, с которой, начинающие программисты часто сталкиваются. Рассмотрим пример:
FOR
a:=1 TO 10 DO
FOR
a:=1 TO 10 DO
END;
END;
Данная конструкция представляет собой вложенный цикл. Видимо предполагается, что внешний цикл должен исполнятся 10 раз и для каждого шага внешнего цикла внутренний также должен исполняться 10 раз. Итого, внутренний цикл должен исполняться 100 раз. Однако, этого не произойдет. Внешний цикл завершится одновременно с завершением первого прохода внутреннего, так как обоими циклами управляет одна и та же переменная. Поэтому для вложенных циклов с параметром необходимо определять различные управляющие переменные. Беспроблемная запись приведенного выше примера будет такой:
FOR b:=1 TO 10 DO
FOR
a:=1 TO 10 DO
END;
END;
Сейчас внутренний цикл будет выполнен 100 раз. Циклы с параметром могут сколь угодно глубоко вкладываться друг в друга, но вы должны помнить, что каждое вложение в разы увеличивает количество выполняемых операций. То есть структура из большого количества вложений может потребовать значительного времени на свое выполнение.
Выражения для начального и конечного значения параметра могут быть только целыми величинами. Примеры:
FOR
a:=b TO 10 DO
END;
ошибка если b не целое число
FOR a:=1.8 TO 10 DO
END;
ошибка, так как начальное значение выражения не целое число.
FOR
a:=b/2 TO 10 DO
END;
ошибка, даже если b есть целое, так как результат вычисления b/2 действительный. Все эти примеры можно повторить и для выражения конечного значения параметра. С выражением шага дело обстоит еще более строго. Выражение для шага, может быть только константой. Это означает, что
FOR
a:=1 TO 10 BY b DO
END;
будет ошибкой независимо от типа величины b. Единственно возможно использовать величину по имени, если она объявлена как константа (см. раздел «Величины в КП»)
Цикл с
предусловием
Данная форма цикла предписывает выполнять последовательность команд до тех пор, пока истинно условие, записанное после ключевого слова WHILE.
Синтаксис:
WHILE условие
DO
Тело цикла
END;
§ В данной форме цикла, условие является условием продолжения цикла, то есть, пока условие истинно, тело цикла выполняется.
§ Цикл называется циклом с предусловием, это означает, что условие проверяется до выполнения тела цикла. Это в частности означает, что тело цикла может быть не выполнено ни разу.
Циклы по условию очень существенно отличаются от цикла по параметру именно тем, что нет никаких специальных выражений вычисляемых по особым правилам. Условие цикла, это любое выражение, которое может в КП считаться условием. Все переменные входящие в условие могут совершенно произвольным образом изменяться в теле цикла, и эти изменения окажут влияние на процесс работы цикла.
Естественно надлежит следить, чтобы выражение условия содержало в себе величины изменяемые в теле. В противном случае легко создать ситуацию, в которой цикл никогда не закончится. Пример:
b:=1;
WHILE b=1 DO
a:=b*2;
END;
Данный цикл, очевидно, зависнет, так как он выполняется пока b=1. Величина b принимает значение 1 до входа в цикл и больше не изменяется, следовательно, условие продолжения цикла будет всегда истинным. Вообще, необходимо сказать, что циклы по условию являются главным источником зависания программ. Причина этого проста. Изменение управляющей переменной в цикле с параметром описано явным образом в заголовке цикла и управляющая переменная одна. Величин влияющих на условие продолжения цикла WHILE может быть много и логика их изменения может быть достаточно хитроумной, следовательно, возможностей для ошибки в циклах по условию значительно больше, но и возможностей по управлению процессами они также предоставляют существенно больше.
Вторая проблема цикла с предусловием это вход в тело цикла. Нельзя забывать, что для выполнения тела цикла хотя бы один раз условие должно быть истинным. Поэтому инициализация переменных участвующих в условии обязательно должна стать заботой программиста.
Цикл с
постусловием
Данная форма цикла предписывает выполнять последовательность команд до тех пор, пока не станет истинно условие, записанное после ключевого слова UNTIL.
Синтаксис:
REPEAT
Тело цикла
UNTIL условие;
§ В данной форме цикла, условие является условием завершения цикла, то есть, тело цикла выполняется до тех пор, пока условие не станет истинным.
§ Цикл называется циклом с постусловием, это означает, что условие проверяется после выполнения тела цикла. Это в частности означает, что тело цикла будет выполнено по крайней мере один раз, не зависимо от результатов проверки условия.
Выше было описано два отличия от цикла с предусловием, все остальное, что было сказано о цикле WHILE верно и для цикла REPEAT UNTIL. Единственно, что следует отметить это возможность формировать условие завершения целиком в теле цикла. Если цикл с предусловием требует инициализации переменных входящих в условие, то здесь в этом нет жесткой необходимости.
Безусловный
цикл
Единственная форма цикла не требующая никаких условий для своего продолжения или завершения.
Синтаксис:
LOOP
Тело цикла
END;
Тело цикла, здесь выполняется фактически бесконечно. Конечно, в этом мало смысла, поэтому КП предлагает специальные возможности для прерывания процессов. Например, прервать выполнение такого цикла можно командой EXIT. Пример см. ниже. Отличительная особенность безусловного цикла от циклов по условию, это то, что цикл можно прерывать в нескольких точках (циклы по условию также можно прерывать не обращая внимания на условие, но тогда они просто теряют смысл). Это означает, что для прерывания нет необходимости выполнять все тело цикла. Кроме того сложное условие прерывания можно разбить на несколько более простых, проверяемых в более удобных для этого точках.
Замечание
о эквивалентности циклов.
В разных ситуациях, полезность описанных выше форм циклов различна. Для каждой формы можно найти случаи, в которых именно эта форма даст наиболее краткую или наиболее эффективную запись. Однако все конструкции циклов эквивалентны в том смысле, что все, что можно сделать с использованием одной формы можно сделать и с помощью другой. Простой пример. Рассмотрим цикл с параметром и построим эквивалентные ему циклы других форм:
FOR
i:=1 TO 10 DO
END;
В форме цикла с предусловием:
i:=1;
WHILE
i<=10 DO
i:=i+1;
END;
В форме цикла с постусловием:
i:=1;
REPEAT
i:=i+1;
UNTIL i>10;
В форме безусловного цикла:
i:=1;
LOOP
i:=i+1;
IF
i>10 THEN EXIT; END;
END;
Из этих примеров хорошо видно, как преобразовать цикл по параметру в форму условного или безусловного цикла. Достаточно описать все части заголовка. А именно выражение для начального значения параметра необходимо записать до цикла. В условии цикла необходимо прописать выражение для завершения цикла и наконец в теле цикла записывается выражение для изменения значения параметра.
Преобразование условных форм цикла в цикл по параметру далеко не так элементарно, что говорит о большей универсальности условных циклов.
В безусловном цикле используется конструкция условного перехода, об этой конструкции почитайте соответствующий раздел данного пособия, здесь же только упомянем, что конструкция IF THEN не является обязательной составляющей безусловного цикла, просто в данном примере иначе прерывание циклического процесса организовать не получится.
Условный
оператор и оператор выбора
Оператор
IF THEN ELSE
Данный оператор называется условным, потому, что он позволяет изменить ход передачи управления между операторами по результатам проверки условия.
Синтаксис:
IF условие THEN последовательность команд ELSE последовательность команд
END;
Условие – это любое условие допустимое в КП. Ограничений на запись последовательности команд не существует. В этой последовательности могут участвовать любые операторы, в том числе циклы и другие условные операторы, то есть последовательность команд может быть сколь угодно сложным фрагментом программы.
Ключевое слово ELSE и следующая за ним последовательность команд не являются обязательными. Если слово ELSE присутствует в записи условного оператора, то выбор производится между двумя альтернативами. При истинном условии, выполняется последовательность команд, записанная после THEN, при ложном условии выполняется последовательность команд записанная после ELSE. Если ELSE отсутствует, то при истинном условии выполняется последовательность команд, записанная после THEN, если же условие ложно, то управление передается на оператор следующий после ключевого слова END.
Обратите внимание, что в любом случае выбор происходит между двумя альтернативами. Это требует внимательного анализа условия, если ситуация допускает более чем два взаимоисключающих вывода, то необходимо подумать о более сложной конструкции, например о вложенных условиях.
Примеры
правильного синтаксиса:
IF
a=1 THEN b:=2 ELSE b:=3;
END;
IF
a=1 THEN b:=2;c:=3; ELSE b:=3;c:=4;
END;
IF
a=1 THEN b:=2; c:=3;
END;
Условие, используемое в условном операторе может быть сложным, то есть оно может быть логическим выражением состоящим из простых условий, связанных логическими операциями. О сложных выражениях читайте раздел «величины и выражения КП».
Условный оператор можно использовать для построения сложных условных конструкций. Например:
IF
a=1 THEN
IF
b=2 THEN c:=3;
END;
END;
В этом условном операторе команда c:=3 выполняется только в том случае, если верно условие внешнего оператора и условие внутреннего. Эту форму правда возможно записать с помощью логических операций несколько короче:
IF
(a=1) & (b=2) THEN c:=3;
END;
& - операция – логическое И. Обратите внимание на необходимость заключать простые условия в круглые скобки. В данном случае логическая операция упростила запись. В общем же случае выбор между сложным условием и вложенным условным оператором должен выполнятся исходя из потребностей логики фрагмента программы.
Ключевое
слово ELSIF
Есть еще одна возможность для записи сложного условия, это ключевое слово ELSIF, оно не новый оператор, это короткая запись оператора ELSE IF необходимого для записи сложного условия. Ниже пример правильного использования.
IF
a=1 THEN c:=3;
ELSIF
a=2 THEN c:=4;
ELSIF
a=3 THEN c:=5;
END;
Дополнительное ключевое слово ELSIF предназначено, фактически, для построения вложенного условного оператора, но оно немного упрощает запись оператора, делает её короче.
Оператор
CASE
Назначение оператора – выбор между несколькими альтернативами.
Синтаксис:
CASE выражение OF
список меток: последовательность команд
| список меток: последовательность команд
…..
…..
ELSE последовательность команд
END;
Оператор CASE указывает выбор и выполнение последовательности команд в зависимости от значения выражения, которое далее будем называть переключателем. Сначала вычисляется выражение переключателя, затем выполняется та последовательность команд, чей список меток содержит полученное значение. Выражение выбора должно иметь целый или литерный тип, который включает значения всех меток выбора. Метки выбора — константы, и никакое значение не может встречаться более одного раза. Если значение выражения не встречается в качестве метки, то выполняется последовательность команд, следующая за ключевым словом ELSE, если таковая имеется, в противном случае программа аварийно останавливается.
Примеры
правильного синтаксиса:
Пример
1:
CASE
a OF
1:
b:=2;
| 2:
b:=3;
| 3:
b:=4;
END;
Пример
2:
CASE
a OF
1:
b:=2; c:=1;
| 2:
b:=3; c:=5;
| 3: b:=4;
END;
Пример
3:
CASE
a OF
1:
b:=2; c:=1;
| 2:
b:=3; c:=5;
| 3:
b:=4;
ELSE
b:=12;
END;
Пример
4
CASE
a OF
1,6,7:
b:=2; c:=1;
|
2,12,34: b:=3; c:=5;
| 3:
b:=4;
ELSE
b:=12;
END;
Пример
5:
CASE
a OF
'1','6':
b:=2; c:=1;
|
'a': b:=3; c:=5;
|
'3': b:=4;
ELSE
b:=12;
END;
Процедуры
Описание
процедуры
Синтаксис:
Имя процедуры(список формальных параметров): тип возвращаемого значения
Тип возвращаемого значения может отсутствовать. Если процедура все же возвращает какое-либо значение, то в теле процедуры должен быть хотя бы один оператор RETURN. Процедура может содержать свой список переменных. Переменные данного списка называются локальными переменными. Память под локальные переменные выделяется в момент вызова процедуры и очищается после выхода. Следовательно, значения локальных переменных доступны только внутри процедуры и их время жизни совпадает со временем работы процедуры.
Вызов
процедуры
Синтаксис:
Имя процедуры(список фактических параметров)
Вызов процедуры активизирует процедуру. Если описание процедуры содержит список формальных параметров, то вызов должен содержать список фактических параметров, которые передают значения соответствующим формальным параметрам из списка данного в описании процедуры (см. гл. 10). Соответствие устанавливается по положению параметров в списках фактических и формальных параметров.
Примеры
вызова процедуры:
Пример1.
Процедура без параметров, не
возвращающая результата
MODULE
example;
PROCEDURE
p;
BEGIN
END p;
PROCEDURE
Work*;
BEGIN
p;
END Work;
END example.
Пример
2. Процедура с параметрами
возвращающая значение
MODULE
example;
PROCEDURE
p(a:INTEGER):INTEGER;
BEGIN
RETURN
a*2;
END p;
PROCEDURE
Work*;
VAR
y:INTEGER;
BEGIN
y:=p(5);
END Work;
END example.