Программа на Delphi
	
	
|J:=-L - 200;              |250                             | 
|B:= J > L;                |False                           | 
|B:= (J < L) and (Q[5] =   |True                            | 
|'i');                     |230                             | 
|Rec.A:= J-20;             |Ошибка. Несоответствие типов    | 
|Rec.B:= 20;               |'d\\d'                          | 
|Rec.B:= S[1]+S[3]+'\d';   |                                | 
                    11.2. Оператор безусловного перехода 
Этот оператор выполняет передачу управления оператору, которому 
предшествует метка. Синтаксис оператора: 
                                 Goto Метка; 
Язык допускает в качестве меток использовать имя или значение целого типа 
из диапазона 1 .. 9999. 
При использовании операторов перехода необходимо придерживаться следующих 
правил: 
   1. Все метки, используемые в блоке, должны быть описаны словом Label. 
      Пример оператора описания меток: 
      Label 1, 2, Met1, Met2, Met3; 
   2. Метка должна располагаться в том же блоке, что и оператор, который ею 
      помечен. 
   3. Недопустим переход к метке внутрь структурного оператора (например, 
      внутрь цикла, минуя его заголовок). Компилятор не реагирует на эту 
      ситуацию, однако поведение программы может быть непредсказуемо. 
      Недопустимы также вход или выход по метке в процедурах или функциях. 
П р и м е ч а н и е. Не используйте меток, если в этом нет особой 
необходимости. В технике современного программирования использование меток 
считается правилом плохого тона, т. к. их применение часто ведет к 
составлению плохо структурированных модулей, усложняющих чтение, 
сопровождение и отладку программ. 
                    11.3. Оператор обращения к процедуре 
Этот оператор вызывает активизацию операторов, расположенных в теле 
процедуры (см. параграф 15.1). После выполнения процедуры управление 
передается к оператору, расположенному вслед за оператором процедуры. 
При вызове процедуры её формальным параметрам должны строго соответствовать 
по совместимости типов и количеству фактические параметры. 
Примеры обращения к процедурам: 
                       Val (s, r, Code); 
                       Sort (a, n * 2); 
                       SaveParameters; 
                          11.4. Обращение к функции 
Следует подчеркнуть, что не существует специального оператора обращения к 
функции (см. параграф 15.1). Обычно такое обращение производится 
посредством другого оператора, часто оператора присваивания. 
Обращение к функции активизирует ее внутренние операторы точно так же, как 
это происходит в процедурах. Принципиальное отличие между выполнением 
процедуры и функции состоит в следующем: 
    . после выполнения оператора процедуры управление передается к 
      следующему за ним оператору; 
    . после выполнения функции управление вновь передается в оператор, 
      который содержит обращение к этой функции, с целью передачи в него 
      вычисленного значения функции и для завершения вычислений внутри этого 
      оператора. 
Поясним это на примере оператора присваивания, содержащего обращение к 
функции Func8: 
                   G:= 2 * Pi * Func8(m, n, a) / Sqr (z); 
При выполнении этого оператора сначала происходит обращение к функции 
Func8. После выполнения операторов, составляющих тело этой функции, 
вычисленное значение возвращается в этот оператор, где оно используется для 
выполнения дальнейших вычислений внутри оператора. 
                     12. Стандартные процедуры и функции 
Язык содержит ряд процедур и функций, которые в практике программирования 
ипользуются наиболее часто. Расширенный список процедур и функций, которые 
могут найти применение в практике программирования, приведен в приложении. 
                     12.1. Строковые процедуры и функции 
   1. Function Length (St): LongInt; 
      Возвращает длину строки символов St, т. е. количество символов в ней 
      (не путать с размером строки). 
      St:= '1234abc'; 
      L:= Length(St); {L= 7} 
   2. Procedure Delete (St, Pos, Num); 
      Удаляет Num символов из строки St начиная с позиции Pos, если 
      PosLength (Target), то результат Target + Obj. 
      St1:= '***'; 
      St2:= '1234abc'; 
      Insert (St1, St2, 3) { St2= '12***34abc'} 
   4. Procedure Str (Value, St); 
      Преобразует значение Value числового типа в строку символов St. Value 
      может сопровождаться форматом. 
      L:=19; 
      Str (L, g); {g= '19'} 
      R:= 2.123155; 
      Str (R: 8:3, h); {h= ' 2.123' (длина 8, в дробной части 3} 
   5. Procedure Val (St, Vr, Code); 
      Преобразует строку символов St в числовую величину Vr целого или 
      вещественного типа. Code = 0, если преобразование прошло успешно, 
      иначе в Code будет записан номер первого ошибочного символа 
      конвертируемой строки, при этом значение Vr не определено. 
      St:='319'; 
      Val (St, k, Cod); {k= 319, Cod = 0} 
      St:='81yy9'; 
      Val (St, k, Cod); {k= ?, Cod = 3} 
   6. Function Copy (St, Pos, Num): String; 
      Выделяет из строки St подстроку символов длиной Num начиная с позиции 
      Pos. Если Pos>Length, то возвращает пустую строку. 
      St1:='АБВГДЕ'; 
      St2:= Copy(St1, 2, 3); {St2= 'БВГ'} 
      St2:= Copy(St1, 2, 27); {St2= 'БВГДЕ'} 
      St2:= Copy(St1, 44, 2); {возвращает пустую строку St2= ''} 
   7. Function Concat (St1, St2{, …, StN}): String; 
      Объединяет строки в одну строку. 
      St:='abc'; 
      St1:=Concat( 'sss', St, '1234'); {St1= 'sssabc1234'} 
      St1:=Concat( St, '123'); {St1= 'abc123'} 
   8. Function Pos (Obj, Target): Integer; 
      Возвращает номер символа, начиная с которого строка Obj первый раз 
      входит в строку Target. Если строка Obj отсутствует в строке Target, 
      то Pos = 0. 
      Q:= 'Иванов Сергей Петрович'; 
      H:= Pos ('Сергей', Q); {H= 7} 
      H:= Pos ('Игорь', Q); {H= 0} 
   9. Function SizeOf (Obj): Integer; 
      Возвращает размер переменной Obj. 
  10. Function FormatFloat(const Format: string; Value: Extended): string; 
      Возвращает форматированное вещественное значение в виде строки. Format 
      – формат числа, Value – число. В табл. 14 даны форматы функции 
      FormatFloat. 
                                                                  Таблица 14 
|Формат    |Описание                                                 | 
|0         |Поле для цифры. Недостающие позиции заменяются нулями    | 
|#         |Поле для цифры. Если в позиции имеется значащая цифра, то| 
|.         |оно выводится. Нули не выводятся                         | 
|,         |Разделитель целой и дробной частей                       | 
|E+, E-    |Поле разделителя тысяч, миллионов                        | 
|          |Формат представления чисел с плавающей точкой. Если "+"  | 
|;         |указан, то перед порядком выводится знак. Если указан    | 
|          |"-", то минус выводится только для отрицательных порядков| 
|          |                                                         | 
|          |Разделитель форматов                                     | 
Примеры действия форматов при конвертации числа в строку представлены в 
табл. 15. 
                                                                  Таблица 15 
|Формат            |Число 1   |Число 2     |Число 3   |Число 4  | 
|0                 |1234      |-1234       |0.5       |0        | 
|0.00              |1234      |-1234       |1         |0        | 
|#.##              |1234.00   |-1234.00    |0.50      |0.00     | 
|#,##0.00          |1234      |-1234       |.5        |0.00     | 
|#,##0.00;(#,##0.00|1,234.00  |-1,234.00   |0.50      |0.00     | 
|)                 |1,234.00  |(1,234.00)  |0.50      |Zero     | 
|#,##0.00;;Zero    |1,234.00  |-1,234.00   |0.50      |0.000E+00| 
|0.000E+00         |.234E+03  |-1.234E+03  |5.000E-01 |         | 
|#.###E-0          |1.234E3   |-1.234E3    |5E-1      |0E0      | 
                         12.2. Стандартные функции  
   1. Function Char (X: byte): Char; 
      Возвращает символ с номером X. 
      Ch:= Char(74); {Ch= 'J'} 
   2. Function Ord (X): LongInt; 
      Возвращает порядковый номер скалярного аргумента. 
      j:= Ord('J'); {j= 74} 
   3. Function Round (X: Real): LongInt; 
      Возвращает округленное до целого значение вещественного аргумента. 
      j:= Round(12.8235); {j= 13} 
   4. Function Trunc (X: Real): LongInt; 
      Возвращает целое путем отбрасывания дробной части вещественного 
      аргумента. 
                 j:= Round(12.8235); {j= 12} 
                  12.3. Арифметические процедуры и функции  
   1. Function Frac (X: Extended): Extended; 
      Возвращает дробную часть аргумента, например: 
      r:= Frac(-12.82); {r = -0.82, Frac(12.82)=0.82 } 
   2. Function Abs (X: Extended): Extended; 
      Возвращает абсолютное значение аргумента, например: 
      r:= Abs(-12.82); {r = 12.82} 
   3. Function ArcTan (X: Extended): Extended; 
      Возвращает арктангенс аргумента. 
   4. Function Cos (X: Extended): Extended; 
      Возвращает косинус аргумента. 
   5. Function Sin (X: Real): Real; 
      Возвращает синус аргумента. 
   6. Function ArcCos(X: Extended): Extended; 
      Возвращает арккосинус аргумента, значение которого должно принадле- 
      жать отрезку [-1, 1]. Возвращает значение из отрезка [0, Pi]. 
   7. Function ArcSin(X: Extended): Extended; 
      Возвращает арксинус аргумента, значение которого должно принадле-жать 
      отрезку [-1, 1]. Возвращает значение из отрезка [-Pi/2, Pi/2]. 
   8. Function ArcTan2(Y, X: Extended): Extended; 
      Возвращает арктангенс аргументов, вычисляя ArcTan(Y/X) в соответ-ствии 
      с квадрантами координатной плоскости xOy. Возвращает значение из 
      отрезка [-Pi, Pi]. 
   9. Function Exp (X: Real): Real; 
      Возвращает экспоненту аргумента. 
  10. Function Sinh(X: Extended): Extended; 
      Возвращает гиперболический синус аргумента. 
  11. Function Cosh(X: Extended): Extended; 
      Возвращает гиперболический косинус аргумента. 
  12. Function Tanh(X: Extended): Extended; 
      Возвращает гиперболический тангенс аргумента. 
  13. Function ArcSinh(X: Extended): Extended; 
      Возвращает гиперболический арксинус аргумента. 
  14. Function ArcCosh(X: Extended): Extended; 
      Возвращает гиперболический арккосинус аргумента. 
  15. Function ArcTanh(X: Extended): Extended; 
      Возвращает гиперболический арктангенс аргумента. 
  16. Function Ln (X: Real): Real; 
      Возвращает натуральный логарифм аргумента. 
  17. Function Sqr (X: Real): Real; 
      Возвращает квадрат аргумента. 
  18. Function Sqrt (X: Real): Real; 
      Возвращает квадратный корень аргумента. 
  19. Function Ceil(X: Extended):Integer; 
      Возвращает наибольшее целое аргумента. 
      Сeil(-2.8) = -2 
      Ceil(2.8) = 3 
      Ceil(-1.0) = -1 
  20. Function Floor(X: Extended): Integer; 
      Возвращает наименьшее целое аргумента. 
      Ceil(-2.8) = -3 
      Ceil(2.8) = 2 
      Ceil(-1.0) = -1 
  21. Function Dec (X, [n]: LongInt): LongInt; 
      Уменьшает значение аргумента на величину второго параметра. Если он 
      отсутствует, то уменьшает на 1. 
      J:=67; 
      K:=Dec(J); {j= 66} 
      K:=Dec(J, 13); {j= 53} 
  22. Function Inc (X, [n]: LongInt): LongInt; 
      Увеличивает значение аргумента на величину второго параметра. Если он 
      отсутствует, то увеличивает на 1. 
      J:=67; 
      K:=Inc(J); {j= 68} 
      K:=Inc(J, 13); {j= 81} 
                           12.4. Скалярные функции 
   1. Function Odd (X: LongInt): Boolean; 
      Возвращает True, если аргумент четный. 
      J:=67; 
      K:=Odd(J); {K= False} 
   2. Function Pred (X); 
      Возвращает предшествующее значение типа аргумента. 
   3. Function Succ (X); 
      Возвращает последующее значение типа аргумента. 
                         12.5. Процедуры завершения 
   1. Procedure Exit; Выход из процедуры. 
   2. Procedure Halt([Code:Word]); 
      Выход в операционную систему с кодом возврата, если он указан. 
         12.6. Процедуры и функции для работы с типами "дата/время" 
Типы TDateTime и TTimeStamp, а также производные от них типы предназначены 
для хранения даты и времени. Эти типы используются в ряде весьма полезных и 
необходимых процедур и функций для работы с датами и временем. 
   1. Function Now: TDateTime; 
      Возвращает текущую дату и время. 
   2. Function Date: TDateTime; 
      Возвращает текущую дату. 
   3. Function Time: TDateTime; 
      Возвращает текущее время. 
   4. Function DateToStr (D: TDateTime): String; 
      Преобразует дату в строку символов, например: 
      S:= DateTimeToStr(Date); {текущая дата '26.10.99'} 
   5. Function TimeToStr(T: TDateTime): String; 
      Преобразует время в строку символов, например: 
      S:= TimeToStr(Time); { текущее время '13.58.13'} 
   6. Function DateTimeToStr(DateTime: TDateTime): String; 
      Преобразует дату/время в строку символов, например: 
      S:= DateTimeToStr(Now); { текущие дата и время '26.10.99 14.01.51'} 
   7. Function DateTimeToTimeStamp(DateTime: TDateTime): TTimeStamp; 
      Конвертирует TDateTime в TTimeStamp, например: 
      TS:= DateTimeToTimeStamp(Now); {type TS = TTimeStamp} 
      s:= IntToStr(Ts.Date) + ' ' + IntToStr(Ts.Time); {'730053 51095810' – 
      (прошло дней с 00.00.0000 г. и миллисекунд от полуночи текущего дня} 
   8. Function TimeStampToDateTime(const TimeStamp: TTimeStamp): TDateTime; 
      Конвертирует TTimeStamp в TDateTime. 
   9. Procedure DecodeDate(Date: TDateTime; var Year, Month, Day: Word); 
      Раскладывет дату Date на год, месяц и день, например: 
      DecodeDate(Now, Y, M, D); 
      s:= IntToStr(Y) + ' ' + IntToStr(M) + ' ' + IntToStr(M); {'1999 10 
      26'} 
  10. .Procedure DecodeTime(Time: TDateTime; var Hour, Min, Sec, MSec: 
      Word); 
      Раскладывет время Time на час, минуты, секунды и миллисекунды, 
      например: 
      DecodeTime(Now, H, M, S, MS); 
      ss:= IntToStr(H) + ' ' + IntToStr(M) + ' ' + IntToStr(S) + ' ' + 
      IntToStr(MS); 
      {'14 22 34 567', т. е. 14 ч 22 мин 34 с 567 мс} 
  11. .Function EncodeDate(Year, Month, Day: Word): TDateTime; 
      Противоположна DecodeDate; 
  12. .Function EncodeTime(Hour, Min, Sec, MSec: Word): TDateTime; 
      Противоположна DecodeTime; 
  13. .Function FormatDateTime(const Frmt: string; DateTime: TDateTime): 
      string; 
      Преобразует DateTime в строку с заданным форматом. Если формат пуст, 
      то функция возвращает строку в формате "c". Следующий оператор 
      присвоит строковой переменной s значение 'Встреча состоится: пятница, 
      6 Ноябрь, 1999, в 10:30 AM'. 
      s:= FormatDateTime('"Встреча состоится:" dddd, mmmm d, yyyy, ' +'"в" 
      hh:mm AM/PM', StrToDateTime('6.11.99 10:30am')); 
Виды форматов даны в табл. 16. 
                      12.7. Прочие процедуры и функции 
   1. Function Hi(X): byte; 
      Возвращает старший байт своего целочисленного аргумента. 
   2. Function Lo(X) : byte; 
      Возвращает младший байт своего целочисленного аргумента. 
   3. Procedure Swap(X); 
      Меняет старший и младший байты целочисленного аргумента местами. 
   4. Procedure Randomize; 
      Инициализирует генератор случайных чисел. 
   5. Function Random(N: Integer): Integer; 
      Возвращает случайное число из интервала (0, N). 
   6. Function SizeOf(X) : Integer; 
      Возвращает число байт, занимаемых аргументом. 
   7. Procedure Move(Var Source, Dest; Count: Integer); 
      Копирует Count байт из переменной Source в переменную Dest. В случае 
      перекрытия областей памяти пересылка в перекрывающуюся область не 
      производится. 
   8. Function ParamCount: Word; 
      Возвращает число параметров, переданных в командной строке. 
   9. Procedure Break; 
      Оператор безусловного завершения цикла, процедуры или функции. 
  10. . Procedure Continue; 
      Оператор, используемый в цикле для передачи управления в его начало. 
                                                                  Таблица 16 
|Формат   |Описание                                                       | 
|C        |Показывает сначала дату в формате дд.мм.гг, затем время в      | 
|         |формате чч.мм.сс. Не показывает время, если дробная часть      | 
|D        |DateTime равна нулю                                            | 
|Dd       |Показывает день без лидирующего нуля (1 – 31)                  | 
|Ddd      |Показывает день с лидирующим нулём (01 – 31)                   | 
|Dddd     |Показывает день недели в укороченном формате (Вос – Суб)       | 
|Ddddd    |Показывает день недели в полном формате (Воскресенье – Суббота)| 
|Dddddd   |                                                               | 
|M        |Показывает дату в формате дд.мм.гг.                            | 
|Mm       |Показывает дату в формате д Месяц год                          | 
|Mmm      |Показывает месяц без лидирующего нуля (1 – 12)                 | 
|Mmmm     |Показывает месяц с лидирующим нулём (01 – 12)                  | 
|Yy       |Показывает месяц в сокращенном виде (Янв – Дек)                | 
|Yyyy     |Показывает месяц в полном формате (Январь – Декабрь)           | 
|h        |Показывает год в виде двух последних цифр (00 – 99)            | 
|hh       |Показывает год в виде четырех цифр (00000 – 9999)              | 
|n        |Показывает час без лидирующего нуля (0 – 23)                   | 
|nn       |Показывает час с лидирующим нулем (00 – 23)                    | 
|s        |Показывает минуту без лидирующего нуля (0 – 59)                | 
|ss       |Показывает минуту с лидирующим нулем (00 – 59)                 | 
|t        |Показывает секунду без лидирующего нуля (0 – 59)               | 
|tt       |Показывает секунду с лидирующим нулем (00 – 59)                | 
|am/pm    |Показывает время в формате чч:мм                               | 
|ampm     |Показывает время в формате чч:мм:сс                            | 
|a/p      |Показывает время в 12-часовом формате (am – до полудня, pm –   | 
|/        |после полудня)                                                 | 
|:        |Показывает время в 12-часовом формате без указателя до/после   | 
|         |полудня                                                        | 
|         |Использует Windows-разделитель даты.                           | 
|         |Использует Windows-разделитель времени                         | 
  11. . procedure Abort; 
      Используется в контексте с другим оператором; отменяет "задним числом" 
      оператор в случае его аварийного завершения, блокирует выдачу 
      сообщения об ошибке, удобен к использованию в блоке try … finally. 
                          13. Структурные операторы 
К их числу относятся: 
    . составной оператор, 
    . условный оператор If, 
    . оператор варианта Case, 
    . оператор цикла For – Do, 
    . оператор цикла While – Do, 
    . оператор цикла Repeat – Until, 
    . оператор записи With, 
    . оператор Try – Except – End, 
    . оператор Try – Finally – End, 
    . оператор On – Do, 
    . оператор Try – Finally – End. 
                          13.1. Составной оператор 
Это простая структура следующих друг за другом операторов, заключенных в 
операторные скобки begin … end. 
Синтаксис составного оператора: 
                 Begin 
                 Оператор1 
                 Оператор2 
                 … 
                 ОператорN 
                 End; 
Составной оператор применяется в тех случаях, когда какое-либо действие 
необходимо применить не к одному, а сразу к нескольким операторам. 
Пример: 
                 Begin 
                 R:= X; 
                 X:= Y; 
                 Y:= R; 
                 End; 
                         13.2. Условный оператор If 
Синтаксис допускает два вида оператора: 
           if логическое выражение then оператор1 else оператор2; 
и его усеченный вариант: 
                       if логическое выражение then оператор1; 
Оператор работает следующим образом. Сначала вычисляется логичес-кое 
выражение. Если оно истинно, то выполняется оператор1, иначе – оператор2. 
Усеченный оператор выполняет оператор1 только в случае истинного значения 
логического выражения и не производит никаких действий в случае его 
ложности. 
Примеры: 
           if (x < 10.7) then a[4]:= 5 else a[4]:= 6; 
           if (x < 10.7) then a[4]:= 5; 
Допустима вложенность условных операторов внутри составного условного 
оператора. Например, оператору 
           if L1 then if L2 then St1 else St2 else St3; 
эквивалентен оператор 
           if L1 then 
           begin 
           if L2 then St1 else St2; 
           end 
           else St3; 
В этом операторе для повышения структурированности использованы операторные 
скобки begin … end. При конструировании сложного условного оператора во 
избежание логических ошибок следует отдавать предпочтение структурному 
способу записи такого оператора. 
                        13.3. Оператор варианта Case 
Синтаксис оператора: 
                       Case Selector of 
                       Const1: Оператор1; 
                       Const2: Оператор2; 
                       … 
                       ConstN: ОператорN 
                       [else Оператор]; 
                       End; 
Selector может быть любой простой тип кроме Real. Каждая из Const1 … ConstN 
может быть значение, несколько перечисленных через запятую значений или 
отрезок типа. Оператор Else, как видно из описания, может отсутствовать. В 
том случае, если он присутствует, то действует общее правило: перед словом 
Else не должно быть символа ";" (точка с запятой). Поясним работу оператора 
Case на примере: 
                 Case i of 
                 0 : x := 0; 
                 1,3 : x := 1; 
                 10 .. 15: x := 2 
                 else x := 3; 
                 End; 
При выполнении оператора Case управление будет передано тому оператору, 
который помечен константой, являющейся значением переменной i. Например, 
если к моменту выполнения Case-оператора i = 0, то будет выполнен оператор 
x := 0. Иначе, если i = 1 или i = 3, то будет выполнен оператор x := 1; 
иначе, если значение i в диапазоне 10 .. 15, то будет выполнен оператор x 
:= 2; наконец, если i не равно ни одной из вышеперечисленных констант, то 
будет выполнен оператор x := 3, следующий за словом else (иначе). 
                        13.4. Оператор цикла For – Do 
Синтаксис оператора имеет две разновидности: 
For счетчик цикла:=нач.знач. To конеч.знач. Do оператор 
For счетчик цикла:=нач.знач. Downto конеч.знач. Do оператор 
Здесь конструкция For .. Do называется заголовком цикла, оператор – телом 
цикла. 
Для циклов должны соблюдаться следующие правила и ограничения: 
    . начальное и конечное значения счетчика цикла должны быть одинаковых 
      простых типов, кроме Real; 
    . в теле цикла счетчик не должен менять значение; 
    . вход в цикл минуя заголовок запрещен; 
    . для первой разновидности начальное значение не должно быть больше 
      конечного; 
    . для второй разновидности начальное значение не должно быть меньше 
      конечного. 
Первая разновидность оператора цикла For работает следующим образом. 
Сначала счетчик цикла принимает нач.знач. и выполняется оператор, 
расположенный вслед за словом Do. Затем значение счетчика будет увеличено 
на шаг счетчика 1 и вновь будет выполнен оператор и т. д., пока счетчик не 
переберет все значения от нач.знач. до конеч.знач. 
Пример. 
                 s:= 0; 
                 For i:=1 to 44 do s:= s + z[i]; 
В результате в переменной s будет накоплена сумма первых 44 элементов 
массива z. 
Другая разновидность оператора For отличается лишь отрицательным шагом –1 
счетчика. 
Пример. 
                 s:= 0; 
                 For i:=44 Downto 1 do s:= s + z[i]; 
Будет получен тот же результат. 
                       13.5. Оператор цикла While – Do 
Синтаксис оператора: 
                   While логическое выражение Do оператор; 
Цикл выполняет оператор, расположенный вслед за словом Do до тех пор, пока 
истинно логическое выражение, расположенное за словом While ("выполняй, 
пока истинно"). 
Пример. 
           x:= 0; 
           i:=0; 
           While (x < 101.667) do 
           Begin 
           Inc (i); 
           X:= X + 5.617; 
           Y[i]:= Func (i + 6, 9 * i, X); 
           End; 
В этом примере цикл будет выполняться до тех пор, пока не выполнится 
условие x < 101.667. В теле цикла переменная X с каждым шагом цикла 
увеличивает свое значение на 5.617 так, что на определенном шаге условие x 
< 101.667 впервые не будет выполнено. В этот момент без входа в тело цикл 
закончит работу. 
                     13.6. Оператор цикла Repeat – Until 
Синтаксис оператора: 
                       Repeat 
                       Оператор1; 
                       Оператор2; 
                       … 
                       ОператорN; 
                       Until логическое выражение; 
Цикл работает, пока логическое выражение ложно ("повторяй, пока не 
выполнится"). 
Пример. 
           s:= 0; 
           i:=0; 
           Repeat 
           Inc (i);  
           s:= s + z[i]; 
           Until (i = 44); 
В этом примере цикл будет выполняться до тех пор, пока не выполнится 
условие i = 44. Результат будет тот же, что в примере для For-цикла. 
                      13.7. Операторы Break и Continue 
Оператор Break может быть размещен в теле цикла. При его выполнении цикл 
прекращает работу и считается выполненным. 
Пример. 
           s:= 0; 
           i:=0; 
           Repeat 
           Inc (i); 
           s:= s + z[i]; 
           if (s > 14) then Break; 
           Until (i = 44); 
В этом примере цикл будет выполняться до тех пор, пока не выполнится 
условие i = 44 или если в операторе if переменная s превысит значение 14. 
Оператор Continue также может быть размещен в теле цикла. При его 
выполнении управление независимо от того, где он расположен, сразу 
передается в начало цикла для выполнения следующего шага. 
Пример. 
           s:= 0; 
           i:=0; 
           Repeat 
           Inc (i); 
           s:= s + z[i]; 
           if (s > 20) then Continue; 
           if (s > 14) then Break; 
           Until (i = 44); 
В этом примере если в первом операторе if выполнится условие s > 20, то 
сработает оператор Continue. Он сразу передаст управление на первый 
оператор в теле цикла – Inc (i), предотвратив тем самым выполнение ниже- 
следующих операторов – второго if и Until. 
                            13.8. Вложенные циклы 
В теле оператора цикла могут быть размещены другие операторы цикла. Такие 
структуры называются вложенными циклами. Язык допускает любую глубину 
вложенности циклов. При использовании вложенных циклов необходимо иметь в 
виду следующее: 
    . все вложенные циклы For – Do должны иметь различные счетчики (иначе 
      это противоречило бы требованию на запрет изменения значения счетчика 
      внутри цикла); 
    . нет никаких ограничений на досрочный выход из внутреннего цикла 
      наружу; 
    . недопустим вход во внутренний цикл For – Do, минуя его заголовок, что 
      соответствует общему требованию о корректном входе в цикл. 
Вложенные циклы используются в ситуациях, когда на каждом шаге наружного 
цикла необходимо полностью выполнить внутренний цикл. 
Пример. 
           Const 
           n = 15; 
           m = 24; 
           Var 
           i,j: Byte; 
           R,Tau,s: Real; 
           z: array[1..n, 1..m] of Real; 
           … 
      {заполнение массива z с использованием вложенных циклов} 
      Tau:= Pi/m; 
      For i:=1 to n do begin 
      R:=4.0*Pi*Sin(i*Tau); {первый оператор в теле цикла по i} 
      For j:=1 to m do z[i, j] := R+j; {второй оператор в теле  цикла по i} 
      end {i}; 
      {вычисление суммы положительных элементов массива z с использованием 
      вложенных циклов } 
           s:=0; 
           For i:=1 to n do 
           For j:=1 to m do 
             if ( z[i, j] > 0) then s:= s + z [i, j]; 
Приведенный пример содержит две структуры вложенных циклов. Первая 
структура предназначена для заполнения элементов двумерного массива z с 
помощью математической формулы 
                                    [pic] 
Наружный цикл со счетчиком i в теле цикла содержит два оператора – оператор 
присваивания (вычисление значения вспомогательной переменной R с целью 
сокращения времени вычислений) и оператор внутреннего цикла со счетчиком j. 
Поскольку наружный цикл в своем теле содержит несколько операторов, то они 
заключены в операторные скобки begin … end. 
Эта структура работает следующим образом. После входа в наружный цикл 
переменная i (счетчик этого цикла) примет значение 1. Далее будет вычислено 
значение переменной R при i = 1. После этого будет выполнен внутренний цикл 
со счетчиком j, где j на каждом шаге будет последовательно принимать 
значения 1, 2, 3, … m (i при этом остается неизменным и равным 1). В 
результате будут вычислены элементы z11, z12, …, z1m первой строки массива. 
Затем будет выполнен возврат к заголовку наружного цикла, где значение 
счетчика i будет увеличено на 1 (т. е. i станет равно 2) и вновь будет 
выполнены операторы, расположенные в его теле. В результате будут 
определены элементы z21, z22, …, z2m второй строки массива и т.д. 
Вторая структура вложенных циклов предназначена для вычисления суммы 
положительных элементов массива z. Для этого сначала переменной s будет 
присвоено значение 0, а затем во вложенных циклах будет накоплена требуемая 
сумма в ячейку s. 
                         13.9. Оператор записи With 
В ранних версиях языка оператор использовался для более удобного доступа к 
полям записи. 
Пример: 
                 Var 
                 Student : Record 
                 Fam: String[30]; 
                 Name: String[20]; 
                 Age: Word; 
                 End; 
                 … 
                 Student.Fam:= 'Колокольников'; 
                 Student.Name:= 'Павел'; 
                 S:=Student.Fam + ' '+Student.Name; 
                 {предыдущих три оператора эквивалентны следующим} 
                 With Student do 
                 Begin 
                 Fam:= 'Колокольников'; 
                 Name:= 'Павел'; 
                 S:= Fam + ' '+ Name; 
                 End; 
                     13.10. Оператор Try – Except – End 
Это новейшее средство языка. Блок Try – Except – End используется для 
предотвращения исключительных ситуаций (ИС), которые могут возникнуть при 
выполнении программы. К их числу относятся сбои в работе аппаратуры, ошибки 
вычислений (например деление на нуль), попытки присвоить значение, 
выходящее за пределы типа и т. д. 
Синтаксис: 
           Try 
           {операторы, способные генерировать ИС} 
           Except 
           {операторы, обрабатывающие генерированные ИС} 
           end; 
Блок Try – Except – End работает следующим образом. Выполнение начинается с 
операторов, расположенных в блоке Try – Except. Если в каком-либо операторе 
возникает ИС, то она подавляется и затем выполняются все операторы, 
расположенные в блоке Except – End. В результате предотвращается аварийное 
прерывание программы. Использование блока Try – Except – End открывает 
возможность программного контроля за ИС. 
Пример. 
      i:= 0; 
      n:= 8; 
      Try 
      i:= n div i; {Деление на нуль. Оператор генерирует ИС} 
      n:= i + 9; 
      Except 
      ShowMessage('Ошибка. Деление на нуль в операторе i := n / i'); 
      End; 
Результатом выполнения блока операторов будет появление на экране формы с 
сообщением "Ошибка. Деление на нуль в операторе i := n / i", после чего 
программа продолжит работу с оператора, следующего за словом End, а не с 
оператора n := i + 9. 
Если бы оператор i := n div i не был защищен блоком Try – Except – End, то 
возникшая при его выполнении ИС привела бы к нежелательному аварийному 
завершению программы. 
                          13.11. Оператор On – End 
При возникновении ИС язык позволяет не только предотвратить прерывание 
программы, но и определить, какого именно вида была ИС. Для этого в блоке 
Except – End можно использовать оператор On –Do. 
Пример 
      i:= 0; n:= 8; 
      Try 
      i:= n div i; {Деление на нуль. Оператор генерирует ИС} 
      n:= i + 9; 
      Except 
      On Ex: EdivByZero do ShowMessage('Деление на нуль'); 
      End; 
В этом примере сообщение о возникновении ИС будет выдано только в случае, 
когда ИС будет только деление на нуль (EdivByZero). Во всех остальных 
случаях ИС будет предотвращена, однако никакого сообщения о ее 
возникновении выдано не будет. Объявленная в блоке Except – End переменная 
Ex может быть любым именем (здесь Ex используется только для примера). 
                     13.12. Оператор Try – Finally – End 
Блок Try – Finally – End также используется для предотвращения ИС, которые 
могут возникнуть при выполнении программы. В отличие от блока Try – Except 
– End блок Try – Finally – End используется для освобождения ресурсов 
памяти, закрытия файлов и пр. в случае возникновения ИС. 
Синтаксис: 
           Try 
           {операторы, способные генерировать ИС} 
           Finally 
           {операторы освобождения ресурсов памяти } 
           end; 
Блок Try – Finally – End работает следующим образом. Выполнение начинается 
с операторов блока Try – Finally, которые в правильно написанной программе 
должны содержать операторы выделения ресурсов памяти. Если в каком-либо 
операторе возникает ИС, то управление сразу передается к операторам блока 
Finally – End, где производится освобождение памяти, закрытие файлов и пр. 
В результате, с одной стороны, предотвращается аварийное прерывание 
программы и, во вторых, корректно освобождается ранее зарезервированная 
память, выполняется ряд других необходимых операций. 
Отметим, что блок Finally – End выполняется всегда вне зависимости от того, 
была или не была сгенерирована ИС. 
Пример. 
      i:= 0; 
      n:= 8; 
      Try 
      GetMem (p, 8000); {выделение памяти} 
      i:= n div i; {Деление на нуль. Оператор генерирует ИС} 
      n:= i + 9; 
      Finally 
      FreeMem (p, 8000); {освобождение памяти} 
      End; 
                                14. Указатели 
В языке есть средство, разрешающее запрашивать память динамически, т. е. по 
необходимости. Это позволяет уменьшить объем кода программы и экономно 
расходовать оперативную память. Такое средство представляет собой 
специальный тип, называемый указателем. Имеется два типа ука-зателей: 
указатель на объект некоторого типа и указатель без типа. 
Тип Pointer образует указатель без типа. Указатель на тип имеет синтаксис: 
                                  ^ Имя типа 
Примеры объявления указателей: 
Type 
tDinArr = Array[1 .. 1000, 100] of String[255]; {обычный тип} 
tDinArrPtr = ^tDinArr; {указатель на тип tDinArr} 
tRecPtr = ^tRec; {указатель на тип записи, который описан ниже} 
tTRec = Record {обычный тип-запись} 
A: Integer; 
B: Real; 
C: String[255]; 
End; 
      Var 
      DinArr: tDinArr; {обычная запись} 
      DinArrPtr: tDinArrPtr; {указатель на тип} 
      RecPtr: tRecPtr; {указатель на тип-запись} 
Страницы: 1, 2, 3, 4, 5 
	
	
					
							 |