Два последовательных оператора обязательно должны разделяться точкой с запятой “;”.

Примеры простых операторов:

a := 10; b := a*5; Write( a, b );

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

Составной оператор – это последовательность операторов, перед которой стоит слово BEGIN, а после – END. Слова BEGIN и END часто именую операторными скобками.

Пример составного оператора:

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

Условный оператор IF служит для организации процесса вычислений (изменения последовательности выполнения операторов) в зависимости от какого-либо логического условия.

Если условие истинно, то выполняется оператор (простой или составной), следующий за словом THEN, в противном случае, когда условие ложно, будет выполняться оператор, следующий за словом ELSE. Альтернативная ветвь ELSE может отсутствовать, если в ней нет необходимости. В таком “усеченном” варианте, в случае, если условие оказывается ложным, ничего не происходит и выполняется оператор следующий за условным оператором IF.

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

VAR
  x, y : real;
BEGIN
  Write(‘Введите значение аргумента: ’); ReadLn(x);
  IF x>0 THEN y := x
         ELSE y := 0;
  Write(‘Значение функции y = ’, y)
END.

Условные операторы могут быть вложенными друг в друга:

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

При вложениях условных операторов самое главное – не запутаться в вариантах сочетаний условий (отчасти этому может помочь ступенчатая форма записи операторов). Всегда действует правило: альтернатива ELSE считается принадлежащей ближайшему условному оператору IF, не имеющему ветви ELSE. Например:

По записи может сложиться впечатление, что Оператор_Б будет выполняться только при “невыполнении” Условия1. Но на самом деле он будет отнесен к Условию2 и выполнится только при выполнении Условия1 и невыполнении Условия2! Если необходимо, чтобы Оператор_Б выполнялся именно при невыполнении Условия1, то единственный выход таков: заключить вложенный (усеченный) оператор IF в операторные скобки begin…end:

IF Условие1 THEN begin
                   if Условие2 then Оператор_А
                 end
            ELSE Оператор_Б;

Оператор варианта необходим в тех случаях, когда в зависимости от значения какой-либо переменной нужно выполнить те или иные операторы (простые или составные). Если вариантов всего два, то можно обойтись и оператором IF. Но если их, например, десять? В этом случае оптимален оператор варианта CASE.

Оператор (Оператор1, Оператор2, …) в конкретном варианте может быть как простым, так и составным.

PROGRAM Example_CASE_1;
VAR A : integer;
BEGIN
    Write(‘Введите оценку: ‘); Read(A);
    CASE A OF
        2 : Write(‘неудовлетворительно’);
        3 : Write(‘удовлетворительно’);
        4 : Write(‘хорошо’);
        5 : Write(‘отлично’)
        ELSE Write(‘Ошибка!’)
    END;
END.

Здесь в зависимости от значения переменной А на экран выводится наименование оценки. Наличие варианта ELSE обеспечивает вывод сообщения об ошибке в случае, когда введено число вне интервала 2..5.

PROGRAM Example_CASE_2;
VAR Hour : integer;
BEGIN
    Read( Hour );
    CASE Hour OF
        0, 24 : Write(‘Полночь’);
        1..4 : Write(‘Ночь’);
        5..7 : Write(‘Раннее утро’);
        8..11 : Write(‘Утро’);
        12 : Write(‘Полдень’);
        13..17 : Write(‘День’);
        18..23 : Write(‘Вечер’)
        ELSE Write(‘Введено число вне диапазона 0..24!’)
    END;
END.

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

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

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

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

VAR
  Factorial, N : Integer;
BEGIN
  Factorial := 1; {стартовое значение факториала =0! }
  N := 1;         {стартовое значение для условия цикла }
  WHILE N<=10 DO                {заголовок цикла, условие }
   begin                        {начало тела цикла }
     Factorial := Factorial*N; {вычисление факториала N! }
     N := N + 1                 {N должно меняться в цикле}
   end;                         {конец тела цикла }
  WriteLn(’10!= ’,Factorial);  {вывод результата расчета }
END.

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

Оператор REPEAT…UNTIL имеет две части: начальную (слово REPEAT) и завершающую (слово UNTIL), которые охватывают группу операторов, составляющих тело цикла. Поэтому необходимости в использовании составного оператора для построения тела цикла из нескольких простых операторов не возникает.

Принципиальное отличие оператора REPEAT…UNTIL от оператора WHILE в том, что проверка условия производится не перед началом выполнения тела цикла, а после его выполнения, когда решается вопрос, повторить ли еще раз действия. Поэтому тело цикла всегда выполняется по крайней мере один раз.

VAR
  N : Integer;
BEGIN
  . . .
  REPEAT
    Write(‘Введите целое число от 0 до 10: ’);
    ReadLn(N);
  UNTIL (N>=0) and (N<=10);
  . . .
END.

В этом примере программа будет запрашивать ввод числа до тех пор, пока пользователь не введет “правильное” число.

Оператор цикла с параметром вводится для организации “строгих” циклов, которые должны быть проделаны заданное число раз. Кроме того, циклы с параметром позволяют организовать автоматическое изменение значения некоторой переменной в определенном диапазоне.

или

VAR i : integer;
BEGIN
  FOR i := 1 TO 10 DO Write(i:5);
  FOR i := 5 DOWNTO 0 DO Write(i:5)
END.

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

CONST n = 10;
      m = 3;
VAR i,
    k : integer;
BEGIN
  k := 1;
  FOR i := k TO n DO Write(i:5);
  FOR i := (m+2) DOWNTO 0 DO Write(i:5)
END.

Выполнение цикла начинается с присваивания параметру стартового значения. Затем следует проверка, не превосходит ли параметр конечное значение (случай с TO) или не является ли он меньше конечного значения (случай с DOWNTO). Если результат проверки утвердительный, то цикл считается завершенным. В противном случае выполняется тело цикла (оператор, следующий за словом DO), и после этого параметр цикла меняет свое значение на следующее. Далее снова производится проверка значения параметра цикла, т.е. алгоритм повторяется.

FOR i := i-5 TO i+5 DO ... ;

не заслуживает никакого доверия, даже если запускается!

Операторы FOR могут быть вложенными друг в друга, например

VAR
  i,j : integer;
BEGIN
  WriteLn(‘Таблица умножения’);
  FOR i := 1 TO 10 DO begin
     FOR j := 1 TO 10 DO Write((i*j):5);
    WriteLn;
  end;
END.

VAR
  i, num : Integer;
  A : array[1..10] of Integer;
BEGIN
  . . . { Ввод элементов массива А }
  num := 0;
  FOR i:=1 TO 10 DO { Цикл для i от 1 до 10 }
   IF A[i]=0 THEN begin { если найден нулевой элемент }
                    num := i; { запоминаем его номер }
                    BREAK      { прекращаем цикл }
                  end;
  IF num <> 0 THEN WriteLn(num)
              ELSE WriteLn(‘Нулевых элементов нет’);
END.

Процедура CONTINUE вызывает переход к следующей циклической итерации игнорируя расположенные ниже операторы, составляющие тело цикла.

VAR
  CommDiv,        { кандидат в НОД }
  num1,           { первое число }
  num2 : Integer; { второе число }
BEGIN
  Write(‘Введите первое число: ’); ReadLn(num1);
  Write(‘Введите второе число: ’); ReadLn(num2);
  FOR CommDiv := num1 DOWNTO 1 DO begin
    IF (num2 mod CommDiv)<> 0 THEN CONTINUE;
    IF (num1 mod CommDiv) = 0 THEN begin
       WriteLn(‘Наибольший общий делитель: ’, CommDiv);
       BREAK
    end {if}
end {for}
END.

В примере применен цикл FOR, в котором по убывающий перебираются возможные кандидаты в наибольший общий делитель. Критерий делимости – равенство нулю остатка от деления (операция mod). Если кандидат (значение переменной CoomDiv) не является делителем числа num2, по команде CONTINUE начинается следующий проход цикла, а операторы, оставшиеся в теле цикла, не выполняются. Если число (CommDiv) оказывается делителем числа num2 и num1, что проверяется вторым оператором IF тела цикла, значит, оно – общий делитель. А поскольку перебор идет от больших к меньшим значениям, первый найденный общий делитель – наибольший. Выводим его на печать и прерываем цикл командой BREAK.

Процедура EXIT завершает работу своего программного блока. Если EXIT вызывается внутри процедуры или функции, то их работа завершается. Если EXIT вызывается в основном блоке программы, то это приводит к ее завершению.

Процедура HALT, или более полно HALT(n),   завершает работу программы с кодом завершения n. Этот код впоследствии может быть проанализирован, в частности командой IF ERRORLEVEL в среде MS-DOS. Значение ERRORLEVEL после остановки программы будет равно значению n. Вызов процедуры HALT без параметра эквивалентен вызову HALT(0).

На основе процедуры HALT можно легко построить программу, например ASK.PAS, для организации диалога в BAT-файлах MS-DOS.

После компиляции получаем файл – AKS.EXE

@ECHO OFF
CLS
ECHO Сейчас вы можете:
ECHO 0 - Завершить работу
ECHO 1 – Запустить Norton Commander
ECHO 2 – Отформатировать жесткий диск
ECHO Ваш выбор ?
ask.exe
IF ERRORLEVEL 0 GOTO end
IF ERRORLEVEL 1 GOTO startNC
IF ERRORLEVEL 2 GOTO formatHDD
GOTO end
:startNC
   c:\nc\nc
:formatHDD
   format C: /s
:end