Глава 5. ОПЕРАТОРЫ ЯЗЫКА
Турбо Паскаль-7
Операторы языка описывают некоторые алгоритмические действия, которые необходимо
выполнить для решения задачи. Тело программы можно представить как последовательность
таких операторов. Идущие друг за другом операторы программы разделяются точкой с
запятой.
Все операторы языка Паскаль можно разбить на две группы: простые и структурированные.
5.1. Простые операторы
Простыми являются те операторы, которые не содержат в себе других операторов. К ним
относятся:
- оператор присваивания;
- обращение к процедуре;
- оператор безусловного перехода GOTO;
- пустой оператор.
Обращение к процедуре будет рассмотрено в п. 10.1, остальные - в данном разделе.
5.1.1. Оператор присваивания
С помощью этого оператора переменной или функции присваивается значение выражения.
Для этого используется знак присваивания := , слева от которого записывается имя
переменной или функции, которой присваивается значение, а справа - выражение,
значение которого вычисляется перед присваиванием.
Допустимо присваивание значений переменным и функциям любого типа, за исключением
типа файл. Тип выражения и тип переменной (или функции) должны быть совместимы
для присваивания (см. п. 9.3).
Пример.
X := Y;
Z := А + В;
Res := (I>0) and (I<100);
I := Sqr(J) + I*К;
5.1.2. Оператор безусловного перехода GOTO. Использование меток
Оператор GOTO позволяет изменить стандартный последовательный порядок выполнения
операторов и перейти к выполнению заданного оператора. Оператор, на который
происходит переход, должен быть помечен меткой. Эта же метка должна быть указана
и в операторе GOTO. Метки, используемые в Turbo Pascal, могут быть двух типов:
- целым числом в пределах от 0 до 9999;
- обычным идентификатором.
Все используемые метки должны быть перечислены в разделе объявления меток,
начинающемся зарезервированным словом label, например:
label 1, 2, Metka;
Одной меткой можно пометить только один оператор. Метка от помеченного оператора
отделяется двоеточием.
Использовать оператор GOTO следует крайне осторожно. Широкое его применение без
особых на то оснований ухудшает понимание логики работы программы. Безусловный
переход можно осуществлять далеко не из каждого места программы и не в любое место
программы.
Так, нельзя с помощью этого оператора перейти из основной программы в подпрограмму
или выйти из подпрограммы, не рекомендуется осуществлять переход внутрь
структурированного оператора, т. к. он может дать неправильный результат, и т. д.
Более подробно о таких ограничениях см. [ 1 ].
Пример. Найти частное от деления целых чисел.
program EXAMPLE4;
label Out; {описание метки}
var X, Y, Res: Integer; {описание переменных}
begin
Write('Введите делимое:'); {вывод сообщения на экран}
ReadLn(X); {чтение числа}
Write('Введите делитель:'); {вывод сообщения на экран}
ReadLn(Y); {чтение числа}
if Y = 0 then
begin {это - Составной оператор, см. п. 5.2.1}
WriteLn('Деление на ноль недопустимо! Выхожу...');
goto Out; {выход при нулевом делителе}
end;
Res:=X div Y;
WriteLn('Частное равно: ',Res);
Out: {метка "пустого" оператора}
end.
5.1.3. Пустой оператор
Пустой оператор не выполняет никакого действия и никак не отображается в программе
(за исключением, быть может, метки или точек с запятыми, отделяющих пустой оператор
от предыдущих или последующих операторов).
Он может потребоваться для осуществления на него безусловного перехода
(см. пример в п. 5.1.2).
5.2. Структурированные операторы
Структурированными являются такие операторы, которые включают в себя другие операторы.
К структурированным операторам относятся:
- составной оператор;
- условный оператор IF;
- условный оператор CASE;
- оператор цикла REPEAT;
- оператор цикла WHILE;
- оператор цикла FOR;
- оператор над записями WITH.
Оператор над записями WITH будет рассмотрен в разделе 6.4, остальные - в данном
разделе.
5.2.1. Составной оператор
Составной оператор представляет собой совокупность последовательно выполняемых
операторов, заключенных в операторные скобки begin и end:
begin
<оператор 1>;
<оператор 2>;
. . .
<оператор N>
end;
Он может потребоваться в тех случаях, когда в соответствии с правилами построения
конструкций языка можно использовать ОДИН оператор, а выполнить нужно несколько
действий. В такой составной оператор входит ряд операторов, выполняющих требуемые
действия.
В дальнейшем везде, где будет указываться, что можно использовать один оператор, им
может быть и составной оператор.
Отдельные операторы внутри составного оператора отделяются друг от друга точкой с
запятой (см. пример в п. 5.1.2, где тело цикла представляет составной оператор).
Так как завершающее составной оператор слово end не является отдельным предложением,
то перед ним точку с запятой можно не ставить, в противном случае компилятор будет
считать, что перед словом end стоит пустой оператор.
Можно считать, что и само тело программы, т. к. оно заключено в операторные скобки
begin и end, тоже является составным оператором.
5.2.2. Условный оператор IF
Оператор IF реализует алгоритмическую конструкцию РАЗВИЛКА и изменяет порядок
выполнения операторов в зависимости от истинности или ложности некоторого условия.
Существует два варианта оператора:
if S then A
else В; {полная развилка}
и
if S then А; {укороченная развилка}
В этих операторах:
S - некоторое логическое выражение, истинность которого проверяется;
А - оператор, который выполняется, если выражение S истинно;
В - оператор, который выполняется, если выражение S ложно.
Так как условный оператор IF является единым предложением, ни перед then, ни перед
else точку с запятой ставить нельзя. Примеры использования оператора:
if X < 0 then X := -Y;
if X < 1.5 then Z := X + Y else Z := 1.5;
Пример. Ввести целое число и вывести символ, соответствующий этому числу в
кодировке ASCII, если такой символ есть, или сообщение, что такого символа
нет (управляющие символы не учитываются).
program EXAMPLE5;
var X: Integer;
begin
Write('Введите целое число: ');
ReadLn(X);
if (X > 31) and (X < 256) then
WriteLn('Соответствующий символ - ', Chr(X)) else
WriteLn('Такого символа НЕТ')
end.
5.2.3. Условный оператор CASE
С помощью этого оператора можно выбрать вариант из любого количества вариантов.
Структура этого оператора в Turbo Pascal:
case S of
Cl:<оператор1>;
C2:<оператор2>;
. . .
CN:<операторN>;
else <оператор>
end;
В этой структуре:
S - выражение порядкового типа, значение которого вычисляется;
Cl, С2, ..., CN - константы, с которыми сравнивается значение выражения S;
<оператор1>, <оператор2>, ..., <операторN> - операторы, из которых выполняется тот,
с константой которого совпадает значение выражения S;
<оператор> - оператор, который выполняется, если значение выражения S не совпадает
ни с одной из констант С1, ..., CN.
Ветвь оператора else является необязательной. Если она отсутствует и значение
выражения S не совпадет ни с одной из перечисленных констант, весь оператор
рассматривается как пустой. В отличие от оператора IF перед словом else точку
с запятой можно ставить.
Если для нескольких констант нужно выполнять один и тот же оператор, их можно
перечислить через запятую (или даже указать диапазон, если возможно), сопроводив
их одним оператором.
Пример.
case I of
0,2,4,6,8: WriteLn('Четная цифра');
1,3,5,7,9: WriteLn('Нечетная цифра');
10..100: WriteLn('Число от 10 до 100');
else
WriteLnC'Отрицательное число или больше 100')
end;
Пример использования оператора CASE приведен также в п.16.3.21.
5.2.4. Оператор цикла REPEAT
Оператор цикла REPEAT организует выполнение цикла, состоящего из любого числа
операторов, с неизвестным заранее числом повторений. Тело цикла выполняется хотя бы
один раз. Выход из цикла осуществляется при истинности некоторого логического
выражения. Структура этого оператора:
repeat
<Оператор1>;
<Оператор2>;
. . .
<ОператорN>;
until S;
В этой структуре:
<Оператор1>; <Оператор2>; <ОператорN> -
выполняемые операторы, составляющие тело цикла;
S - логическое выражение, истинность которого проверяется в конце каждой итерации.
Так как слова repeat и until являются своеобразными операторными скобками, точку
с запятой перед словом until ставить не обязательно.
Пример. Усовершенствованная программа, вычисляющая сумму двух чисел
(см. пример п. 2).
program EXAMPLE6;
var
X, Y, Sum: Real;
Ch: Char;
begin
repeat {начало цикла}
Write('Введите числа X и У ');
ReadLn(X, Y);
Sum := X + Y;
WriteLn('Сумма чисел X и Y равна ',Sum);
Write('Завершить программу? ');
ReadLn(Ch);
until (UpCase(Ch) = 'Y') or (Ch = 'д') or (Ch = 'Д')
{Функция UpCase - возвращает соответствующую заглавную букву.}
end.
5.2.5. Оператор цикла WHILE
Оператор цикла WHILE организует выполнение одного оператора неизвестное заранее
число раз. Выход из цикла осуществляется, если некоторое логическое выражение
окажется ложным. Так как истинность логического выражения проверяется в начале
каждой итерации (т е раньше, чем выполняется тело), тело цикла может не выполняться
ни разу. Структура оператора цикла имеет вид:
while S do
<Оператор>;
В этой структуре:
S - логическое выражение, истинность которого проверяется в начале каждой итерации;
<Оператор> - выполняемый оператор цикла.
Пример. Найти все делители целого положительною числа
(кроме 1 и самого числа).
program EXAMPLE7;
var
X:Integer;
Half: Integer;
Divider: Integer;
i: Integer;
begin
repeat
Write ('Введите число больше нуля: ');
ReadLn(X) ;
if X <= 0 then
WriteLn('Неправильный ввод')
until X > 0;
Half := X div 2;
Divider := 2;
i := 0;
while Divider <= Half do
begin
if X mod Divider = 0 then
begin
Inc(i); {увеличение счетчика на единицу}
WriteLn(i, ' -и делитель равен; ', Divider)
end ;
Inc(Divider) {увеличение делителя на единицу}
end;
if i = 0 then
WriteLn('Делителей нет');
WriteLn('Конец решения')
end .
5.2.6. Оператор цикла FOR
Оператор цикла FOR организует выполнение одного оператора заранее известное
число раз. Существует два варианта оператора:
for <переменная цикла>:=<начальное значение> to <конечное значение> do <оператор>;
for <переменная цикла>:=<начальное значение> downto <конечное значение> do <оператор>;
В этих операторах:
<переменая цикла> - переменная порядкового типа;
<начальное значение> - выражение (порядкового типа), определяющее начальное значение
переменной цикла;
<конечное значение> - выражение (порядкового типа), определяющее конечное значение
переменной цикла (при этом значении тело цикла (т е <оператор>) выполняется
последний раз );
<оператор> - выполняемый оператор.
<начальное значение> и <конечное значение> должны быть совместимы для присваивания
с переменной цикла (см. п. 9.3).
Цикл действует таким образом:
- Сначала вычисляются и запоминаются начальное и конечное значения.
- Далее переменной цикла присваивается начальное значение.
- Затем значение переменной цикла сравнивается с конечным значением.
Причём, пока параметр цикла меньше или равен конечному значению (в первом варианте
оператора) или больше или равен конечному значению (во втором варианте), выполняется
очередная итерация; в противном случае происходит выход из цикла.
Выполнение очередной итерации включает в себя сначала выполнение <оператора>, а затем
- присваивание переменной цикла следующего большего значения (в первом варианте
оператора) или следующего меньшего значения (во втором варианте).
Естественно, что, если в первом варианте <начальное значение> больше чем
<конечное значение> или во втором варианте меньше чем <конечное значение> ,
оператор не выполняется ни разу.
После выхода из цикла <переменая цикла> становится неопределенной, за исключением
случая, когда выход из цикла был осуществлен с помощью оператора GOTO или стандартной
процедуры Break.
Пример.
Вывести на экран буквы от Z до А,
program EXAMPLE8;
var i: Char;
begin
for i := 'Z' downto 'A' do
Write(i);
WriteLn
end.
Пример. Вычислить 101 значение sin x с заданным шагом и вывести первое
отрицательное значение синуса.
program EXAMPLE9;
label 1;
var
Si: array[0..100] of Real; {массив вещественных чисел}
Step: Real;
X: Real;
i : Integer;
begin
Write('Введите шаг вычисления: ');
ReadLn(Step);
X := 0; {начальный аргумент}
for i := 0 to 100 do
begin
Si[i]:=Sin(X);
X := X + Step
end;
for i := 0 to 100 do
if Si[I] < 0 then
begin
WriteLn('Первое отрицательное значение синуса: ',
Si[i], ' Номер элемента: ', i);
goto 1;
end;
WriteLn('Нет отрицательного значения');
1: end.
5.2.7. Использование стандартных процедур Break и Continue в операторах циклов
REPEAT, WHILE и FOR
В версии 7.0 в циклах REPEAT, WHILE и FOR можно использовать две стандартные процедуры
- Break и Continue. Процедура Break позволяет досрочно выйти из цикла, не дожидаясь
выполнения условия выхода. Процедура Continue позволяет начать новую итерацию цикла,
даже если предыдущая не завершена.
Пример.
В массиве целых числел (см. п. 6.1) найти первое отрицательное число и вывести его
на экран дисплея.
program EXAMPLE10;
const N = 10;
var Mas: array[l..N] of Integer; {массив чисел}
i: Byte;
Yes: Boolean;
begin
WriteLn ('введите элементы массива'); {ввод чисел}
for i := 1 to N do
begin
Write ('Mas[', i, ' ]= ');
ReadLn(Mas[i])
end;
Yes := False; {предположим - число не найдено}
for i:= 1 to N do {поиск отрицательного числа}
begin
if Mas[i] >= 0 then
Continue; {не отрицательное => на след число}
WriteLn('Первое отрицательное число = ',Mas[i],
' Номер = ', i); {найдено число}
Yes := true;
Break; {выход из цикла}
end;
if not Yes then
WriteLn('Отрицательных чисел нет');
ReadLn
end.
