Знакомство с языком Турбо Паскаля


В этой главе описывается ядро Турбо Паскаля - минимальный набор средств, достаточный для написания сравнительно простых программ. В частности, рассматриваются все операторы языка, наиболее популярные типы данных и операции над ними. Вы познакомитесь с приемами разработки процедур и функций, позволяющими создавать структурированные программы. В заключительной части главы на примерах показано применение методики нисходящего программирования, обеспечивающей сравнительно простой и надежный способ детальной проработки алгоритма программы.
 
Ваша первая программа
Для знакомства с языком Турбо Паскаля попробуем составить несложную программу, осуществляющую вывод какого-либо сообщения на экран ПК. Пусть это будет фраза «Я программирую на Турбо Паскале». Вот возможный вариант такой программы:
Пример 2.1
Program My_First_Program;
const
Text = 'Я программирую на Турбо Паскале'; 
begin
WriteLn(Text);
end.
Прежде всего проанализируем форму представления текста. В программе шесть строк. Строки программы обычно выделяют некоторые смысловые фрагменты текста и могут не связываться с конкретными действиями в программе: расположение текста программы по строкам - дело вкуса программиста, а не требование синтаксиса языка. Ту же программу можно было бы написать, например, так:
Program My_First_Program; const Text =
'Я программирую на Турбо Паскале';begin WriteLn(Text); end.
В отличие от некоторых других языков программирования пробел в языке Турбо Паскаль используется как разделитель отдельных конструкций языка, поэтому программа
PROGRAMMy_First_Program;constText=
'Я программирую на Турбо Паскале';BEGINWriteLn(Text);end.
будет неверной.
В Турбо Паскале игнорируется различие в высоте букв (заглавные или строчные), если только это не связано с текстовыми константами. Начало программы могло бы, например, выглядеть так:
program my_first_program; 
Теперь о смысле отдельных строк. Первая строка
Program My_First_Program;
начинается словом Program и содержит объявление имени программы. Слово Program зарезервировано в Турбо Паскале, т.е. не может использоваться ни в каких иных целях, кроме как для объявления имени программы. В Турбо Паскале имеется множество зарезервированных слов (см. гл.З). Любое из них нельзя использовать в качестве идентификатора (имени) какого-либо объекта программы - переменной, константы и т.д. Замечу, что редактор среды Турбо Паскаля обычно выделяет зарезервированные слова цветом. В связи с этим в тексте книги эти слова выделены жирным шрифтом. Поскольку имя программы никак в дальнейшем не используется, требование его объявления кажется излишним. В Турбо Паскале можно опускать объявление имени оператором Program без каких-либо последствий для программы.
В рассматриваемом примере имя My_First_Program есть не что иное, как английская фраза «Моя Первая Программа», но только написанная без пробелов - пробел является разделителем и не может использоваться произвольно (вместо пробелов в идентификаторах разрешается использовать символ подчеркивания).
Первая строка заканчивается особым разделителем - точкой с запятой. Этот разделитель в языке Турбо Паскаль отмечает конец оператора или описания. Использование особого разделителя позволяет располагать несколько операторов на одной строке.
Вторая строка
const
содержит единственное зарезервированное слово const, означающее, что далее будут описаны одна или несколько констант (CONSTants - константы). Константами в языке считаются такие объекты программы, которые не могут изменять своего значения. В отличие от многих других языков программирования, константа в Турбо Паскале может иметь собственное имя, что соответствует принятой в научных и инженерных расчетах практике именования часто используемых констант. Например, со школы мы помним о существовании константы п—3.14159265. При обработке программы имя константы pi будет заменяться компилятором на ее значение.Описать константу в Турбо Паскале - значит указать ее имя и значение. Такое указание содержится в третьей строке
Text = 'Я программирую на Турбо Паскале';
в которой константе с именем Text присваивается в качестве значения строка символов «Я программирую на Турбо Паскале».
В Турбо Паскале могут использоваться константы разного типа - целые или вещественные числа, символы, строки символов, массивы и т.д. Признаком того, что Text является константой типа строка символов, служат два апострофа, обрамляющих строку, причем сами апострофы этой строке не принадлежат, а лишь указывают компилятору на то, что все заключенные в них символы следует рассматривать как единое целое - текстовую константу. Если понадобится включить сам апостроф в текстовую константу, достаточно его написать дважды подряд. Например, описание
Text = 'Турбо' 'Паскаль';
создаст константу со значением
Турбо'Паскаль
Все три первые строки не связаны с какими-либо конкретными действиями при работе программы. Они сообщают компилятору некоторые сведения о самой программе и использующихся в ней объектах. Эта часть программы называется разделом описаний. Зарезервированное слово begin в четвертой строке сигнализирует компилятору о начале другой части программы - раздела операторов. В нашем примере этот раздел содержит оператор
WriteLn(Text);
который, собственно, и выводит сообщение на экран компьютера.
Завершает всю программу зарезервированное слово end с точкой. Точка оповещает компилятор о конце текста программы. За сочетанием end. можно размещать какой угодно текст - он не будет обрабатываться компилятором.
Перед тем как попробовать откомпилировать и исполнить нашу программу, обсудим ее единственный исполняемый оператор
WriteLn(Text);
Любопытно, что в Паскале вообще и Турбо Паскале, в частности, нет специальных операторов ввода-вывода. Для обмена информацией с окружающим миром в программах, написанных на языке Турбо Паскаль, используются специальные стандартные процедуры. Таким образом, по своей сути оператор
WriteLn(Text);
является оператором обращения к встроенной процедуре вывода данных (свое название она получила от WRITE LiNe - записать строку).
Понятие процедуры - одно из центральных понятий Турбо Паскаля. Процедура - это некоторая последовательность операторов, к которой можно обратиться по имени. Всякий раз, когда мы называем в операторе имя процедуры, инициируется последовательность запрограммированных в ней действий.
Процедура WriteLn относится к стандартным или встроенным процедурам Турбо Паскаля. Стандартная процедура не нуждается в предварительном описании, она доступна любой программе, в которой содержится обращение к ней. Разница между оператором вывода и обращением к процедуре вывода состоит в том, что имя процедуры вывода, как и любой другой процедуры Турбо Паскаля, не является зарезервированным словом, а следовательно, пользователь может написать свою собственную процедуру с именем WriteLn. Впрочем, эта возможность для большинства пользователей остается лишь языковой тонкостью и очень редко используется на практике.
Процедура WriteLn - одна из немногих процедур Турбо Паскаля, при обращении к которым допускается использование произвольного числа параметров. Параметры передаются процедуре в виде списка, располагающегося в круглых скобках сразу за именем процедуры. В нашем примере процедуре передается единственный параметр -константа Text. Как мы увидим дальше (см. гл.5), самым первым параметром при обращении к процедуре WriteLn можно указать адрес приемника информации - устройство или дисковый файл, в который направляется вывод. Таким способом программист может легко переадресовать вывод данных. Если, как это сделано в нашем примере, адрес вывода не указан, вывод направляется на экран дисплея.
Анализируя всю программу в целом, мы обнаружим, что четыре использовавшихся в ней слова (Program, const, begin и end) являются зарезервированными. Слово WriteLn, как уже отмечалось, не относится к зарезервированным, но вряд ли может возникнуть необходимость переопределить его, так как в этом случае программа лишится мощного и удобного средства вывода данных. Два слова My_First_Program и Text служат идентификаторами (именами) некоторых объектов программы. Программист может использовать в качестве идентификаторов любые последовательности символов, которые удовлетворяют следующим ограничениям:

  • идентификатор может состоять из букв латинского алфавита, цифр, знака подчеркивания; никакие другие символы в идентификаторе недопустимы;
  • идентификатор не может начинаться с цифры;
  • идентификатор не может совпадать ни с одним из зарезервированных слов;
  •  длина идентификатора может быть произвольной, но значащими считаются первые 63 символа.

Как и всюду в программе, в идентификаторах игнорируется разница в высоте букв, поэтому, например, идентификаторы Text, text и TEXT с точки зрения компилятора идентичны.
Теперь попробуйте выполнить программу. Для этого после набора ее текста нажмите Ctrl-F9. Если Вы не ошиблись при вводе текста, то спустя несколько секунд заметите быструю смену изображений на экране: сразу после загрузки программы Турбо Паскаль очищает экран, предоставляя его в распоряжение работающей программы пользователя. Такой экран называется окном программы. После завершения прогона (работа программы часто называется ее прогоном) на экране вновь появится окно редактора с текстом программы. Если Вы не успели разглядеть изображение окна программы, нажмите Alt-F5. После нажатия на любую клавишу среда вернет экран в режим воспроизведения окна редактора.
Перед тем, как двигаться дальше, полезно подробнее ознакомиться с некоторыми возможностями среды Турбо Паскаля. Нажмите клавишу F10, чтобы перейти к режиму выбора из главного меню, подведите указатель к опции Debug (отладка) и нажмите клавишу Enter - на экране раскроется меню второго уровня, связанное с этой опцией. Новое меню как бы «выпало» из верхней строки, поэтому такое меню часто называют выпадающим. Отыщите в новом меню опцию Output (вывод программы), подведите к ней указатель и нажмите клавишу Enter еще раз. На экране вновь появится окно программы, но оно уже не будет исчезать после нажатия на любую клавишу - экран будет связан с этим окном постоянно. Теперь добьемся того, чтобы на экране демонстрировались два окна одновременно: вновь нажмите клавишу F10, выберите Window, нажмите клавишу Enter, подведите указатель к опции Tilе(черепица) и нажмите клавишу Enter еще раз. Если все сделано правильно, экран приобретет вид.
Двойная рамка, очерчивающая окно программы, свидетельствует о том, что именно это окно активно в данный момент. Сделаем активным окно редактора: нажмем клавишу Alt и, не отпуская ее, - клавишу с цифрой 1 (окно редактора имеет номер 1, окно программы - номер 2, см. верхние правые углы рамок. Теперь все готово к дальнейшим экспериментам с программой.
Попробуем изменить выводимый на экран текст. Например, уберем в конце треть-ей строки точку с запятой и отредактируем ее таким образом:
Text = 'я учусь программировать на турбо паскале'
Если Вы запустите программу вновь, нажав клавиши Ctrl-F9, компилятор сообщит:
Error 85: ";" expected. (Ошибка 85: Отсутствует ";".),
а редактор установит курсор на первый символ слова begin, показывая то место, где при разборе текста обнаружена ошибка (разделитель «;» может отделять от конца оператора сколько угодно пробелов; компилятор пропускает эти пробелы в поисках разделителя до тех пор, пока не обнаружит зарезервированное слово, - вот почему курсор стоит не в конце строки с объявлением константы, а перед словом begin). Исправьте программу - поставьте в конце третьей строки разделитель «;» и вновь запустите счет. На этот раз все пройдет нормально, но вывод программы изменится, и в окне программы появится текст
я учусь программировать на турбо паскале
Этот текст строго соответствует заданному в текстовой константе набору символов, поэтому в нем отсутствуют прописные буквы.
 
Типы данных
Структура рассмотренной программы имеет следующий вид:
Program MyFirstProgram; 
{Раздел описаний}
begin
{Раздел операторов}
end.
Слова Program, begin и end выделяют две части программы - раздел описаний и раздел операторов. Такая структура обязательна для любой программы, что является следствием жесткого требования языка: любой нестандартный идентификатор, используемый в исполняемых операторах, должен быть предварительно описан в разделе описаний. (Стандартные идентификаторы связаны с предварительно объявленными объектами и входят в стандартную библиотеку Турбо Паскаля. Таким, например, является идентификатор WriteLn. Стандартные идентификаторы, если они используются в программе, описывать не нужно).
Требование предварительного описания идентификаторов кажется чрезмерно строгим и делающим язык менее свободным. На самом деле в нем проявляется тенденция развития языков программирования в сторону повышения надежности создаваемых программ. Кто программировал на Фортране или Бэйсике (в этих языках не требуется предварительное описание идентификаторов), знает, как порой бывает трудно обнаружить в большой программе ошибочно введенный или пропущенный символ в идентификаторе. Если, например, всюду в программе используется переменная с именем EPSILON, а в одном месте ошибочно написано EPSLION, то программа может благополучно откомпилироваться и даже давать почти правдоподобный результат для некоторых наборов данных, но в какой-то момент начнет вести себя странно. Обязательное предварительное описание идентификаторов в Турбо Паскале защищает программы от такого рода ошибок и повышает их надежность.
Описать идентификатор - это значит указать тип связанного с ним объекта программы (константы или переменной). Понятие типа - одно из фундаментальных понятий Турбо Паскаля. В гл.4 подробно рассмотрены различные типы; чтобы пояснить описываемые ниже особенности языка и при этом не слишком забегать вперед, укажем, что тип определяет, во-первых, способ внутреннего для компьютера представления объекта и, во-вторых, действия, которые разрешается над ним выполнять.
В рассматриваемых далее в этой главе программах понадобятся следующие типы данных:

  • INTEGER - целочисленные данные, во внутреннем представлении занимают 2 байта; диапазон возможных значений - от -32768 до +32767; данные представляются точно;
  • REAL - вещественные данные, занимают 6 байт; диапазон возможных значений модуля - от 2.9Е-39 до 1.7Е+38; точность представления данных - 11...12 значащих цифр;
  • CHAR - символ, занимает 1 байт;
  • STRING - строка символов, занимает МАХ+1 байт, где МАХ - максимальное число символов в строке;
  • BOOLEAN - логический тип, занимает 1 байт и имеет два значения: FALSE (ложь) и TRUE (истина).

Тип константы определяется способом записи ее значения. Например:
const
cl = 17;
с2 = 3 .14 ; 
сЗ = 'А';
с4 = '3.14 ' ; 
с5 = False;
При анализе этого фрагмента программы компилятор отнесет первую константу к типу INTEGER, вторую - к типу REAL, третью - к CHAR, четвертую - к STRING и последнюю - к BOOLEAN. Признаком, позволяющим отнести константу к REAL или к INTEGER, является наличие или отсутствие десятичной точки в ее значении. Разумеется, константы С2 и С4 относятся к разным типам: С2 - к REAL (в константе есть десятичная точка), а С4 - к STRING (константа обрамлена апострофами). Константу СЗ компилятор будет считать относящейся к типу CHAR: одиночный символ в апострофах относится к CHAR, в то время как несколько символов - к STRING.
В отличие от константы переменная именует объект программы, который может изменять свое значение в ходе счета. При описании переменных за идентификатором ставятся двоеточие и имя типа. Несколько однотипных переменных можно объединять в список, разделяя их запятыми. В начале раздела описания переменных должно стоять зарезервированное слово VAR (VARiables - переменные). Например:
var
sigma :Real; а,b,с,d :Char;
textl :String[15];
text2 :String;
flag :Boolean;.
Как уже говорилось, тип данных определяет длину внутреннего представления соответствующих переменных. В частности, длина внутреннего представления переменных типа STRING (строка символов) зависит от максимального числа символов, которые могут составлять строку. В приведенном выше примере переменная text l описана с указанием ее максимальной длины (15 символов), а в описании переменной text2 максимальная длина не указана и компилятор установит для нее предельно допустимую в Турбо Паскале длину - 255 символов.
Рассмотрим еще одну несложную программу (пример 2.2). Ее назначение: ввести с клавиатуры два целых числа, найти результат деления первого числа на второе и вывести полученный результат на экран.
Пример 2.2
Program Input_0utput; {Программа вводит два целых числа
и выводит частное от деления 1-го на 2-е}
var
n1,n2 : Integer; {n1 и n2 - вводимые целые}
х : Real;{x - результат}
BEGIN
Write( 'n1 = ');{Сообщаем о вводе n1}
ReadLn (n1) ;{Вводим n1}
Write ( 'n2 = ');{Сообщаем о вводе п2}
ReadLn (n2);{Вводим п2}
x := n1/n2;{Находим результат}
WriteLn('n1/n2 =',х);{Выводим его}
END.
Прежде всего бросается в глаза появление в программе поясняющих комментариев. Комментарий в Турбо Паскале - это произвольная последовательность любых символов, обрамленная фигурными скобками. Комментарий разрешается вставлять в любое место программы, где по смыслу может стоять пробел. В качестве ограничителей комментария допускается использование фигурных скобок «{» и «}», а также пары символов: «(*» - слева от комментария и «*)» - справа от него:
{ Это - комментарий }
(* Это - тоже комментарий *)
Редактор Турбо Паскаля выделяет комментарии наклонным шрифтам (курсивом).
Комментарии с однотипными ограничителями нельзя вкладывать друг в друга, т.е. недопустимы последовательности вида
{...{...}...} или (*...(*...*)...*)
Однако можно вкладывать комментарии с ограничителями разных типов (не более одной глубины вложения):
{ ... (* ...*)...} или (* ... { ... } ... *)
Последнее обстоятельство проясняет кажущуюся странной избыточность ограничителей: если всюду в программе будут использоваться ограничители одного типа, то для того, чтобы временно исключить из программы какой-либо фрагмент текста, достаточно заключить его в ограничители другого типа.
Наличие комментариев в программе избавляет меня от необходимости пояснять назначение отдельных строк программы. Несколько слов о вводе данных. Пары операторов
Write (..);
ReadLn(..);
работают следующим образом. Вначале оператор Write выводит строку на экран и оставляет курсор в конце только что выведенной строки текста. Заметим, что оператор
WriteLn(Text);
в примере 1 после вывода текста осуществлял перевод строки и устанавливал курсор в начало следующей строки экрана. Именно в этом простом действии (переводе строки) заключается единственное отличие в работе процедуры WriteLn от процедуры
Write.
Затем по оператору ReadLn вызывается встроенная процедура ввода данных и программа останавливается в ожидании ввода. В этот момент необходимо набрать на клавиатуре нужное число и нажать клавишу Enter. Сразу после этого программа продолжит работу: проанализирует введенное число и перейдет к вводу следующего числа или вычислению результата. Таким образом, сигналом окончания подготовки очередного числа является нажатие на клавишу Enter, до этого момента можно стирать любой ошибочно введенный символ клавишей Backspace.
Для вычисления отношения введенных чисел используется один из основных операторов Турбо Паскаля - оператор присваивания. В его левой части указывается имя переменной, правая часть представляет собой выражение того же типа, что и переменная. Пара символов «: =», связывающая левую и правую части оператора присваивания, означает «присвоить значение». Запомним: в операторах присваивания Турбо Паскаля всегда используются символы «: =», в то время как при описании констант -одиночный символ «=». С точки зрения синтаксиса языка, два символа «: =» рассматриваются как один специальный символ и обязательно пишутся слитно.
Оператор присваивания используется практически во всех языках программирования. В некоторых языках, например в Фортране или Бейсике, символом присваивания является знак равенства, однако новичка, привыкшего к строгости математических формул, может озадачить типичная форма записи фортран-оператора присваивания, например, такая:
X = X + 1
Вариант записи этого же оператора на Турбо Паскале:,
X := X + 1;
в этом смысле кажется более логичным. Разумеется, вряд ли кому-нибудь придет в голову видеть уравнения там, где их нет и не может быть. Конечно же, и в том, и в другом случае реализуется одно и то же алгоритмическое действие: к содержимому X прибавляется 1 и полученный результат вновь присваивается переменной X. Обратите внимание на оператор вывода результатов
WriteLn('n1/n2 = ',х);
В нем в качестве одного из параметров явно указывается константа типа строка символов 'nl/n2 = '. Конечно же, константы (в отличие от переменных) вовсе не обязательно описывать в разделе описаний, так как их тип легко определяется компилятором по форме записи константы. С учетом этого можно было бы записать программу из примера 1 предельно лаконично:
begin WriteLn('Я программирую на Турбо Паскале'); end.
 
Преобразованя типов и действия над ними
Как уже говорилось, тип переменной позволяет не только устанавливать длину ее внутреннего представления, но и контролировать те действия, которые выполняются над ней в программе. Контроль за использованием переменных еще на этапе компиляции программы - важное преимущество Турбо Паскаля перед другими языками программирования, в которых допускается автоматическое преобразование типов. В Турбо Паскале почти невозможны неявные (автоматические) преобразования типов. Исключение сделано только в отношении констант и переменных типа INTEGER (целые), которые разрешается использовать в выражениях типа REAL (вещественные). Если, например, переменные X и Y описаны следующим образом:
var
х: Integer; 
у: Real;
то оператор
у := х + 2;
будет синтаксически правильным: хотя справа от знака присваивания стоит целочисленное выражение, а слева - вещественная переменная, компилятор сделает необходимые преобразования автоматически. В то же время оператор
х := 2.0;
будет неверным, так как автоматическое преобразование типа REAL (константа 2.0 содержит десятичную точку и, следовательно, принадлежит к типу REAL) в тип INTEGER в Турбо Паскале запрещено.
Разумеется, запрет на автоматическое преобразование типов еще не означает, что в Турбо Паскале нет средств преобразования данных. Они, конечно же, есть, но их нужно использовать явно (подробнее об этом см. гл.4). Для преобразования данных в языке существуют встроенные функции, которые получают в качестве параметра значение одного типа, а возвращают результат в виде значения другого типа. В частности, для преобразования REAL в INTEGER имеются даже две встроенные функции такого рода: ROUND округляет REAL до ближайшего целого, a TRUNC усекает REAL путем отбрасывания дробной части.
Например, ошибочным будет оператор
х := у/х; 
но правильным
х := round(у/х);
(объявления переменных см. выше).
Понятие функции в Турбо Паскале близко к понятию процедуры. Как и процедура, функция вызывается своим именем и может содержать произвольное число операторов Турбо Паскаля и даже внутренних процедур и функций. Существенным отличием функции от процедуры является то обстоятельство, что функция имеет собственное значение и, следовательно, может использоваться наравне с переменными в выражениях соответствующего типа.
Для преобразования данных типа CHAR (символ) в целое число предназначена функция ORD, обратное преобразование INTEGER в CHAR осуществляет функция CHR.
С помощью следующей несложной программы (пример 2.3) Вы сможете узнать внутренний код произвольного символа.
Пример 2.3
Program Code_pf_Char;
{Программа читает символ с клавиатуры и выводит на экран
этот символ несоответствующий ему внутренний код}
var
ch: Char; {В эту переменную читается символ}
begin
Write('Введите любой символ: '); 
ReadLn(ch); {Читаем один символ}
WriteLn(ch, ' = ',ord(ch)); {Преобразуем его к целому и выводим на экран}
END.
Обратите внимание: при вызове
WriteLntch,' = ',ord(ch));
третьим параметром обращения указан вызов функции ORD (СН) , что с точки зрения языка является выражением; как мы увидим дальше (см. гл.8), во многих случаях при вызове процедур и функций в качестве параметров вызова можно указывать не только переменные или константы, но и выражения с их участием.
По мере надобности мы будем знакомиться с другими функциями преобразования типов данных, а сейчас - о тех операциях, которые разрешены над различными типами.
Конечно же, в Турбо Паскале есть все четыре арифметические операции над переменными REAL И INTEGER:
+ - сложение;
 - - вычитание; 
* - умножение; 
/ - деление вещественное; 
div - деление целочисленное.
Наличие двух операций деления есть еще одно проявление основополагающего принципа Турбо Паскаля: программист должен явно подтверждать компилятору, что он готов к возможным последствиям преобразования типов. Если, например, в языке Фортран используется выражение 1/2 , то результат этого выражения будет зависеть от того, переменной какого типа он будет присвоен: если N есть переменная целого типа, а Х- вещественного, то в программе на Фортране присваивания
N = 1/2
X = 1/2
дадут значения 0 для N и 0.5 для X. В Турбо Паскале такой двусмысленности нет: выражение 1/2 всегда имеет значение 0.5 и поэтому оператор
var
N :Integer;
begin
N := 1/2;
просто недопустим. В то же время допустимый в Турбо Паскале оператор
var
X : Real;
begin
X := 1 div 2;
самим фактом использования операции целочисленного деления DIV свидетельствует о том, что программист сознательно отбрасывает дробную часть результата. (Надеюсь, что читатель извинит явную искусственность этих примеров, которая вызвана лишь стремлением проиллюстрировать обсуждаемые особенности языка).
Для данных типа INTEGER в Турбо Паскале есть еще одна операция MOD - получение остатка от целочисленного деления. Например:
5 mod 2 = 1 
31 mod 16 = 15 
18 mod 3 = 0
В Турбо Паскале отсутствует операция возведения в степень, что, очевидно, будет вызывать определенные неудобства при реализации вычислительных алгоритмов. Некоторым утешением может служить наличие встроенной функции SQR, возвращающей квадрат от значения параметра, причем тип результата определяется типом параметра.
И еще об одном существенном недостатке Турбо Паскаля: в нем отсутствуют комплексный тип и соответствующие операции над ним. Вообще, в отношении реализации разнообразных вычислительных процедур Турбо Паскаль значительно уступает некоторым другим языкам программирования, в частности, тому же Фортрану. В частности, в нем намного беднее набор встроенных математических функций (см. гл. 4).
При работе с целыми числами могут оказаться полезными две процедуры (здесь и далее в квадратных скобках указываются необязательные параметры):
DEC (X [, N] ) - уменьшает содержимое переменной X на значение выражения N (если N не задано, то на 1); тип переменной X и выражения N - INTEGER (точнее, любой целый, см. гл. 4);
INC (X [, N] ) - увеличивает значение X на N (если N не задано, то на 1).
Над символами и строками символов определена единственная операция - сцепление двух строк. Операция обозначается символом «+». Например, программа
var
st: String; 
begin
st := 'Турбо'+'-'+'Паскаль'; 
WriteLn(st);
end.
напечатает строку
Турбо-Паскаль
Все остальные действия над строками и символами реализуются с помощью встроенных процедур и функций (см. гл.4).
И, наконец, об операциях отношения и логических операциях.
Над данными типа REAL, INTEGER, CHAR, STRING определены следующие операции отношения (сравнения):
= - равно;
<> - не равно;
< - меньше;
> - больше;
<= - меньше или равно,
>= - больше или равно.
В операциях сравнения должны участвовать однотипные операнды. Исключение сделано опять-таки в отношении REAL и INTEGER, которые могут сравниваться друг с другом. Результат применения операции отношения к любым операндам имеет тип BOOLEAN.

Сравнение двух строк осуществляется следующим образом. Символы строк сравниваются попарно друг с другом так, что первый символ первой строки сравнивается с первым символом второй строки, второй символ первой строки - со вторым символом второй и т.д. Символы сравниваются путем сравнения их кодов во внутреннем представлении (см. гл. 4). Если одна строка короче другой, недостающие символы заменяются нулем. Отношение первой несовпадающей друг с другом пары символов и принимается за отношение двух строк.
При сравнении данных типа BOOLEAN учитывается внутреннее соглашение Турбо Паскаля, в соответствии с которым FALSE есть нулевой байт, a TRUE - байт с единицей в младшем разряде. Заметим, что функция ORD преобразует к целому не только символы, но и логические величины, поэтому
ord(false) = 0,
ord(true) = 1.
В Турбо Паскале определены следующие логические операции:
not - логическое НЕ;    or - логическое ИЛИ;
and - логическое И;     хоr - исключающее ИЛИ.
Логические операции применимы к операндам целого и логического типов. Если операнды - целые числа, то результат логической операции есть тоже целое число (подробнее об этом сказано в гл.4). Логические операции над логическими данными дают результат логического типа.
При вычислении выражений любого типа приоритет вычислений определяется расставленными скобками, а при их отсутствии - по табл. 2.1 (в порядке убывания приоритета).
Таблица 2.1 Приоритет операций


Приоритет

Операция

1

not, @

2

*, /, div, mod, and, shl , shr

3

+, - , or, xor

4

=, <>, >, >=, <, <=, in

Примечание. Операции @ (получение адреса), shl (сдвиг влево), shr (сдвиг вправо) и in (принадлежность к множеству) описаны в гл.4.
Следует учесть, что в отличие от многих других языков программирования в Турбо Паскале логические операции имеют более высокий приоритет, чем операции отношения. В связи с этим, в сложных логических выражениях обычно необходимо расставлять скобки. Если, например, b и с имеют тип INTEGER , то выражение
а = b and с < d
вызовет сообщение о синтаксической ошибке, так как сначала выполнится операция b and с. Правильным будет выражение:
(а = b) and (с < d)
 
Операторы языка
С одним из наиболее часто используемых операторов языка Турбо Паскаль - оператором присваивания мы уже познакомились. Ниже рассматриваются остальные операторы языка.
 
Составной оператолр и пустой оператор
Составной оператор - это последовательность произвольных операторов программы, заключенная в операторные скобки - зарезервированные слова begin . . . end. Составные операторы - важный инструмент Турбо Паскаля, дающий возможность писать программы по современной технологии структурного программирования (без операторов перехода GOTO).
Язык Турбо Паскаль не накладывает никаких ограничений на характер операторов, входящих в составной оператор. Среди них могут быть и другие составные операторы - Турбо Паскаль допускает произвольную глубину их вложенности:
begin
.......
begin
.......
begin
......
......
end;
...... 
end;
......
end;
Фактически, весь раздел операторов, обрамленный словами begin . . . end, представляет собой один составной оператор. Поскольку зарезервированное слово end является закрывающей операторной скобкой, оно одновременно указывает и конец предыдущего оператора, поэтому ставить перед ним символ «;» необязательно, и далее во всех примерах мы не будем этого делать. Наличие точки с запятой перед end в предыдущих примерах означало, что между последним оператором и операторной скобкой end располагается пустой оператор. Пустой оператор не содержит никаких действий, просто в программу добавляется лишняя точка с запятой. В основном пустой оператор используется для передачи управления в конец составного оператора.
 
Условный оператор
Условный оператор позволяет проверить некоторое условие и в зависимости от результатов проверки выполнить то или иное действие. Таким образом, условный оператор - это средство ветвления вычислительного процесса.
Структура условного оператора имеет следующий вид:
IF <условие> THEN <оператор1> ELSE <оператор2>,
где IF, THEN, ELSE - зарезервированные слова (если, то, иначе); <условие> - произвольное выражение логического типа; <оператор1>, <оператор2> - любые операторы языка Турбо Паскаль.
Условный оператор работает по следующему алгоритму. Вначале вычисляется условное выражение <условие>. Если результат есть TRUE (истина), то выполняется <оператор1>, а <оператор2> пропускается; если результат есть FALSE (ложь), наоборот, <оператор1> пропускается, а выполняется <оператор2>. Например:
var
х, у, max: Integer;
begin
.......
if x > max then
у := max else
y := x;
При выполнении этого фрагмента переменная Y получит значение переменной X, если только это значение не превышает МАХ, в противном случае Y станет равно МАХ.
Часть ELSE <оператор2> условного оператора может быть опущена. Тогда при значении TRUE условного выражения выполняется <оператор1>, в противном случае этот оператор пропускается:
var
х, у, max: Integer; 
begin
.......
if x > max then
max := x; 
Y := x;
В этом примере переменная Y всегда будет иметь значение переменной X,а в МАХ запоминается максимальное значение X.
Поскольку любой из операторов <оператор1> и <оператор2> может быть любого типа, в том числе и условным, а в то же время не каждый из «вложенных» условных операторов может иметь часть ELSE <оператор2>, то возникает неоднозначность трактовки условий. Эта неоднозначность в Турбо Паскале решается следующим образом: любая встретившаяся часть ELSE соответствует ближайшей к ней «сверху» части THEN условного оператора. Например:
var
a,b,c,d : Integer; begin
a := 1; b := 2; c= 3; d := 4;
if a > b then
if с < d then 
if с < 0 then
с := 0 else
a := b; {аравно 1}
if a > b then 
if с then 
if с then 
с := 0
else
else 
else
a := b; {аравно 2}
Рассмотрим программу (пример 2.4), которая вводит произвольное десятичное целое число в диапазоне 0...15, преобразует его к шестнадцатеричному и выводит на экран полученный результат.
Пример 2.4 
Program Hex;
{Программа вводит с клавиатуры целое число в диапазоне от 0 до 15, преобразует его к шестнадцатеричной системе счисления и выводит результат на экран}
var
n : Integer; {Вводимое число} 
ch : Char; {Результат
begin
Write ( ',n = ' ) ;
ReadLn(n); { Вводим число } 
{Проверяем число на принадлежность к диапазону 0...15}
if (n >= 0) and (n <= 15) then
begin {Да, принадлежитдиапазону} 
if n < 10 then
ch := chr(ord('0') + n)
else
ch := chr(ord('A') + n- 10);
WriteLn('n = ',ch) 
end
else {He принадлежитдиапазону}
WriteLn('Ошибка') 
end.
В шестнадцатеричной системе счисления используется 16 цифр в каждом разряде: цифры 0...9 обозначают первые 10 возможных значений разряда, буквы A...F - остальные шесть.
В программе учитывается непрерывность и упорядоченность множеств цифр 0...9, букв A...F и их кодов (см. гл.4).
 
Операторы повторений
В языке Турбо Паскаль имеются три различных оператора, с помощью которых можно запрограммировать повторяющиеся фрагменты программ.
Счетный оператор цикла FOR имеет такую структуру: 
FOR <пар_цик> := <нач_знач> ТО <кон_знач> DO <оператор>.
Здесь FOR, TO, DO - зарезервированные слова (для, до, выполнить);
<пар_цик> - параметр цикла - переменная типа INTEGER (точнее, любого порядкового типа, см. гл.4);
<нач_знач> - начальное значение - выражение того же типа;
 <кон_знач> - конечное значение - выражение того же типа; 
<оператор> - произвольный оператор Турбо Паскаля.
При выполнении оператора FOR вначале вычисляется выражение <нач_знач> и осуществляется присваивание <пар_цик> : = <нач_знач>. После этого циклически повторяется:

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

В качестве иллюстрации применения оператора FOR рассмотрим программу, осуществляющую ввод с клавиатуры произвольного целого числа N и вычисление суммы всех целых чисел от 1 до N (пример 2.5).
Пример 2.5
Program Summ_of_Integer;
{Программа вводит целое положительное число N и подсчитывает сумму всех целых чисел от 1 до N}
var
i, n, s : Integer;
begin
Write('N = ');
ReadLn(n); . {Вводим N}
s := 0; {Начальное значение суммы}
for i : = 1 to n do {Циклподсчетасуммы} 
s : = s + i;
writeln('Сумма = ',s) {Выводимрезультат}
end.
Отметим два обстоятельства. Во-первых, условие, управляющее работой оператора FOR, проверяется перед выполнением оператора <оператор>: если условие не выполняется в самом начале работы оператора FOR, исполняемый оператор не будет выполнен ни разу. Другое обстоятельство - шаг наращивания параметра цикла строго постоянен и равен (+1). Существует другая форма оператора:
FOR<пар_цик>: = <нач_знач> DOWNTO <кон_знач> DO <оператор>
Замена зарезервированного слова ТО на DOWNTO означает, что шаг наращивания параметра цикла равен (-1), а управляющее условие приобретает вид <пар_цик> = <кон_знач>.
Пример 2.5 можно модифицировать так, чтобы сделать его пригодным для подсчета любых сумм - положительных и отрицательных:
..................
s := 0;
if n >= 0 then
for i := 1 to n do
s := s + i else
for i := -1 downto n do s : = s + i ;
...............
Два других оператора повторений лишь проверяют условие выполнения или повторения цикла, но не связаны с изменением счетчика цикла.
Оператор цикла WHILE с предпроверкой условия:
WHILE <условие> DO <оператор>.
Здесь WHILE, DO - зарезервированные слова (пока [выполняется условие], делать);
<условие> - выражение логического типа;
 <оператор> - произвольный оператор Турбо Паскаля.
Если выражение <условие> имеет значение TRUE, то выполняется <оператор>, после чего вычисление выражения <условие> и его проверка повторяются. Если <условие> имеет значение FALSE , оператор WHILE прекращает свою работу.
Рассмотрим пример 2.6, иллюстрирующий использование оператора WHILE. Найдем так называемое «машинное эпсилон» - такое минимальное, не равное нулю вещественное число, которое после прибавления его к 1.0 еще дает результат, отличный от 1.0.
Пример 2.6
Program EpsilpnDetect;
{Программа вычисляет и выводит на экран значение "машинного эпсилон"}
var
epsilon: Real;
begin
epsilon := 1;
while epsilon/2 + 1 > 1 do
epsilon := epsilon/2
WriteLn('Машинное эпсилон = ',epsilon) 
end.
У читателя, привыкшего к непрерывной вещественной арифметике, может вызвать недоумение утверждение о том, что в дискретной машинной арифметике всегда существуют такие числа 0<X<eps, что 1.0+Х=1.0. Дело в том, что внутреннее представление типа REAL может дать «лишь» приблизительно 1014 возможных комбинаций значащих разрядов в отведенных для него 6 байтах. Конечно же, это очень большое число, но оно несопоставимо с бесконечным множеством вещественных чисел. Аппроксимация бесконечного непрерывного множества вещественных чисел конечным (пусть даже и очень большим) множеством их внутреннего машинного представления и приводит к появлению «машинного эпсилон».
Оператор цикла REPEAT... UNTIL с постпроверкой условия:
REPEAT <тело_цикла> UNTIL <условие>.
Здесь REPEAT, UNTIL- зарезервированные слова (повторять до тех пор, пока не будет выполнено условие);
<тело_цикла> - произвольная последовательность операторов Турбо Паскаля; 
<условие> - выражение логического типа.
Операторы <тело_цикла> выполняются хотя бы один раз, после чего вычисляется выражение <условие>: если его значение есть FALSE, операторы <тело_цикла> повторяются, в противном случае оператор REPEAT. . . UNTIL завершает свою работу.
Для иллюстрации применения оператора REPEAT... UNTIL модифицируем программу из примера 2.3. Модификация (пример 2.7) состоит в том, что программа будет все время повторять цикл ввода символа и печати его кода до тех пор, пока очередным символом не будет символ CR (вводится клавишей Enter).
Пример 2.7 
Program Codes_of_Chars;
{Программа вводит символ и выводит на экран его код. Для завершения работы программы нужно дважды нажать Enter}
var
ch : Char; {Вводимый символ} 
const
CR = 13; {Кодсимвола CR} 
begin
repeat
ReadLn(ch);
WriteLn(ch,' = ',ord(ch))
until ord(ch) = CR
end.
Обратите внимание: пара REPEAT... UNTIL подобна операторным скобкам begin. .. end, поэтому перед UNTIL ставить точку с запятой необязательно.
Для гибкого управления циклическими операторами FOR, WHILE и REPEAT в состав Турбо Паскаля включены две процедуры:
BREAK - реализует немедленный выход из цикла; действие процедуры заключается в передаче управления     оператору, стоящему сразу за концом циклического оператора;
CONTINUE - обеспечивает досрочное завершение очередного прохода цикла; эквивалент передачи управления в самый конец циклического оператора.
Введение в язык этих процедур практически исключает необходимость использования операторов безусловного перехода GOTO.

 

 
На главную | Содержание | < Назад....Вперёд >
С вопросами и предложениями можно обращаться по nicivas@bk.ru. 2013 г. Яндекс.Метрика