1.1. Окно просмотра результатов Output

Скомпилированная программа сразу готова к работе: в окне Output будут выводиться все сообщения и запросы программы. Если она не запрашивает ввода данных с клавиатуры, то выходной экран виден до

- 12 -

тех пор, пока выполняется сама программа. После ее завершения происходит возврат в систему. Если требуется еще раз посмотреть, что вывела на экран программа, то нужно нажать на клавиши Alt+F5. На экране появится результат работы программы в таком виде, как если бы она была запущена под управлением MS-DOS.

Другая возможность просмотреть результат — это переход в окно Output и увеличение его размеров до полного экрана. Для этого необходимо произвести следующие действия:

1) нажать клавишу F6 (активизация окна Watch);

2) нажать комбинацию клавиш Alt+F6 для замены окна Watch на окно Output;

3) нажать клавишу F5 для расширения его до полного экрана.

В этом случае верхняя строка меню и нижняя строка помощи остается на экране. Для возврата требуется выполнить перечисленные действия в обратном порядке (F5, Alt+F6, F6).

В языке Турбо Паскаль реализовано несколько процедур, позволяющих управлять появлением текста на экране. Например, процедуры WriteLn и Write, выводящие информацию на дисплей; GotoXY, устанавливающая курсор в указанном месте; ClrScr, очищающая экран от текущей информации. Эффект от действия этих и других процедур (см. гл.15 «Модуль CRT») полностью проявляется в окне Output.

 

1.2. Окно просмотра переменных Watch

Это окно предназначено для отладка программ. В нем можно наблюдать изменение значений всех переменных при ее пошаговом выполнении. Окно Watch является важной частью отладчика Турбо Паскаля — инструмента для локализации и исправления ошибок в построении программы.

Для выбора переменных и выражений, которые необходимо наблюдать в окне Watch, можно пользоваться подменю Break/Watch основного меню. Для этого система устанавливается в один из режимов построкового выполнения (клавишей F7 или F8).

 

1.3. Структура меню

Главное меню Турбо Паскаля появляется в верхней строке экрана и содержит семь пунктов. Из окон Edit, Watch или Output можно активизировать меню, нажав клавишу F10. После этого используется два способа выбора пунктов из него:

1. Нажатие клавиши управления курсором (← и →) для перехода на следующий пункт я затем клавиши ввода для появления соответствующего вертикального подменю.

2. Нажатие клавиши с буквой, соответствующей выделенной букве нужного пункта: F,E,R,C,0,D или В.

Один из семи пунктов главного меню — Edit (редактирование текста) активизирует окно Edit и устанавливает мигающий курсор. После этого можно набирать текст программы. Другие пункты главного меню работают следующим образом: после выбора пункта под ним появляется подменю, в котором перечислены возможные команды или опции. Например, пункт File (работа с файлами) имеет подменю, показанное на рис. 1.4:

Рис. 1.4

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

Из уровня главного меню наиболее короткий путь к выполнению необходимой команды — последовательное нажатие двух клавиш с литерами, соответствующими нужным пунктам меню. Например, чтобы выполнить команду Quit, надо нажать последовательно клавиши F и Q. Эта команда выгрузит систему программирования из памяти. С другой стороны, можно использовать короткие команды, указанные в нижней строке экрана (для Quit — это Alt+X). Таким образом, Турбо Паскаль поддерживает два способа работы с системой: через меню и через короткие команды (функциональные клавиши и их комбинации с Alt и Ctrl).

- 14 -

 

1.3.1. Пункт File (работа с файлами)

Этот пункт главного меню используется для записи новых файлов с текстами программ, чтения уже существующих файлов с диска, работы с каталогами диска или выхода из среды программирования. Все эти команды просты в использовании. Рассмотрим их по порядку.

1.3.1.1. Команда загрузки файла Load (F3). Эта команда задает чтение файла программы с диска и загрузку его в редактор системы. После того как файл попадает в редактор, его можно модифицировать, компилировать, запускать на выполнение. При выборе этой команды на экране появится изображение, показанное на рис. 1.5.

Рис. 1.5

Если известно имя файла, то нужно набрать его и, нажав клавишу ввода, загрузить в окно Edit. Имя файла может не содержать полный путь к нему, если этот файл находится в текущем каталоге. Можно также набирать имя файла без расширения — загрузчик сам добавит к нему по умолчанию расширение PAS. Если необходимый файл находится в другом каталоге, то нужно набрать полное его имя с маршрутом к нему, например:

Е:\TURBO55\PAS\TEST.PAS

Если же загрузчик не обнаружил файла с указанным именем, то система откроет новый файл с точно таким же названием.

Всегда можно воспользоваться и предложенным в окне групповым именем. В этом случае при нажатии клавиши ввода система покажет список файлов с расширением .PAS в текущем каталоге (рис. 1.6).

Рис. 1.6

- 15 -

Можно выбрать любой файл из этого списка, переместив выделяющую строку (клавишами управления курсора или первой буквой имени файла) на его имя и нажав клавишу ввода. Этот файл загрузится в редактор и будет продолжена обычная работа. Список файлов выводится в алфавитном порядке.

Отменить текущее состояние системы меню можно, нажав клавишу Esc. После этого произойдет возврат к команде Load. Нажав еще раз Esc, можно убрать все вертикальное подменю с экрана.

1.3.1.2. Команда восстановления «истории» Pick (Alt+F3). Эта команда позволяет вернуться к работе с одним из файлов, который уже был загружен в редактор. Она показывает список из девяти файлов, отсортированных по порядку последних обращений к ним (рис. 1.7).

Рис. 1.7

Выбрав ее нажатием клавиши P (или Alt+F3 из основного меню), можно получить список, из которого выбирается файл для загрузки в редактор. Есть и другая возможность работы с Pick (правда, не такая полная): если находясь в редакторе, нажать комбинацию клавиш Alt+F6, то в него автоматически загрузится файл, с которым перед этим работали (т.е. верхний пункт в окне Pick). Этим обеспечивается подобие «двухоконности» редактора системы.

При выборе последней строки в этом списке (-load file-), выполняется команда Load. Обычно список Pick файлов теряется при выходе из системы. Однако его можно сохранить, записав на диск. Как это сделать, показано в описании пункта Options главного меню (разд. 1.3.5).

1.3.1.3. Команда открытия нового файла New. Эта команда удаляет текущий файл из редактора и устанавливает имя нового файла NONAME.PAS. Если текущий файл не был записан на диск после последней корректировки, то система выдаст запрос (рис. 1.8).

- 16 -

Рис. 1.8

Получив ответ «Y», система запишет текущий файл на диск, а получив ответ «N», система только удалит этот файл из редактора, и все изменения, внесенные в него, потеряются. Это очень важная альтернатива. Пользуясь ею, можно любым образом модифицировать программу и наблюдать, как она работает. А потом, ответив на запрос «N», оставить ее первоначальный вариант на диске неизменным.

1.3.1.4. Команда записи файла Save (F2). Эта команда записывает текущий файл из редактора на диск. В режиме редактирования ее можно выполнить, кроме обычного пути, нажатием клавиши F2. Система записывает файл с тем же именем, с которым он и был прочитан. Исключение составляет файл NONAME.PAS. Система предоставляет возможность его переименования, выдав сообщение (рис. 1.9).

Рис. 1.9

Если в ответ нажать клавишу ввода, то этот файл запишется с именем NONAME.PAS. Иначе, нужно набирать новое имя. При этом имя NONAME.PAS исчезнет. Если файл должен быть записан не в текущий каталог, то необходимо набрать его полное имя (можно без расширения — система сама его добавит).

При записи на диск уже существующего файла старая его версия переименовывается: вместо расширения .PAS она получает расши-

- 17 -

рение .ВАК. Это иногда бывает полезным — всегда имеется новая версия программы и предыдущая. Тем не менее существует возможность отключить такой режим записи (см. разд. 1.3.5).

1.3.1.5. Команда записи с новым именем Write To. Эта команда записывает файл, находящийся в окне Edit на диск, заменяя имя (и, возможно, каталог) этого файла. На экране появляется прямоугольник (рис. 1.10).

Рис. 1.10

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

1.3.1.6. Команда просмотра каталога Directory. Эта команда показывает содержимое текущего каталога. По умолчанию маской для выбора файлов является групповое имя *.*. Однако можно выбрать каталог и маску через окно запроса. Двигая прямоугольник выделения в окне списка содержимого каталога, можно открывать подкаталоги, если они есть, и свободно передвигаться по всей структуре диска. Если выбран какой-либо файл и нажата клавиша ввода, то этот файл будет прочитан и загружен в редактор. Фактически, эта команда может быть альтернативой команде Load при загрузке программ в систему.

1.3.1.7. Команда смены каталога Change Dir. Используя эту команду, можно сменить текущий каталог или диск. На экране появится окно для ввода имени нового каталога. После выполнения этой команды любые действия с файлами будут производиться по умолчанию в новом каталоге.

1.3.1.8. Команда временного выхода в MS-DOS — OS Shell. Эта команда позволяет работать в среде MS-DOS без выгрузки системы Турбо Паскаль. Выполнение этой команды влечет за собой очистку экрана и выдачу приглашения (PROMPT) MS-DOS. При этом происходит как бы выход из среды программирования в MS-DOS. После этого можно задавать любые команды MS-DOS: COPY,

- 18 -

RENAME, FORMAT и др., а также запускать любые программы, объем которых не превышает объема оставшейся памяти. Ограничения на размер возникают из-за того, что система Турбо Паскаль из памяти не выгружается (занимаемый ею объем составляет примерно 235К). Вернуться обратно в Edit можно, набрав в командной строке MS-DOS команду выхода EXIT. Все содержимое экрана DOS попадет при этом в окно Output.

Если какие-либо программы запускались в этом режиме, то прежде чем вернуться в Турбо Паскаль, необходимо убедиться, что они завершили свою работу. Особенно это касается вызовов в режиме OS Shell программ типа Norton Commander. Запуск резидентных программ в нем категорически противопоказан (это может сбить работу среды программирования).

1.3.1.9. Команда выхода из среды Quit. Эта команда позволяет выйти из системы (аналогичный результат получается, если нажата комбинация клавиш Alt+X). Команда производит выгрузку из памяти системы Турбо Паскаль. Чтобы войти обратно, надо запустить на выполнение в MS-DOS файл TURBO.EXE. Если в редакторе к моменту выхода остался незаписанный на диск файл, то система выдаст запрос (рис. 1.11).

Рис. 1.11

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

 

1.3.2. Пункт Edit (работа с редактором)

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

- 19 -

Line 1 Col 1 Insert Indent Tab Fill Unindent C:NONAME.PAS

Здесь:

Line и Col показывает текущее положение курсора в тексте (строка и колонка соответственно). Вначале курсор находится в левом верхнем углу текста (line 1, Col 1);

надпись Insert показывает, что установлен режим вставки при вводе символов. Если ее нет, то включен режим замещения (режимы переключаются клавишей Ins);

надпись Indent показывает, что включен (нажатием Ctrl+O I или Ctrl+Q I) режим автоматического отступа. При этом после нажатия клавиши ввода курсор установится в ту же колонку, с которой начиналась предыдущая строка;

надпись Tab говорит о том, что при нажатии клавиши TAB в текст будет вставлен символ табуляции (код ASCII 9). В противном случае будет вставлено заданное число пробелов (по умолчанию — 8); режим управляется комбинацией клавиш Ctrl+O T;

режим Fill (он управляется нажатием Ctrl+O F) задает оптимальную замену последовательностей пробелов символами табуляции при записи файла на диск;

если установлен режим Unindent (нажатием Ctrl+O U), то при нажатии клавиши удаления Backspace будут удалены все пробелы и знаки табуляции, отделяющие текущий символ от позиции начала предыдущей строки;

C:NONAME.PAS — имя текущего файла (т.е. файла, с которым производится работа).

Полный перечень команд редактора находится в Приложении 5. Сочетания клавиш типа Ctrl+O U должны набираться следующим образом: держа клавишу Ctrl нажатой, нажимают последовательно клавиши O и U.

Рассмотрим некоторые наиболее сложные группы команд.

1.3.2.1. Работа с блоками. Для обозначения начала блока надо поставить курсор на символ, являющийся первым в блоке и нажать Ctrl+K, а для обозначения конца блока (Ctrl+K K) курсор должен находиться непосредственно за его последним символом. Блок обычно выделяется цветом. После того как блок обозначен, его можно скопировать (командой Ctrl+K C) или перенести (Ctrl+K V) в позицию, заданную курсором. Удалить блок из текста можно командой Ctrl+K Y, а отменить выделение — командой Ctrl+K H (она же восстановит выделение вновь). При записи блока на диск (Ctrl+K W) Турбо Паскаль присоединяет автоматически к имени файла расширение .PAS. При чтении блока с диска (Ctrl+K R) Турбо Паскаль в запросе имени будет предлагать имя последнего записанного на диск блока.

- 20 -

1.3.2.2. Поиск и замена. При работе команд поиска строки в тексте (Ctrl+Q F) и поиска/замены (Ctrl+Q A) Турбо Паскаль в специальной строке запрашивает строку поиска (при поиске/замене еще и строку-замену), а затем режимы поиска, выдав запрос «Options:». Здесь можно ввести строку, содержащую любую комбинацию символов B,G,U,L,N,W и цифр. Они служат для задания режима работы этих команд:

символ B задает поиск назад, начиная от позиции курсора (обычно поиск производится вперед от текущей позиции курсора);

символ G задает режим глобального поиска, т.е. заданная строка ищется от начала файла до его конца. При завершении поиска, курсор устанавливается на последнее найденное определение. Сочетание символов B и G задает глобальный поиск от конца файла до его начала;

символ U позволяет игнорировать различие между строчными и прописными символами в поиске определения;

символ L задает поиск определения внутри обозначенного блока;

символ N (если указан) отменяет запросы подтверждения замены после нахождения заданной строки. Работает только в режиме поиска/замены;

символ W задает поиск отдельных слов, полностью совпадающих с определением (по умолчанию производится поиск любого сочетания, совпадающего с определением, даже если оно является частью другого слова);

цифра, указанная в запросе Options, указывает, на какой по счету найденной строке-определении приостановить поиск.

1.3.2.3. Расстановка маркеров. Маркеры — это специально помеченные командами Ctrl+K n (где n — цифровая клавиша — номер маркера в пределах от 1 до 5) позиции в тексте, в которые всегда можно быстро переместить курсор командой Ctrl+Q n.

1.3.2.4. Восстановление строки. После изменения содержания какой-либо строки текста можно восстановить его командой Ctrl+Q L, при условии, что курсор не покидал эту строку. После удаления редактируемой строки эта команда не работает.

 

1.3.3. Пункт Run (запуск на выполнение)

Этот пункт основного меню предоставляет несколько различных способов запуска программы на выполнение. В его подменю (рис. 1.12) представлено шесть команд, каждой из которых соответствуют

- 21 -

Рис. 1.12

комбинации функциональных клавиш. Это сделано для быстрого доступа к командам. Рассмотрим их подробнее.

1.3.3.1. Команда выполнения Run (Ctrl+F9). Эта команда инициализирует запуск текущей программы. Если программа еще не откомпилирована или после компиляции в нее были внесены изменения, то команда Run сначала компилирует ее. В конце работы программы окно Output заменяется экраном среды. Если требуется еще раз взглянуть на результат работы программы, то надо нажать комбинацию клавиш Alt+F5 (аналогичный результат дает команда User screen в этом же пункте меню). Если система находится в режиме отладки, то по команде Run программа будет далее выполняться в обычном режиме.

1.3.3.2. Команда прекращения отладки Program Reset (Ctrl+F2). После этой команды процесс отладки программы прекращается. При этом система не освобождает всю память, которую занимал код программы при отладке, поэтому точки останова и переменные просмотра (см. разд. 1.3.7.1) остаются.

1.3.3.3. Команда выполнения до курсора Go To Cursor (F4). С помощью этой команды можно запустить программу в работу. Ее выполнение будет происходить до тех пор, пока отладчик не достигнет строки, в которой находится курсор в окне Edit (при этом сама эта строка выполняться не будет). Таким образом, появляется возможность начинать отладку с любого места программы, например из процедуры, в которой предполагается ошибка.

Воспользоваться командой Go To Cursor можно в любой момент работы системы с редактором или отладчиком. При этом в режиме отладки программа выполнится без остановок (за исключением явно заданных точек останова) до курсора. В режиме редактирования по команде F4 будет произведена компиляция программы и ее запуск.

1.3.3.4. Команда детальной трассировки Trace Into (F7). Во время пошаговой отладки команда Trace Into задает выполнение текущей строки программы. Для того чтобы проследить за логикой выполнения программы или за изменением некоторых переменных при выполнении определенных строк, необходимо подавать эту

- 22 -

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

Если отладочная метка находится на строке, содержащей вызов функции или процедуры, то команда Trace Into передаст управление им (это может повлечь за собой загрузку дополнительного файла, содержащего текст этой процедуры) и установит метку на их первую выполняемую строку. При достижении конца процедуры отладчик вернется к основному файлу и поставит метку на следующую после вызова строку.

1.3.3.5. Команда выполнения по строкам Step Over (F8). Эта команда очень похожа по управлению и действиям на команду Trace Into, однако не совершает «заходов» в процедуры и функции, просто выполняет их как одну строку основной программы.

1.3.3.6. Команда просмотра результатов User Screen (Alt+F5). С помощью этой команды можно просматривать результат не только на текстовом экране, но и на графическом, что бывает очень полезно при работе с модулем Graph (см. гл. 19 «Модуль Graph»).

 

1.3.4. Пункт Compile (компиляция)

Этот пункт главного меню содержит несколько опций для компиляции программ, в том числе три команды для собственно компиляции (рис. 1.13).

Рис. 1.13

Команды Compile, Make и Build — это три возможных пути для компиляции программ, состоящих из нескольких файлов. Дело в том, что результат работы команд Make и Build зависит от порядка внесения изменений в тексты программ, компилируемых совместно, а также от состояния опции Primary File в этом же меню. В связи с этим было бы полезно рассмотреть все команды пункта Compile подробно.

1.3.4.1. Команда компиляции Compile (Alt+F9). Эта команда инициализирует компиляцию и всегда обрабатывает текущий файл, находящийся в данный момент в окне Edit. При этом на экране

- 23 -

появляется окно информации о процессе (рис. 1.14). В нем показывается количество обработанных строк, объем доступной оперативной памяти и т.д.

Рис. 1.14

Если компиляция закончилась успешно (а это может произойти в случае, если не было ошибок), в нижней строке этого окна выдается сообщение о завершении процесса:

Success : Press any key

Успешно : Нажните любую клавишу

Если же была обнаружена ошибка, то Турбо Паскаль активизирует редактор и его курсор устанавливается в ту строку, в которой она была сделана. Расшифровку ошибки можно увидеть в верхней строке окна редактора. Заметим, что компилятор прекращает свою работу, как только обнаруживается ошибка. Исправив ее, можно обнаружить другую ошибку, расположенную ниже по тексту. Так можно проверить весь текст программы до конца, исправляя каждый раз ошибки. Детальное описание ошибки можно получить, нажав F1.

1.3.4.2. Команда избирательной компиляции Make (F9). Если программа состоит из модулей (которые могут быть взаимосвязанными) и исходные тексты модулей доступны системе, то было бы естественным перекомпилировать только те модули, которые претерпели изменения, а прочие подключить в уже откомпилированном виде. Именно такой режим компиляции задает команда Make. При ее подаче система проверяет все файлы модулей, составляющие программу, и если эти файлы изменены после последней компиляции, то они будут перекомпилированы. Также перекомпилируются все зависящие от них модули. При проверке файлов система сравнивает дату и время файла с исходным текстом и файла с кодом, полученным после компиляции. Команда Make плохо работает на ПЭВМ, не снабженных часами на аккумуляторах.

- 24 -

1.3.4.3. Команда общей компиляции Build. Команда Build производит компиляцию всех доступных системе текстов, составляющих программу, независимо от того, были ли они корректированы после компиляции или нет.

1.3.4.4. Опция назначения первого файла Primary file. Опция Primary file значительно упрощает работу с множеством файлов. Используя ее, можно указывать системе на главный файл в многофайловой программе. При этом любая команда компиляции будет обрабатывать именно этот файл, а не тот, что загружен в текущий момент в редактор. Файл, который ранее находился в редакторе, после компиляции восстановится в нем (правда, только в том случае, если не было ошибок).

Чтобы указать системе на первый файл, нужно выбирать пункт Compile главного меню, затем пункт Primary file. Турбо Паскаль покажет входное окно, указанное в описании команды Load (см. разд. 1.3.1.1). Выбор файла производится так же. После того как выбран файл, его имя будет все время появляться в окне информации о процессе, например:

Primary file (Первый файл): MAINPR.PAS

Теперь, если воспользоваться командами компиляции, то Турбо Паскаль сначала прочитает и загрузит в память Primary file, а затем начнет его компилировать.

Прежде чем закончить работу с одним программным проектом и приступить к другому, нужно удалить старое имя Primary file. Для этого выбирается в меню опция Primary file и нажимается клавиша пробела или комбинация клавиш Ctrl+Y. Имя Primary file при этом стирается из окна выбора файла.

1.3.4.5. Опция установки EXE- и TPU-файлов Destination. Эта опция используется для указания системе, куда должен быть помещен скомпилированный файл. В опции Destination определены две альтернативы: Memory и Disk (память и диск). По умолчанию коды компиляции сохраняются в памяти. Это очень удобно, так как можно производить изменения в программе и тут же видеть их результат. Ради такой работы, собственно, и была создана система Турбо Паскаль. Если же выбрана опция Disk, то выполняемые EXE-файлы и модули (TPU-файлы) всегда записываются на диск. Это необходимо для получения программы, которая может работать непосредственно под управлением MS-DOS.

1.3.4.6. Команда указания строки ошибки Find Error. Это важная команда для автономного компилятора. Тем не менее опишем ее здесь. Если во время выполнения программы по команде Run при включенном отладчике была обнаружена ошибка, то отладчик активизирует редактор, найдет строку, во время выполнения которой

- 25 -

произошла ошибка, установит туда курсор и выдаст в верхней строке окна Edit сообщение об ошибке (рис. 1.15).

Если же программа была запущена под управлением MS-DOS

Рис. 1.15

или из среды программирования при отключенном отладчике, то в случае ошибки ее выполнение прервется и на экране появится сообщение следующего вида:

Runtime error 200 at 20B0:8236

Ошибка выполнения 200 по адресу 20B0:8236

В нем содержится важная информация: номер ошибки и адрес команды, которая привела к ошибке. Воспользовавшись списком ошибок выполнения программ, можно по номеру ошибки определить ее вид. Например, ошибка 200 — это деление на ноль. Чтобы определить, в каком месте текста программы произошла ошибка, необходимо произвести следующие действия:

1) запомнить адрес, выданный в сообщении (лучше записать);

2) войти в систему Турбо Паскаль;

3) загрузить текст этой программы в редактор;

4) включить режим отладки (см. разд. 1.3.5.1);

5) откомпилировать программу (Alt+F9);

6) выбрать пункт Compile основного меню и в нем дать команду Find Error;

7) ввести запомненный (записанный) адрес в окна ввода адреса (рис. 1.16). После нажатия клавиши ввода в этом окне система быстро

Рис. 1.16

- 26 -

определит место ошибки в тексте программы, и курсор редактора укажет на строку, в которой произошла ошибка.

1.3.4.7. Команда получения общего состояния Get Info. Выбрав этот пункт меню, можно открыть на экране новое окно, содержащее различную информацию о текущем состоянии системы и программы (рис. 1.17).

Рис. 1.17

 

1.3.5. Пункт Options (установка параметров системы)

Этот пункт позволяет управлять характеристиками компилятора и самой среды Турбо Паскаль. Меню Options содержит семь пунктов (рис. 1.18).

Рис. 1.18

Первые четыре опции — Compiler, Linker, Environment и Directories — имеют еще одно подменю, содержащее несколько директив. Остальные опции необходимы только в специальных ситуациях.

1.3.5.1. Установки компилятора Compiler. Меню, появляющееся при выборе этой команды, показано на рис. 1.19. Пункты в меню

- 27 -

Рис. 1.19

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

Выражение «директива компилятора» означает, что инструкции даются компилятору во время обработки текста программы. Подробно о ее синтаксисе рассказывается в разд. 3.3 «Комментарии и ключи компиляции» и разд. 3.4 «Условная компиляция программ».

Режим проверки диапазонов Range Checking. Когда компиляция программы происходит в режиме Range Checking On (включен), исполняемый код формируется так, что при выполнении программы происходит контроль:

1) выхода индекса массива за его границы;

2) переполнения переменных типа String;

3) переполнения разрядной сетки числовых переменных;

4) некорректная инициализация данных типа «объект».

Как только происходит нарушение, программа прекращает свою работу и генерируется ошибка выполнения (Runtime error).

По умолчанию режим Range Checking находится в состоянии Off (выключен). Однако при отладке программы очень полезно включить этот режим (On), так как это увеличит ее эффективность. После отладки рекомендуется восстановить состояние Off.

Режим проверки стека Stack Checking. Стек — это область памяти, в которой программы обычно сохраняют значения локальных переменных во время работы процедур или функций.

- 28 -

Если программа была откомпилирована в режиме Stack Checking On, то компилятор включает в исполняемые коды программы проверки состояния стека при вызове процедур или функций. Если размер стека не достаточен, чтобы сохранить в нем локальные переменные вызываемой программы, то генерируется ошибка выполнения. По умолчанию этот режим устанавливается в состояние On.

Размер стека в Турбо Паскале по умолчанию принимается равным 16K. Для изменения этого значения используется опция Memory Sizes рассматриваемого подменю настройки компилятора.

Режим проверки ввода-вывода I/O Checking. В этом режиме компилятором генерируются коды проверки ошибок ввода-вывода. По умолчанию он включен, и программа будет генерировать ошибку выполнения. Под ошибкой ввода-вывода подразумевается любое аварийное прерывание при обращении к любому периферийному устройству центрального процессора ПЭВМ (чтение-запись на дисках, печать на принтере, ввод с клавиатуры и т.д.).

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

Режим генерации «дальних» вызовов Force Far Calls. Этот режим применяется в специальных приложениях программирования. «Дальний» вызов (длинный адрес, Far Call) — это полная адресация для части процедур и функций, размещаемых в разных сегментах памяти отдельно от основного программного сегмента. («Дальний» вызов содержит в себе, кроме относительного адреса сегмента, необходимого внутри 64-килобайтного блока, еще и базовый адрес внешнего сегмента.)

Обычное состояние режима Force Far Calls – Off. При этом компилятор генерирует только «ближние» (near) вызовы. Если же состояние – On, то дальние вызовы генерируются для всех процедур и функций программы. Например, дальние вызовы обязательны при генерации оверлейного кода (см. гл. 18 «Модуль Overlay»).

Режим генерации оверлейных кодов Overlay Allowed. Оверлеи — это части кода программы, которые во время ее выполнения могут перекрываться. Их использование позволяет системе выполнять программы, размер которых больше, чем размер всей доступной памяти в компьютере. Оверлеи загружаются в память в тот момент, когда становятся нужны находящиеся в них программы, и после завершения своей работы выгружаются из памяти, освобождая место для другого оверлея.

- 29 -

Чтобы получить модуль, который планируется использовать как оверлейный, необходимо включить этот режим. По умолчанию состояние Overlay Allowed — Off. Более подробно этот вопрос будет рассмотрен в гл. 18 «Модуль Overlay».

Опция установки единицы обработки данных Align Data. Эта опция управляет режимом доступа к данным в компьютерах на базе микропроцессоров семейства 80Х86. По умолчанию используется режим Word как наиболее эффективный. Рекомендуем использовать режим по умолчанию. Более подробно об этом см. Приложение 2.

Режим проверки строк-переменных Var-String Checking. Этот режим определяет, как точно компилятор будет проверять значения типа String, передаваемые в процедуры и функции. По умолчанию он имеет значение Strict (точно). При этом строковые переменные, которые передаются по ссылке, должны точно соответствовать типу формальных VAR-параметров, определенных в заголовке вызываемых процедур или функций. Если это не так, то генерируется ошибка выполнения. Если же этот режим имеет значение Relaxed (ослабленная), то длина строкового аргумента передается процедуре или функции без сравнения ее с длиной формального параметра.

Режим проведения логических операций Boolean Evolution. Этот режим определяет метод работы Турбо Паскаля с логическими выражениями, использующими операторы AND и OR. Он имеет два состояния. Первое по умолчанию — Short Circuit (короткие вычисления). При этом коды формируются по следующим правилам:

1. В выражении «a AND b», если «f=False», то значение b не вычисляется.

2. В выражении «a OR b», если «a=True», то значение b не вычисляется.

И наоборот, полное вычисление операндов в логических выражениях производится при втором состоянии — Complete (полностью).

Режим использования сопроцессора Numeric Processing. Язык Турбо Паскаль может генерировать коды, которые управляют работой сопроцессоров 8087 и 80287. Если такой микропроцессор установлен на применяемой ПЭВМ, то программы, использующие эти коды, будут работать быстрее, особенно если в них много математических расчетов, и могут использовать расширенный набор типов с плавающей точкой (см. разд. 9.5).

Режим Numeric Processing определяет, будет или нет использоваться расширенный набор типов данных. Если режим включен в состояние Software (программное исполнение), то нет; если же он — в состоянии 8087/80287, то да. По умолчанию режим Numeric Processing устанавливается в Software.

- 30 -

Режим генерации эмулирующих кодов Emulation. Этот режим работает только в том случае, если Numeric Processing установлен в 8087/80287. При этом можно включать в выполняемые коды эмуляцию или отключать ее. По умолчанию этот режим включен. В этом случае Турбо Паскаль проверяет наличие в ПЭВМ сопроцессора. Если он есть, то используются коды управления сопроцессором. Если же сопроцессора нет в ПЭВМ, то используются коды эмуляции и программа работает медленнее. В том случае, если режим Emulation выключен, a Numeric Processing — в состоянии 8087/80287, программа будет проверять наличие сопроцессора, и если его нет, то ее выполнение прекращается.

Режим генерации отладочной информации Debug Information. Этот режим включает генерацию отладочной информации, необходимой для работы встроенного отладчика. Если он включен (по умолчанию), то компилятор генерирует коды, необходимые для нормальной работы этого отладчика (при этом опция Integrated Debugging в меню пункта Debug должна быть так же установлена в состояние On). Кроме того, эта информация позволяет Турбо Паскалю определять строку, в которой произошла ошибка выполнения программы.

Если режим Debug Information установить в состояние Off, то нельзя будет определить, в какой строке произошла эта ошибка. Более того, нельзя воспользоваться командами из меню пункта Run — Trace into, Step over и Go To Cursor, а также невозможно воспользоваться точками останова, которые задаются в меню пункта Break/Watch.

Запись информации о локальных переменных Local Symbols. По этой опции компилятор определяет, надо ли генерировать информацию о константах и переменных, находящихся внутри процедур и функций программы. Когда опция установлена в состояние On (по умолчанию), компилятор позволяет производить проверку значений переменных внутри процедур и функций во время отладки. Если же опция установлена в состояние Off, то нельзя посмотреть значения переменных и констант в окне Watch. Заметим, что если режим Debug Information выключен, то установки в Local Symbols игнорируются.

Задание условных ключевых слов Conditional Defines. Язык Турбо Паскаль поддерживает условную компиляцию, при использовании которой можно включать или игнорировать как отдельные строки, так и целые блоки в программе. Этой возможностью можно управлять через специальную группу директив компилятора. Они представляют собой структуры IF/ELSE/ENDIF, которые и используются для выделения блоков строк, являющихся в этом случае субъектами условной компиляции.

- 31 -

Можно использовать пункт Conditional Defines для определения ключевого слова при использовании директив $IFDEF или $IFNDEF. Результат этих условных директив зависит от определения слова (см. разд. 3.4).

Определение размеров памяти Memory Sizes. С помощью этой опции можно задать потребные ресурсы памяти для работы программы. Подробно этот вопрос обсуждается в разд. 11.4 и 16.6 и в Приложении 2 (директива $M).

1.3.5.2. Опция Linker (компоновщик). При компиляции программы Турбо Паскаль автоматически компонует все процедуры и функции, которые составляют программу. При этом связываются между собой объектные коды программы и коды модулей-библиотек. Подменю опции Linker имеет два пункта, позволяющих регулировать этот процесс (рис. 1.20).

Рис. 1.20

Режим генерации таблицы распределения памяти Map File. Когда этот режим включен, а опция Destination пункта Compile принимает значение Disk, Турбо Паскаль генерирует на диске специальный текстовый файл, содержащий информацию об откомпилированной программе. Этот файл создается во время компиляции в EXE-файл и носит то же имя, но с другим расширением — .MAP. В этом файле содержится информация о переменных, процедурах и функциях, их адресах при выполнении, объеме занимаемой ими памяти и т.п. Степень детализации этой информации задается переключателем режимов: Off (выключено), Segments (по сегментам), Publics (все глобальные переменные), Detailed (детально). По умолчанию устанавливается Off.

Опция установки буфера компоновщика Link Buffer. По умолчанию Турбо Паскаль загружает все запрашиваемые подпрограммы непосредственно в память ПЭВМ и проводит всю компоновку основной и включаемых подпрограмм в памяти. Однако, если программа

- 32 -

очень большая, то может не хватить памяти ПЭВМ. Тогда появляется необходимость указать среде, чтобы компилятор во время компоновки использовал в качестве своего буфера диск вместо памяти.

Вот это и позволяет сделать опция Link Buffer. Как уже говорилось, по умолчанию Link Buffer находится в состоянии Memory. Поставив указатель на эту опцию и нажав клавишу ввода, можно сменить установку на Disk.

1.3.5.3. Опция установки условий работы среды Environment. При выборе этой опции на экране появляется меню, содержащее комбинацию ключей On/Off, входных параметров и одного подменю (рис. 1.21).

Рис. 1.21

Все они позволяют управлять «поведением» среды Турбо Паскаль.

Опция Config Auto Save. Эта опция задает автоматическую запись конфигурации. Если она включена (On), то на диске сохраняется конфигурация среды разработки на момент выхода из нее. При последующем входе в среду это состояние читается с диска и восстанавливается. Это позволит как бы не прерывать работы в среде. По умолчанию опция находится в состоянии Off.

Опция Edit Auto Save. Эта опция задаст автоматическую запись состояния редактора. Если она находится в состоянии On, то перед выполнением программы ее текст будет сохранен на диске. Это может спасти от потери программы при неисправимой ошибке выполнения (например, при зависании системы). Кроме того, программа будет сохраняться при выполнении команды OS Shell пункта File основного меню. По умолчанию опция находится в состоянии Off.

Опция Backup Files. Эта опция используется для задания резервирования файлов. Если она — в состоянии On, то при сохранении файла на диске система предыдущую его версию сохранит с тем же именем, но с расширением BAK. Таким образом, всегда на диске

- 33 -

имеются две последние версии программы. По умолчанию опция находится в состоянии On.

Опция Tab Size. С помощью этой опции можно изменить принятый по умолчанию шаг горизонтальной табуляции, равный восьми позициям. Если нажата клавиша ввода на этой опции, то на экране появится окно ввода, в котором можно указать число в диапазоне от 2 до 16 для установки нового шага табуляции.

Опция Zoom Windows. Эта опция используется для расширения окна. Она позволяет раздвигать окно на весь экран. Действительна только для окон Edit, Watch и Output. По умолчанию находится в состоянии Off. При этом на экране видны одновременно два окна Edit и Watch или Edit и Output.

Опция Screen Size. Эта опция позволяет максимально использовать возможности контроллера дисплея (см. гл.15 «Модуль CRT»), a также выбрать количество видимых текстовых строк на экране: 25 (для всех) и 43 (для EGA) или 50 (для VGA).

Опция установки каталогов Directories. Эта опция позволяет указывать каталоги для хранения различных файлов Турбо Паскаля. При постоянной работе в интегрированной среде накапливается большое количество файлов. Поэтому необходимо их отсортировать и разделить по определенным признакам. Опция Directories предоставляет метод классификации. Остается лишь указать каталоги, в которых должны храниться файлы каждого класса. Вообще говоря, при выборе опции Directories на экране появляется окно, в котором уже указаны некоторые каталоги по умолчанию (рис. 1.22).

Рис. 1.22

Их можно изменять, выбрав соответствующий пункт меню. При этом в опциях Include, Unit и Object можно указать по нескольку каталогов, разделяя пути к ним точкой с запятой (как в команде

- 34 -

MS-DOS PATH). При этом Турбо Паскаль будет производить поиск необходимых файлов в текущем каталоге, затем, если они не найдены, осуществлять их поиск последовательно во всех каталогах, указанных для данного типа файла.

Приведем краткое описание каждого пункта опции Directories:

Turbo — указывает компилятору местонахождение системных файлов, в том числе файла конфигурации и Help-файла.

ЕХЕ & TPU — указывает компилятору, в каком каталоге создавать выполняемые коды программ, а также записывать TPU-файлы (модули), создаваемые при компиляции программ, имеющих заголовок UNIT.

Include — указывает компилятору, где искать файлы, определяемые директивой включения в тексте основной программы {$I ИмяФайла}.

Unit — если в программе использовались модули (они указываются директивой USES), то Турбо Паскаль при компиляции будет искать их в каталогах, указанных в этом пункте.

Object — указывает компилятору Турбо Паскаля, где искать OBJ-файлы для программ, использующих внешние ассемблерные процедуры и функции. (Они обычно объявляются в тексте директивой {$L ИмяФайла}.)

Pick file name — указывает имя файла, в котором сохраняется при выходе из среды Турбо Паскаля список последних девяти файлов, с которыми работал редактор (см. команду File/Pick). Имя этого файла по умолчанию принимается TURBO.PCK. Изменить его можно, выбрав курсором эту опцию и нажав клавишу ввода. После этого в окне ввода набирается имя нового файла. При входе в среду содержание этого файла читается системой из текущего каталога, и список Pick восстанавливает свое последнее состояние.

1.3.5.4. Опция установки командных параметров Parameters. Эта опция поможет в разработке и тестировании программ, использующих при запуске в командной строке дополнительные параметры. Для получения их программой в Турбо Паскале имеются специальные функции ParamStr и ParamCount. Если запускается EXE-программа, то она запрашивает параметры, которые вводятся с клавиатуры. А вот если программа запускается на выполнение из среды, то описываемая опция позволяет автоматически решить проблему этого ввода. Задав в окне ввода параметры один раз, можно тестировать программу много раз, не повторяя этой операции.

1.3.5.5. Команды управления файлами конфигурации Save/Retrieve Options. В них записываются все опции и установки, которые устанавливаются в пункте Options главного меню. При этом можно создавать столько файлов, сколько нужно для работы (обычно их число равно числу программных проектов, находящихся в работе или числу пользователей). Для этого используется команда Save Options. Каждый из этих файлов будет иметь расширение .TP (по умолчанию имя файла — TURBO.TP).

Если необходимо установить параметры системы, хранящиеся в созданном файле, то используется команда Retrieve Options.

Команда записи состояния Save options. При подаче этой команды появляется окно ввода, запрашивающее имя, которое должно быть присвоено новому файлу конфигурации. После ввода нового имени нужно нажать клавишу ввода, и файл будет создан. Для того чтобы записать в тот файл, имя которого появилось в окне ввода, можно просто нажать клавишу ввода. При этом система обязательно предупредит о том, что он уже существует, и выдаст запрос на его перезапись.

Команда чтения состояния Retrieve options. Если системе задать выполнение этой команды, то на экране появится окно запроса имени с уже готовым шаблоном: *.ТР. Если нажать клавишу ввода, то на экране появится список доступных файлов конфигурации, находящихся в текущем каталоге. После этого выбирается нужный и нажимается клавиша ввода. При этом в системе все опции перейдут в состояние, указанное в этом файле.

Следующие два пункта главного меню Debug и Break/Watch содержат команды и опции, относящиеся к системе отладки среды программирования Турбо Паскаль.

 

1.3.6. Пункт Debug (установки отладчика)

В меню Debug представлено семь пунктов (рис. 1.23).

Рис. 1.23

- 36 -

Часть из этих пунктов управляет «поведением» компилятора, другие позволяют проводить определенные действия во время отладки. Два пункта работают при определенных обстоятельствах: пункт Call Stack используется только во время отладки, а пункт Find Procedure доступен только после того, как программа откомпилирована.

1.3.6.1. Оценка значений переменных Evaluate (Ctrl+F4). Во время отладки эта команда позволяет просмотреть значения переменных и выражений в программе, не обращаясь к окну Watch. При этом можно не только просмотреть значение переменной, но и задать новое, чтобы проследить, как изменится дальнейший ход программы.

После этой команды на экране появляется окно, содержащее три горизонтальных поля (рис. 1.24).

Рис. 1.24

В поле Evaluate вводится имя переменной или выражение, значение которого нужно посмотреть. Находясь в редакторе, можно подвести курсор к нужному имени переменной или к началу выражения в тексте и нажать Ctrl+F4. Если вслед за этим сразу нажать стрелку курсора вправо, то можно расширить взятую в окно Evaluate строку текста.

После нажатия клавиши ввода в поле Result появляется их текущее значение. Просмотр можно задавать в любом формате: десятичном, шестнадцатеричном, символьном и т.д. Делается это следующим образом: после имени переменной ставится запятая, а затем символ спецификации формата или их сочетание. Например, пусть объявлена константа

CONST

dec : Array [1..10] of Integer =

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);

Задав в окне Evaluate строку

Dec

- 37 -

в окне Result получим

(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

а задав строку по-другому:

dec[2], 4H

в окне Result получим значения

$14, $1Е, $28, $32.

Такой формат результата получен, так как был задан показ четырех значений массива dec в шестнадцатеричном формате, начиная со второго элемента. Приведем таблицу символов спецификации и их функций (табл. 1.2).

После получения значения переменной в окне Result можно нажать два раза клавишу управления курсором «вниз» или клавиши TAB, в поле New — набрать новое ее значение, а затем продолжать проводить отладку командами Trace Into, Step Over или Go To Cursor.

Таблица 1.2

Спецификация формата	Функция
$	Шестнадцатеричное значение. Имеет такое же действие, как спецификатор формата H
C	Символ. Задает специальный символ для управляющих символов (значения кода ASCII от 0 до 31). По умолчанию такие символы выводятся их номерами в таблице кода ASCII в виде #xx. Влияет на все символы и строки
D	Десятичное значение. Все целые значения выводятся на экран в десятичном виде. Влияет на простые выражения целого типа, а также на структуры (массивы и записи), содержащие целые значения
H	Шестнадцатеричное значение. Все целые значения будут выводиться в шестнадцатеричном виде с предшествующим символом $. Влияет на простые выражения целого типа, а также на структуры (массивы и записи), содержащие целые значения

- 38 -

R	Запись. Выводит на экран имена полей записи, например (x:1;y:10;z:5) вместо (1, 10, 5). Влияет только на переменные типа 'запись'
X	Шестнадцатеричное значение. Действует так же, как спецификатор формата H
Fn	Выражение с плавающей запятой, где n – это целое значение от 2 до 18, задающее число выводимых на экран значащих цифр; по умолчанию это значение равно 11. Влияет только на значения в формате с плавающей точкой
P	Указатель. Выводит указатели в формате 'сегмент:смещение', а не в принятом по умолчанию формате Ptr(seg,ofs). Например, на экран выводится 3ЕА0:0020 вместо Ptr($3EA0,$20). Влияет только на значения типа 'указатель'
S	Строки. Показывает управляющие символы кода ASCII (коды от 0 до 31) в виде значений кода ASCII. При этом используется синтаксис #хх. Поскольку этот формат принят по умолчанию, использовать спецификатор S полезно только в сочетании со спецификатором M
M	Память. Выводит на экран содержимое ячеек памяти переменной. Выражение должно представлять собой конструкцию, которую допускается использовать в левой части оператора присваивания (т.е. конструкцию, обозначающую адрес памяти). В противном случае спецификатор М игнорируется. По умолчанию каждый байт переменной показывается в виде двух шестнадцатеричных цифр. Добавление спецификатора формата D приводит к тому, что байты будут выводиться в десятичном представлении, а добавление спецификаторов H, $ и X задает вывод байтов в шестнадцатеричном виде с предшествующим символом $. Спецификаторы формата C или S приводят к тому, что переменная будет выводиться в виде строки (со специальными символами или без них). По умолчанию число выводимых байтов соответствует размеру переменной, но для точного задания числа выводимых байтов можно использовать счетчик повторения

- 39 -

Команду Evaluate можно использовать в качестве калькулятора, производящего простые арифметические расчеты, вне зависимости от того, находится система в режиме отладки или нет. Для этого дается команда Evaluate, в поле Evaluate набирается выражение, значение которого нужно выяснить, например:

2*5 или 12 DIV 8,

и в поле Result появится ответ: 10 или 1, соответственно.

1.3.6.2. Просмотр состояния стека Call Stack (Ctrl+F3). В любой момент отладки программы эта команда показывает список процедур и функций, получивших управление на данный момент. Например, в теле основной программы команда Call Stack показывает пустой список. С помощью этой команды можно узнать также, каким путем программа дошла до выполнения этой процедуры или функции, не пользуясь командами Step Over и Trace Into.

1.3.6.3. Команда нахождения процедуры Find Procedure. Эта команда является удобным средством для нахождения любой процедуры или функции в тексте программы. Работает она (только после того, как программа откомпилирована) следующим образом: выбор этой команды вызывает появление на экране окна ввода, озаглавленного «Enter subprogram symbol» (введите имя подпрограммы). Если в этом окне набрать имя процедуры или функции, то редактор немедленно покажет на экране ее начало.

Очень удобно использовать команду Find Procedure для проведения корректировки программы во внешнем файле (подключаемой к основной программе директивой {$I Имяфайла} или находящейся в составе модуля). Необходимый файл тут же загружается в редактор, и Турбо Паскаль показывает начало процедуры.

1.3.6.4. Опция установки отладчика Integrated Debugging. Эта опция имеет два состояния — On и Off (по умолчанию — On). В этом случае доступны абсолютно все возможности встроенного отладчика: можно устанавливать точки останова и проходить программу по строкам. Переключение опции в состояние Off отключает отладчик.

1.3.6.5. Генерация кода для автономного отладчика Stand-Alone Debugging. Эта опция имеет два состояния — On и Off (по умолчанию — Off). Ее включают в состояние On в том случае, если нужно воспользоваться внешним отладчиком Turbo Debugger, разработанным фирмой Borland International. Эта опция имеет смысл только при компиляции на диск. При этом Турбо Паскаль включает всю необходимую информацию прямо в ЕХЕ-файл.

Turbo Debugger может понадобиться, если разрабатывается какой-нибудь большой пакет программ, который не в состоянии рабо-

- 40 -

тать под управлением системы разработки в силу дефицита памяти. Если проблемы, связанные с отладкой программ, позволяет решить встроенный отладчик Турбо Паскаля, эта опция может не понадобиться.

1.3.6.6. Опция режимов переключения экрана Display Swapping. Эта опция позволяет указывать среде программирования, как управлять во время отладки экраном, на котором отображается результат работы программы. Она имеет три состояния: None, Smart и Always. По умолчанию установлен Smart, т.е. Турбо Паскаль переключается на выходной экран только, когда необходимо выполнить оператор вывода на экран, а затем переключается обратно. Это очень удобно для большинства отладок. Если установлен режим Always, то система в любом случае переключает на короткое время экран после выполнения очередной строки. Если же установлен режим None, то выходной экран будет накладываться прямо на экран среды Турбо Паскаль. Это лучшее состояние опции, если программа не имеет вывода на экран. Если же все-таки вывод на экран есть, то картинка, представленная средой программирования, может быть разрушена. В связи с этим в пункт Debug включена еще одна команда.

1.3.6.7. Команда регенерации изображения Refresh Display. Эта команда восстанавливает экран среды программирования. Для исполнения этой команды набирается следующая последовательность клавиш: Alt+D и затем R. Другим способом правильное изображение восстановить невозможно.

 

1.3.7. Пункт Break/Watch (точки останова/обзор)

Этот пункт главного меню обеспечивает доступ к управлению двумя важнейшими возможностями отладчика: точками останова и просмотром переменных. На экране появляется меню (рис. 1.25).

Рис. 1.25

1.3.7.1. Добавление выражения Add Watch (Ctrl+F7). Эта команда используется для добавления новых имен переменных или выражений в окно Watch. На экране появляется окно Add Watch, в

- 41 -

которое нужно ввести имя переменной. Однако, если курсор редактора установить на нужное имя и дать команду Add Watch, то после нажатия клавиши ввода имя автоматически появится в этом окне. Затем нужно еще раз нажать клавишу ввода, после чего переменная появится в окне Watch.

Значение переменной постоянно отображается в окне Watch, и при использовании одного из пошаговых режимов отладки можно наблюдать за ее изменением непрерывно. Окно Watch может увеличиваться в высоту с каждым новым вводом до восьми строк. После этого можно листать это окно для просмотра переменных, находящихся за его пределами: для перехода из окна Edit в окно Watch нажимается клавиша F6. Затем, чтобы листать содержимое окна, используются клавиши управления курсором «вверх-вниз».

В это же время можно добавлять новые переменные и выражения в окно. Для этого нажимается клавиша Ins, и на экране появится окно Add Watch. Дальнейшие действия уже известны. Все сказанное о формате переменных в команде Evaluate относится и к окну Watch.

1.3.7.2. Удаление выражения из окна просмотра Delete Watch. Эта команда удаляет текущее выражение из окна Watch. Обычно текущим выражением является то, которое первым вводится в это окно. Оно маркировано точкой, расположенной перед выражением в окне.

Текущее выражение можно менять, перейдя в окно Watch и используя клавиши управления курсором для перемещения выделяющей строки по строкам. То выражение, на котором находится эта строка, и является текущим. Внутри окна Watch удаление выражений происходит после нажатия клавиши Del.

Удаление всех выражений одновременно из окна Watch производится выбором команды Remove all watches.

1.3.7.3. Редактирование выражения Edit Watch. Эта команда показывает текущее выражение Watch в окне Edit Watch. В нем можно редактировать выражение в любой момент. Нажав клавишу ввода можно «узаконить» это изменение, а нажав клавишу Esc отменить команду.

Внутри окна Watch эта команда вызывается следующим образом: выделяющая строка устанавливается на нужное выражение и нажимается клавиша ввода. Выделенное выражение появится в окне Edit Watch.

1.3.7.4. Включение и выключение точек останова Toggle Breakpoint (Ctrl+FS). Эта команда определяет текущую строку программы, находящейся в окне Edit, как точку останова, т.е. точку, в которой выполнение программы будет приостановлено. Чтобы пра-

- 42 -

вильно определить для системы точку останова, нужно установить курсор в строку, на которой выполнение программы должно приостановиться, затем нажать комбинацию клавиш Alt+D и T (или просто комбинацию клавиш Ctrl+F8). Турбо Паскаль при этом выделит эту строку ярким фоном (обычно красного цвета).

Эта же команда используется для исключения точки останова. Последовательность действий при этом такая же.

1.3.7.5. Выключение всех точек останова Clear All Breakpoints. Эта команда снимает все точки останова, установленные до этого.

1.3.7.6. Команда View Next Breakpoint. По этой команде редактор листает программу до следующей точки останова в тексте без ее выполнения. Если точка находится во внешнем файле, то Турбо Паскаль загружает этот файл в редактор так, чтобы в окне Edit появилась строка точки останова. После того как будет достигнута последняя точка, следующая команда View Next Breakpoint покажет в окне Edit первую точку останова.

 

1.4. Интерактивная справка

В интегрированной среде Турбо Паскаль встроена система краткой справки. С ее помощью можно вывести на экран краткое описание опций, которые появляются в меню. Чтобы получить пояснение к опции, достаточно установить выделяющий курсор в меню на нее и нажать клавишу F1. Турбо Паскаль автоматически открывает текстовое окно на экране, в котором содержится краткое описание выбранной опции. Например, на рисунке 1.26 показана справка по команде Run пункта Run главного меню.

Рис. 1.26

- 43 -

Если нажать комбинацию клавиш Ctrl+F1 при работе с редактором интегрированной среды, то справочная информация, соответствующая зарезервированному слову или специальному символу языка, на которое указывает курсор, будет показана на экране. Если соответствующая справочная информация отсутствует, то на экране появится меню справки по языку Турбо Паскаль. Это сокращает количество обращений к различного рода документации по среде Турбо Паскаль. Некоторые окна содержат выделенные слова, позволяющие получить более широкую информацию. Выбрав одно из таких слов (используя клавиши управления курсором) и нажав клавишу ввода, можно получить доступ к дополнительной информации.

Более того, если это описание процедуры или функции языка Турбо Паскаль, то будут показаны примеры их использования. Можно легко воспользоваться этими примерами, не набирая их в редакторе. При нажатии клавиши C активизируется курсор в окне справки. Подведя его к началу нужного фрагмента примера, следует нажать клавишу B. Таким образом, начинается выделение блока. После увеличения его до необходимых размеров курсором нужно нажать клавишу ввода, и фрагмент примера, находящийся в блоке, будет скопирован в текущую позицию курсора редактора. Эта уникальная возможность позволяет увидеть, как создатели языка Турбо Паскаль представляют правильное использование процедур и функций. Пользуйтесь этим!

Если, находясь в редакторе, нажать один раз клавишу F1, то можно получить достаточно полную информацию о его командах. Если же нажать еще раз клавишу F1, то в окне помощи появится вариант помощи, работающий как меню. Его пункты обобщают всю информацию, как о среде Турбо Паскаль и ее редакторе, так и о собственно языке Турбо Паскаль, а также процедурах и функциях, реализованных в его модулях. Эта информация довольно подробна: она занимает свыше 1000 страниц текста.

Среди всех достоинств этой справочной системы есть еще и такая: она помнит множество всех справочных окон, которые были вызваны и может их показывать в обратном порядке при нажатии комбинации клавиш Alt+F1.

Заметим, что в отличие от версии 5.0 в системе Турбо Паскаль версии 5.5 реализована автономная система интерактивной справки THELP. Это резидентная утилита, позволяющая писать программы на языке Турбо Паскаль в любом редакторе текстов. Активизация справочной системы производится нажатием клавиши 5 на цифровой клавиатуре ПЭВМ. Она предоставляет все возможности краткой

- 44 -

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

Таблица 1.3

При работе эта утилита занимает в ОЗУ 8,2К.

- 45 -

 

2.1. Система настройки среды программирования

В состав вспомогательных утилит Турбо Паскаля входит еще одна, о которой не упоминалось во введении, — это TINST.EXE. Ее задача — настройка всех элементов интегрированной среды: опции компилятора, размера экрана, команд редактора, распределения цветов в среде, рабочих директорий и т.д. Эта утилита изменяет информацию непосредственно внутри файла TURBO.EXE.

После запуска на выполнение этой утилиты на экране появится меню (рис. 2.1).

Рис. 2.1

Первые три пункта по своему действию и составу полностью совпадают с соответствующими пунктами основного меню интегрированной среды. Кратко рассмотрим отдельные опции остальных пунктов меню, которые могут повлиять на выполнение компиляции и редактирования. Сначала коротко о пунктах меню:

Editor Commands — устанавливает соответствие между комбинациями клавиш и выполняемыми действиями редактора;

Mode for display — настраивает видеорежимы интегрированной среды. Поскольку адаптер дисплея в ПЭВМ меняется реже, чем программное обеспечение, то если система уже работает на нем, изменять опции в этом меню не рекомендуется;

- 46 -

Set Colors — настраивает цвета на экране в наиболее подходящей гамме;

Resize windows — изменяет соотношение размеров окон Edit и Output /Watch;

Quit/Save — записывает все изменения, внесенные описываемой утилитой непосредственно в файл TURBO.EXE и заканчивает ее работу.

В пункте Option есть некоторые добавления, существенные с точки зрения использования памяти при работе интегрированной среды:

1. В пункте меню Environment, который устанавливает режимы сохранения файлов и конфигурации, добавлена опция Full Graphics Save. Если она находится в состоянии Off, то для работы системы освобождается 8K памяти, которые по умолчанию (On) используются как буфер для сохранения графического экрана. Значение опции Off оптимально, если не пользоваться графическими режимами адаптера дисплея.

2. Там же есть опция Editor Buffer Size, которая устанавливает размер буфера для редактора. По умолчанию его размер 64K, однако его можно уменьшать вплоть до 20000 байт. Таким образом, если планируется работать с небольшими текстами, можно «сэкономить» 45534 байт для компилятора. Примерный объем, занимаемый текстом программы, можно вычислить исходя из соображений, что полный экран монитора (в режиме 80х25) занимает 2000 байт, а степень его заполнения при написании программ на Паскале равна примерно 30%. Таким образом, программа длиной в 25 строк будет занимать примерно 700 байт.

3. Следующая опция Make use of EMS Memory (по умолчанию — On) задает редактору использование в качестве буфера блока 64К расширяемой памяти (стандарта EMS). При загрузке среда Турбо Паскаль проверяет наличие расширяемой памяти стандарта EMS и соответствующего драйвера в MS-DOS и, если они есть, организует в EMS-памяти буфер редактора. В противном случае этот буфер будет организован в основной памяти.

При помощи команды Editor Commands главного меню можно произвести перенастройку клавиш управления редактором. Однако авторам в процессе длительной работы с пакетом Турбо Паскаль воспользоваться ею так и не пришлось, так как эти клавиши в основном совпадают с комбинациями во многих известных редак-

- 47 -

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

Как и предыдущая, команда Set Colors дает полную свободу в выборе цветовой гаммы, в которой будет представлено рабочее поле интегрированной среды. Имеются четыре альтернативы:

— раздельное задание цвета для каждого определения среды фона экрана, цвета текста, цвета меню, цвета окон запросов и т.д. Рекомендуется использовать зеленые (Green) буквы на черном (Black) фоне для текста и коричневое поле для строки меню и подсказки. При длительной работе на ПЭВМ эти цвета наименее утомительны для зрения;

— выбор цветовой гаммы по умолчанию;

— выбор альтернативной цветовой гаммы по умолчанию;

— выбор гаммы, заданной по умолчанию для предыдущей версии. Это сделано, видимо, чтобы для пользователя, работавшего с предыдущими версиями, новая система была привычней.

 

2.2. Принятые в системе расширения имен файлов

Система Турбо Паскаль воспринимает все виды расширений в именах файлов, используемых в среде MS-DOS. Они обычно зависят от области применения или от вида программы. Турбо Паскаль по умолчанию использует несколько выделенных расширений для имен файлов:

TPU — файл модуля, содержащий подобие объектного кода модуля и (необязательно) отладочную информацию.

TPL — файл библиотек Турбо Паскаля. Стандартный набор модулей языка находится в файле TURBO.TPL. Этот файл можно модифицировать с помощью утилиты TPUMOVER.EXE (см. Приложение 4).

TP и CFG — файлы конфигурации для TURBO.EXE и TPC.EXE. Эти файлы позволяют сохранить значения различных опций, установленных для компиляторов. Файлы с расширением .TP могут иметь различные имена, но файл TPC.CFG (см. Приложение 3) в текущем каталоге может быть только один.

PCK — расширение файла истории работ Турбо Паскаля. Этот файл указателя содержит информацию о состоянии редактора, и поэтому после перерыва в сеансе работы с системой редактор восстановит свое последнее состояние.

- 48 -

PAS — стандартное расширение для файлов, содержащих исходный текст на Паскале.

BAK — расширение резервной копии исходного файла. Редактор интегрированной среды программирования всегда переименовывает существующий файл на диске в файл резервной копии, если на диск записывается измененная копия этого файла. Система позволяет установить или отменить генерацию файлов с расширением .BAK.

EXE — выполняемый файл, построенный компилятором.

MAP — расширение справочного файла, генерируемого системой, если опция Options/Compiler/Map File установлена в значение On.

HLP — файл с упакованными текстами для справочной системы (TURBO.HLP)

- 49 -

 

3.1. Алфавит языка и зарезервированные слова

Как и любой другой язык программирования, Турбо Паскаль имеет свой алфавит — набор символов, разрешенных к использованию и воспринимаемых компилятором. В алфавит языка входят:

1. Латинские строчные и прописные буквы:

A, B,..., Z и a, b,..., z

2. Цифры от 0 до 9.

3. Символ подчеркивания «_» (код ASCII номер 95). Из этих символов (и только из них!) конструируются идентификаторы — имена типов, переменных, констант, процедур, функций и модулей, а также меток переходов. Имя может состоять из любого числа перечисленных выше символов, но должно начинаться с буквы, например:

X CharVar My_Int_Var C_Dd16_32m

Прописные и строчные буквы не различаются: идентификаторы FILENAME и filename — это одно и тоже. Длина имен формально не ограничена, но различаются в них «лишь» первые 63 символа (остальные игнорируются).

4. Символ «пробел» (код 32). Пробел является разделителем в языке. Если между двумя буквами имени или ключевого слова стоит пробел, то две буквы будут считаться принадлежащими разным именам (словам). Пробелы отделяют

- 50 -

ключевые слова от имен. Количество пробелов не является значащим. Там, где можно поставить один пробел, можно поставить их сколько угодно. Например, выражения

C:=2+2; и C := 2 + 2 ;

для компилятора эквивалентны.

5. Символы с кодами ASCII от 0 до 31 (управляющие коды). Они могут участвовать в написании значений символьных и строчных констант. Некоторые из них (7, 10, 13, 8, 26) имеют специальный смысл при проведении ряда операций с ними. Символы, замыкающие строку (коды 13 и 10), и символ табуляции (код 9) также могут быть разделителями:

C := 2+2;

эквивалентно построению

C := 2

+

2;

6. Специальные символы, участвующие в построении конструкций языка:

+ - * / = < > [ ] . , ( ) : ;^ @ { } $ # '

7. Составные символы, воспринимаемые как один символ:

<= >= := (* *) (. .) ..

Разделители (пробелы) между элементами составных символов недопустимы.

Как видно, символы из расширенного кода ASCII, т.е. символы с номерами от 128 до 255 (а именно в этот диапазон входит алфавит кириллицы на IBM-совместимых ПЭВМ), а также некоторые другие из основного набора клавиатуры ( !, %, и др.) не входят в алфавит языка. Тем не менее они могут использоваться в тексте программы, но только в виде значений констант символов и (или) строк, а также в тексте комментариев. В имена (идентификаторы) эти символы входить не могут. Обычно это не вызывает проблем. Главное, что можно выводить знаки кириллицы и псевдографики на экран и принимать их с клавиатуры.

Турбо Паскаль имеет большое количество зарезервированных (или ключевых) слов. Эти слова не могут быть использованы в качестве имен (идентификаторов) в программе. Попытка нарушить

- 51 -

этот запрет вызовет ошибку при обработке программы компилятором языка. Список зарезервированных слов Турбо Паскаля таков:

Примечание: Зарезервированное слово PACKED (упакованный) в Турбо Паскале игнорируется.

 

3.2. Общая структура программ

Самая короткая программа на Турбо Паскале выглядит следующим образом:

| BEGIN

| END.

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

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

PROGRAM Имя ( input, output, ... )

здесь не является необходимой.

- 52 -

| PROGRAM Имя_программы;

| USES

| Список используемых библиотек (модулей);

| LABEL

| Список меток в основном блоке программы;

| CONST

| Определение констант программы;

| TYPE

| Описание типов;

| VAR

| Определене глобальных переменных программы;

| ОПРЕДЕЛЕНИЕ ПРОЦЕДУР (заголовки и, возможно, тела процедур);

| ОПРЕДЕЛЕНИЕ ФУНКЦИЙ (заголовки и, возможно, тела функций);

| BEGIN

| Основной блок программы

| END.

Рис. 3.1

Директива USES — первый в программе действительно работающий оператор. С ее помощью подключаются библиотечные модули, из стандартного набора Турбо Паскаля или написанные пользователем, расширяя тем самым список используемых в программе процедур, функций, переменных и констант. У директивы USES есть свое четкое место. Если она присутствует, то должна стоять перед прочими директивами и разделами. Кроме того, слово USES может появиться в программе только один раз. Список библиотек дается через запятую:

USES

CRT, DOS, Graph;

{ подключены три библиотеки с соответствующими именами }

Если библиотеки не используются, то директива USES не ставится.

Блок описания меток LABEL содержит перечисленные через запятую метки переходов, установленные в основном блоке программы. Блоков LABEL может быть сколько угодно (лишь бы метки не повторялись), и стоять они могут где угодно до начала основного блока. Метки могут обозначаться целым числом в диапазоне 0...9999 или символьными конструкциями длиной не более 63 букв, например:

- 53 -

LABEL

Loop, 1, 123, m1, m2, Stop;

{описываем шесть различных меток }

Если метки не используются, то блоки LABEL отсутствуют.

Блок объявления констант CONST так же, как блок LABEL может располагаться в любом месте программы. Таких блоков может быть несколько или может не быть вообще. В них размещаются определения констант различных видов.

Необязательный, как и все предыдущие, блок описания типов TYPE содержит определения вводимых программистом новых типов, в том числе для описания типов «объект». В этом блоке могут быть использованы константы из блока CONST. Если это так, то блок TYPE может быть расположен где угодно, но не выше соответствующего блока CONST. Если же описания типов ни с чем не связаны, то они могут быть помещены в любом месте между другими блоками, но выше того места, где будут использованы.

Раздел описания глобальных переменных VAR формально тоже не обязателен и может отсутствовать. Реально же он, конечно, объявляется и содержит список глобальных переменных программы и их типы. Блоков VAR может быть несколько, но переменные в них не должны повторяться.

Если в программе описываются процедуры и (или) функции, то их определение должно предшествовать основному блоку. В любом случае должны быть описаны заголовки процедур и функций. Обычно заголовком сразу следует реализация (тело) процедуры (функции), но они могут быть и разнесены внутри программы. Если процедура или функция объявляется как внешняя, то ее тело вообще будет отсутствовать в тексте на Паскале. Библиотечные процедуры и функции, подсоединяемые директивой USES, не описываются в тексте, а только используются.

Основной блок — это собственно программа, использующая все, что было описано и объявлено. Он обязательно начинается словом BEGIN и заканчивается END с точкой. После основного блока, вернее после завершающей его точки, любой текст игнорируется. Поэтому основной блок всегда замыкает программу.

Язык Турбо Паскаль предоставляет гораздо большую гибкость в организации текста программы, чем стандарт языка: структура программы на рис. 3.2 более читаема и удобна, чем жесткая последовательность блоков на рис. 3.1.

Существуют, однако, ограничения на перемещения блоков в программе. Программа компилируется последовательно, и все что в

- 54 -

| PROGRAM Сложная_программа;

| USES

| Подключаемые библиотеки (модули);

| CONST Константы и переменные для

| VAR выполнения математических расчетов

| Определения процедур и функций

| математических расчетов

| CONST Константы, типы и переменные,

| TYPE нужные для графического представления

| VAR результатов расчетов

| Определения процедур и функций

| построения графиков

| LABEL Метки, константы и переменные,

| CONST используемые только в основном

| VAR блоке программы

| BEGIN

| Основной блок программы

| END.

Рис. 3.2

ней вводится, должно быть объявлено, до того как будет использовано. Так, переменные из самого нижнего блока VAR (см. рис. 3.2) будут недоступны в определяемых выше процедурах. Попытка использовать их в процедурах вызовет ошибку и остановку компиляции. Исправить такую ошибку просто: надо перенести нужные переменные в блок VAR перед процедурами.

Компилятор Турбо Паскаля накладывает некоторые ограничения на текст программ. Так, длина строки не может превысить 126 символов, а объем файла программы (текста) — 64K (максимально).

 

3.3. Комментарии и ключи компиляции

Кроме конструкций языка, программа может содержать комментарии и ключи компиляции. Комментарии — это произвольный текст в любом месте программы, заключенный в фигурные скобки:

{ текст комментария }

или в круглые скобки со знаком умножения (звездочкой):

(* текст комментария *)

- 55 -

между скобками и звездочкой не должно быть пробелов. Комментарии не могут пересекать друг друга:

{ пример пересечения (* комментариев } — так нельзя *),

но могут быть вложенными. При этом внешний и внутренний комментарии должны быть заключены в разные скобки:

(* внешний охватывает { внутренний } комментарий *)

Длина комментария не ограничивается одной строкой. Можно, например, закомментировать целый кусок текста:

{

много

строк

комментариев

}

Турбо Паскаль позволяет программе (тексту) управлять режимом компиляции: включать или выключать контроль ошибок, использовать или эмулировать математический сопроцессор, изменять распределение памяти и др. Для изменения режима используются ключи компиляции: специальные комментарии, содержащие символ «$» и букву-ключ с последующим знаком «+» (включить режим) или «-» (выключить). Например:

{$R-} отключить проверку диапазонов индексов массивов;

{$N+} использовать сопроцессор 80Х87 и т.д.

Список ключей компиляции приведен в Приложении 2. Можно объединять ключи в один комментарий:

{$N+,R-}

Открывающие скобки, символ «$» и ключ должны быть написаны без пробелов между ними. Подобные конструкции можно вставлять в программу, и при компиляции она сама будет задавать режим работы компилятора. Ключи подразделяются на глобальные (раз установленный режим уже не может измениться) или локальные (можно изменять режимы для разных частей программы). Глобальные ключи должны стоять в начале программы, а локальные — где угодно программисту. Стартовые значения ключей (значения по умолчанию) задаются в среде программирования посредством меню Options/Compiler.

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

{$I ИмяФайлаВключения}

- 56 -

называемый командой включения в программу внешнего текстового файла. Обратите внимание на отсутствие знаков «+» или «-». Вместо них стоит пробел и имя файла. Эта команда заставляет компилятор считать заданный внешний файл частью обрабатываемой программы, т.е. отлаженные законченные блоки текста могут быть записаны на диск и заменены в программе на команды их включения. Это немного замедляет процесс компиляции, но может сэкономить массу места в программе, так как последняя превращается в «цепочку» различных файлов на диске. Примеры задания включения файлов-блоков:

{$I incproc.pas}, или, что то же самое,

{$I incproc},

{$I c:\pascal\pas\graf.inc},

{$I ..\USER\Block1.blk}

Текст включаемого блока должен удовлетворять двум условиям: будучи подставленным на место соответствующей команды {$I...}, он обязан вписаться в структуру и смысл программы без ошибок и должен содержать законченный смысловой фрагмент. Последнее означает, что блок от BEGIN до END (например, тело процедуры) должен храниться целиком в одном файле.

Включаемые тексты сами могут содержать команды {$I...}, вставляющие как бы уже дважды вложенные тексты, а те, в свою очередь, тоже могут содержать директивы {$I...}. Максимальный уровень подобной вложенности равен восьми.

Кроме текстов, можно включать коды в формате OBJ, полученные другими компиляторами или утилитами. Включаемые коды, конечно, не компилируются, но подключаются к выполнимому коду программы на этапе компоновки. В них должны содержаться реализации внешних процедур и (или) функций. Включение происходит почти так же, как и для текстовых блоков:

{$L code.obj}

или, что то же самое,

{$L code} {$L c:\pascal\obj\grafproc.obj}

Обычно после директивы {$L...} в тексте программы сразу ставятся описания внешних процедур и функций, реализованных в подключенном коде.

К той же серии компонующих структуру программы ключей можно отнести команду объявления оверлейных (перекрывающихся) наборов процедур и функций:

- 57 -

{$O ИмяОверлейногоМодуляНаДиске}

Подробную информацию об оверлейных структурах смотрите в гл. 18 «Модуль Overlay».

 

3.4. Условная компиляция программ

Принципы условной компиляции тесно связаны с построением программ на Турбо Паскале. Разрешая группировать блоки VAR, TYPE и прочие по функциональным признакам и размещать их в различных местах программы, Турбо Паскаль предоставляет еще и средства управления порядком компиляции (не путать с режимами!). Любой, кто отлаживал свои программы, знает, как исключить из работы фрагмент текста: надо оформить его как комментарий или обойти оператором перехода типа GOTO. Но все это нарушает исходный текст. Турбо Паскаль вводит особый набор ключей компиляции для решения подобных вопросов. Их немного:

{$DEFINE КлючевоеСлово } задание ключевого слова,

{$UNDEF КлючевоеСлово } сброс ключевого слова,

{$IFDEF КлючевоеСлово } проверка задания слова,

{$IFNDEF КлючевоеСлово } проверка отсутствия задания ключевого слова,

{$IFOPT КлючИзнак } проверка режима компиляции,

{$ELSE) альтернативная ветвь,

{$ENDIF) обязательный конец условия.

Ключ $DEFINE определяет (задает) условное ключевое слово, которое становится активным и известным компилятору и по которому будут срабатывать другие ключи: $IFDEF — проверка условия активности этого слова и $IFNDEF — проверка отсутствия его задания (рис. 3.3).

| { $DEFINE variant0 }

| BEGIN

| {$IFDEF variant0 }

| WriteLn ( 'Вариант программы номер 0' );

| {$ENDIF)

| {$IFNDEF variant0 }

| WriteLn ( 'Ненулевая версия программы' );

| {$ENDIF}

| END.

Рис. 3.3

- 58 -

Если в тексте программы определено ключевое слово (здесь variant0), то будет откомпилирован блок, зависящий от активности этого слова, т.е. заключенный между ключами {$IFDEF variant0} и {$ENDIF}. Альтернативный вариант блока будет компилироваться только, когда ключевое слово variant0 неопределено (пассивно). На это указывают обрамляющие его ключи {$IFNDEF variant0}...{$ENDIF}. Но если, например, изменить в тексте ключа $DEFINE слово variant0 на variant1 и заново откомпилировать программу, то все получится наоборот: будет пропущен первый блок (его слово не определено), но откомпилирован второй (условие отсутствия слова выполняется).

Можно заметить, что обязательная директива {$ENDIF} всегда замыкает блок, начатый ключом {$IF...}. Пример на рис. 3.3 можно без ущерба для смысла переписать в ином виде (рис. 3.4).

| { SDEFINE variant0}

| BEGIN

| {$IFDEF variant0 }

| WriteLn ( 'Вариант программы номер 0');

| {$ ELSE }

| WriteLn ('Ненулевая версия программы');

| {$ENDIF}

| END.

Рис. 3.4

Здесь задействован ключ {$ELSE}, направляющий ход компиляции в альтернативное русло, если не выполняется условие предшествующего ключа {$IF...}. Для такого сложного условия ключ конца все равно будет один.

Блоки, компилируемые условно, могут содержать любое число операторов. Части программы, находящиеся вне блоков условной компиляции {$IF...}...{$ENDIF}, никак не зависят от ключевых слов. Само ключевое слово может содержать сколько угодно символов (только латинских и цифр), хотя распознаются только первые 63 из них. Ключевые слова имеют смысл только в ключах-командах условной компиляции и никак не перекликаются с идентификаторами самой программы.

Однажды объявленное ключевое слово можно отменить по ходу процесса компиляции (перевести из активного состояния в пассивное) ключом

- 59 -

{$UNDEF КлючевоеСлово}

После такой строки в тексте слово считается не заданным.

До сих пор речь шла о вводимых программистом ключевых словах. Кроме них, всегда определены три слова:

VER55 — ключевое слово версии компилятора (языка); для версий 5.0 и 4.0 оно было другим — VER50 и VER40 соответственно;

MSDOS — ключевое слово типа ОС; в MS-DOS, PC-DOS или их аналогах это слово именно такое;

CPU86 — ключевое слово семейства центрального процессора; если он не из семейства 80X86, то это слово будет другим.

К этому списку слов может быть добавлено еще одно, если компилятор обнаружил наличие математического сопроцессора 80X87:

CPU87 — ключевое слово, определенное, если в ПЭВМ имеется математический сопроцессор.

Ключевое слово сопроцессора позволяет установить порядок компиляции в зависимости от комплектации ПЭВМ:

{$IFDEF CPU87 -

{$N+ включаем режим использования сопроцессора }

TYPE

объявляем типы с повышенной точностью;

{$ELSE}

{$N- не используем возможности сопроцессора }

TYPE

объявляем типы с обычной точностью:

{$ENDIF}

В списке ключей условной компиляции был еще один ключ {$IFOPT}. Принцип его работы такой же, как и ключа {$IFDEF}. Отличие состоит лишь в условии срабатывания. Здесь им является состояние какого-либо ключа режима компиляции. Например, если программа компилируется в режиме {$N+}, заданном в тексте или умолчанием, то условие {$IFOPT N+} — истинно, a {$IFOPT N-} — ложно.

Теперь есть возможность управлять ходом компиляции, опираясь на состояние различных режимов. Ключ {$IFOPT} может иметь альтернативную ветвь {$ELSE} и по-прежнему обязан иметь закрывающую блок условной компиляции директиву {$ENDIF}.

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

- 60 -

 

4.1. Простые типы языка

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

 

4.1.1. Целочисленные типы

Обилие целочисленных типов позволяет эффективно использовать память ПЭВМ и более гибко вводить целочисленные переменные в программу. Целочисленные типы отличаются размером при хранении в памяти (Byte и ShortInt — 1 байт, Word и Integer — 2 байта, LongInt — 4 байта) и способом кодировки значений (с представлением знака или без него). Типы без знака переводят допустимый диапазон значений целиком в неотрицательную область.

Целочисленные значения записываются в программе привычным способом:

123 4 -5 -63333 +10000

Число должно быть записано без всяких преобразований. Будет ошибкой задать целое число следующим образом:

1Е+2 (в смысле 100), или 123.0

Знак «+» перед числом может опускаться. Турбо Паскаль разрешает записывать целые значения в шестнадцатеричном формате, используя префикс $:

$FF $9 $FFFFAB0D

Регистр букв A, B, ..., F значения не имеет. Разрешается непосредственно приписывать знак числа, если значения (со знаком или без) не превышают допустимый для данного типа диапазон: от -$80 до +$7F для типа ShortInt, и от -$8000 до +$7FFF для типа Integer. Отрицательные значения для переменных типа LongInt могут быть записаны аналогичным способом. Но здесь есть особенность. Для этого типа отрицательные значения могут записываться и как целые величины без знака. При этом запись отрицательных значений в

- 63 -

шестнадцатеричном формате должна соответствовать обратному отсчету от максимального для размера LongInt положительного числа. Например, число $FFFFFFFF (условное максимальное положительное значение, размещающееся в четырех байтах) трактуется как значение типа LongInt, равное -1. Число $FFFFFFFE (это $FFFFFFFF-l) будет соответствовать уже -2 и т.д. Следуя этой схеме, значение, например -65, в шестнадцатеричном формате для типа LongInt вычислится так: от числа $FFFFFFFF, соответствующего значению -1, нужно «вычесть» еще 64:

$FFFFFFFF - 64 = $FFFFFFFF - $40 = $FFFFFFBF.

Мы специально рассмотрели запись отрицательных чисел в шестнадцатеричном формате, потому что встроенный отладчик Турбо Паскаля при выводе отрицательных целых значений в формате H приводит их к длине LongInt и выводит в обратном отсчете. Здесь необходимо сделать небольшое техническое замечание. Целые значения типов Word, Integer и LongInt хранятся в памяти в «перевернутом» виде: первым идет наименее значащий байт, а последним — наиболее значащий. Так, если мы запишем в переменную W типа Word значение $0102, то оно будет храниться как два байта $02 и $01. Аналогично, если переменной L типа LongInt присвоить значение $01020304, то оно расположится в памяти как четыре байта : $04, $03, $02, $01. Эта машинная «кухня» не важна при работе с переменными — они позволяют вообще не знать механизмов хранения данных. Но при прямом доступе в память или преобразовании данных (что разрешается языком Турбо Паскаль) эти технические подробности становятся необходимыми.

 

4.1.2. Вещественные числа

Вещественные значения (значения типа Real) могут записываться несколькими способами:

 

-1.456	0.00239	-120.00	.09
66777	0	-10	+123
123E+2	-1.4E-19	5E4	0.1234E+31

Как видно, они могут быть представлены: обычным способом с десятичной точкой; как целые, если дробная часть равна 0; в экспоненциальном формате. Экспоненциальный формат соответствует умножению на заданную степень 10. Так,

-1.4E-19 = -1.4 * (10 в степени -19).

Написание буквы E может быть как прописным, так и строчным. Без

- 64 -

использования типов повышенной точности, работающих с математическим сопроцессором 80Х87, степень может иметь не более двух цифр (в диапазоне (-38) ... (+38)), но при использования этих типов — уже до четырех цифр:

1.23456789+0120

Знак числа + может опускаться, в том числе и в экспоненте. В вещественную переменную можно записать шестнадцатеричную константу. При этом она преобразуется в вещественную форму.

 

4.1.3. Логический тип

Логический тип Boolean состоит из двух значений: False (ложно) и True (истинно). Слова False и True определены в языке и являются, по сути, логическими константами. Регистр букв в их написании несущественен: FALSE = false. Значения этого типа участвуют во всевозможных условных операторах языка. С логическим типом связан ряд операций языка, реализующий Булеву алгебру (логические НЕ, И, ИЛИ и др.)

 

4.1.4. Символьный тип

Символьный тип Char — это тип данных, состоящих из одного символа (знака, буквы, кода). Традиционная запись символьного значения представляет собой собственно символ, заключенных в одиночные кавычки: 'ж', 'z' '.' ' ' (пробел) и т.п. В Турбо Паскале имеются альтернативные способы представления символов. Все они будут рассмотрены в гл. 8 «Обработка символов и строк». Значением типа Char может быть любой символ из набора ASCII — однако на каждый из них можно «написать» на клавиатуре.

 

4.1.5. Строковый тип

Очень важным и полезным является тип динамических строк String. (здесь «динамические» означает переменной длины). Можно задать, например, тип String[126] — и переменные такого типа смогут иметь в себе строки длиной от 0 до 126 символов. В Турбо Паскале строки — это больше, чем просто массив символов. К ним прилагается библиотека средств, позволяющих делать со строками буквально все, что угодно. Значения типа «строка» в простейшем случае записываются как обычные текстовые строчки, заключенные в одиночные кавычки:

- 65 -

'строчка '

'строка из цифр 12345'

'В кавычках может стоять любой символ, кроме кода 13'

's'

'' (пустая строка)

'Это - '' - одиночная кавычка в строке'

 

4.1.6. Адресный тип

Язык Турбо Паскаль объявляет специальный адресный тип — Pointer. Значением этого типа является адрес ячейки памяти, представленный по правилом MS-DOS. Тип Pointer — сугубо внутренний. Его значения нельзя вывести на печати или записать в переменную, как мы записываем числовые значения. Вместо этого всегда приходится использовать специальные функции для преобразования условной общепринятой записи адресов памяти в формат типа Pointer и наоборот.

Мы рассмотрели типы, вводимые языком. Кроме них, есть категории типов данных, вводимых программистом, которые мы далее рассмотрим подробно. К ним относятся в первую очередь перечислимые типы.

 

4.1.7. Перечислимые типы

Перечислимый тип — это такой тип данных, при котором количество всех возможных значений ограничено (конечно). Например, тип Word соответствует этому определению. В нем 65536 значений — от 0 до 65535. И уж точно перечислимыми являются типы: Byte — 256 значений от 0 до 255 и Char — в нем 256 символов с кодами от 0 до 255. Можно перечислить и все значения типов ShortInt, Integer и даже LongInt. Только перечисление начнется не с нуля, а с отрицательного целого значения.

Есть и еще один предопределенный перечислимый тип — Boolean. У него всего два значения — False и True. Принято, что номер False внутри языка равен 0, а номер True равен 1. Перечислимый тип можно расписать в ряд по значениям. Тип Char можно было расписать в синтаксисе Паскаля как

TYPE

Char = ( симв0, симв1..., симв64, 'A', 'B', 'C', ...симв255);

тип Byte выглядел бы так:

Byte = (0, 1, 2,...,254, 255);

- 66 -

а логический тип — как

Boolean = ( False, True );

Но такие определения проделаны еще во время написания самого компилятора языка, осталось только пользоваться ими. Зато мы можем вводить новые перечислимые типы, придумывая им имена и перечисляя через запятую в круглых скобках названия элементов-значений этого типа:

| TYPE

| Personages = ( NifNif, NufNuf, NafNaf );

| Test = ( Level0, Level1, Level2, Level4, Level5);

| MusicCard = ( IBM, Yamaha, ATARI, other, None);

| Boolean3 = (false_, Nolnfo_, true_);

Значения в скобках — это значения новых типов. Можно теперь объявлять переменные этих типов, а их значениями можно индексировать массивы или организовывать по ним циклы. Но всегда переменная такого типа сможет содержать только те значения, которые указаны в его перечислении.

Перечислимые данные (их можно называть атомами) должны иметь синтаксис идентификаторов, и поэтому не могут перечисляться цифры, символы, строки.

Идентификаторы не могут повторяться в одной программе. Заметьте, как введен тип Boolean3 для моделирования трехзначной логики: чтобы избежать использования уже задействованных имен True и False, они чуть-чуть видоизменены. Регистр написания идентификаторов по-прежнему не играет роли. Максимальное число элементов в одном вводимом перечислении равно 65535.

Применение вводимых перечислимых типов имеет ряд преимуществ:

1) улучшается смысловая читаемость программы;

2) более четко проводится контроль значений;

3) перечислимые типы имеют очень компактное машинное представление.

Недостатком применения перечислимых типов является то, что значения из перечислимого типа (атомы) не могут быть выведены на экран или принтер и не могут быть явно введены с клавиатуры. Бороться с этим недостатком можно, но посредством не очень красивых приемов. Обычно, чтобы все-таки иметь возможность вывода на экран, вводят массивы, проиндексированные атомами. Каждый их элемент есть строковое написание соответствующего атома (например, для атома NoInfo_ — строка 'Nolnfo_').

- 67 -

Для работы с перечислимыми типами в Турбо Паскале используются общепринятые функции Ord, Pred и Succ. Рассмотрим их действие.

Любой перечислимый тип имеет внутреннюю нумерацию. Первый элемент всегда имеет номер 0; второй — номер 1 и т.д. Порядок нумерации соответствует порядку перечисления. Номер каждого элемента можно получить функцией Ord(X) : LongInt, возвращающей целое число в формате длинного целого, где X — значение перечислимого типа или содержащая его переменная. Так, для введенного выше типа Test:

Ord(Level0) даст 0,

Ord(Level1) даст 1,

...

Ord(Level5) даст 5.

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

Ord(0) = 0

Ord(-100) =-100

но для значений Char она вернет их код:

Ord('0') = 48,

Ord(' ') = 32,

Ord('Б') = 129.

Для логических значений

Ord(False) = 0 и Ord( True ) = 1.

Обратной функции для извлечения значения по его порядковому номеру в языке нет, хотя выражение вида

X : = ИмяПеречислимогоТипа(ПорядковыйНомер)

запишет в X значение, соответствующее заданному порядковому номеру элемента перечисления. Кроме этого, имеются две функции последовательного перебора значений перечислимого типа:

Succ(X) — возвращает следующее за X значение в перечислимом типе;

Pred(X) — возвращает предыдущее значение в перечислимом типе.

Так, для нашего типа Boolеаn3

Succ(false_) = noinfo_ = Pred( true_).

Функции Succ и Pred применимы и к значениям целочисленных типов:

- 68 -

Succ(15) = 16, Succ(-15) = -14,

Pred(15) = 14, Pred(-15) = -16.

и очень эффективно работают в выражениях вида (N-1)*N*(N+1), которые могут быть переписаны как Pred(N)*N*Succ(N).

Не определены (запрещены) значения:

Succ(последний элемент перечисления)

и

Pred(первый элемент перечисления).

Поскольку перечислимые значения упорядочены, их можно сравнивать. Из двух значений большим является то, у которого больше порядковый номер (но это сравнение должно быть в пределах одного и того же типа!), т.е. выполняется:

True > False

в типе Boolean,

NoInfo_ < true_

в типе Boolean3,

'z' > 'a'

в типе Char.

Знаки сравнения могут быть и нестрогими.

 

4.1.8. Ограниченные типы (диапазоны)

Еще одним вводимым типом языка является диапазон. Используя его, мы можем определить тип, который будет содержать значения только из ограниченного поддиапазона некоего базового типа. Базовым типом, из которого вычленяются диапазоны, может быть любой целочисленный тип, тип Char и любой из введенных программистом перечислимых типов.

Для введения нового типа — диапазона — надо в блоке описания типов TYPE указать имя этого типа и границы диапазона через две точки подряд:

| TYPE

| Century = 1..20; { диапазон целочисленного типа }

| CapsLetters = 'А'..'Я'; { заглавные буквы из типа Char }

| TestOK = Level3..Level5; { часть перечислимого типа Test }

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

- 69 -

Это еще больше усиливает контроль данных при выполнении программы. Значения переменных типа «диапазон» могут выводиться на экран и вводиться с клавиатуры, только если этот диапазон взят из базового типа, выводимого на экран или вводимого с клавиатуры. В приведенном примере сугубо «внутренними» значениями будут только значения, принадлежащие к типу TestOK, как диапазону невыводимого перечислимого типа Test. Будет ошибкой задать нижнее значение диапазона большим, чем верхнее.

При конструировании диапазона в описании типа можно использовать несложные арифметические выражения для вычисления границ. Но при этом надо следить, чтобы запись выражения не начиналась со скобки (скобка — это признак начала перечисления):

| TYPE

| IntervalNo = (2*3+2)*2 .. (5+123); {неверно! }

| IntervalYes = 2*(2*3+2) .. (5+123); { правильно }

 

4.2. Сложные типы языка

Среди сложных типов первым традиционно рассматривается массив — упорядоченная структура однотипных данных, хранящая их последовательно. Массив обязательно имеет размеры, определяющие, сколько элементов хранится в структуре. До любого элемента в массиве можно добраться по его индексу.

Тип «массив» определяется конструкцией

Array [диапазон] of ТипЭлементов;

Диапазон в квадратных скобках указывает значения индексов первого и последнего элемента в структуре. Примеры объявления типов:

| TYPE

| Array01to10 = Array[ 1..10] of Real;

| Array11to20 = Array [11..20] of Real;

Здесь мы вводим два типа. Они совершенно одинаковы по структуре, но по-разному нумеруют свои элементы. Оба типа содержат наборы из десяти значений типа Real.

Пусть определены переменные именно таких типов (скажем, a01to10 и a11to20). Доступ к i-му элементу массивов осуществляется через запись индекса в квадратных скобках сразу за именем массива: a01to10[i] или a11to20[i].

Возможно объявление таких конструкций, как массив массивов (это будет, по сути, матрица) или других структур. Подробнее массивы будут рассмотрены в разд. 7.1 «Массивы (Array) и работа с ними».

- 70 -

Другим сложным типом является множество, конструируемое специальной фразой

Set of БазовыйПеречислимыйТип.

Данные типа «множество» — это наборы значений некоего базового перечислимого типа, перечисленные через запятую в квадратных скобках. Так, если базовым считать введенный ранее перечислимый тип Test, то значение типа

Set of Test

может содержать произвольные выборки значений типа Test:

[Level0]

[Level3, Leve4]

[Level1..Level5],

и т.п., а также

[] — пустое множество.

Множество отличается от массива тем, что не надо заранее указывать количество элементов в нем, используя индексацию. Множество может расширяться или сокращаться по ходу программы. В Паскале определены операции над множествами, аналогичные математическим: объединение множеств, поиск пересечения их (взятие разности множеств), выявление подмножеств и др. Излишне говорить, что такой тип данных существенно расширяет гибкость языка. Подробно множества описываются в разд. 7.3 «Тип «множество» (Set). Операции с множествами».

Файловый тип — это «окно в мир» для программы на Турбо Паскале. Именно с помощью файловой системы осуществляется весь ввод и вывод информации программой. Этим вопросам в книге посвящена гл. 12, здесь же ограничимся общим определением файла. Файл (любого типа) — это последовательность данных, расположенных вне рабочей памяти программы (на магнитном диске, на экране, на принтере, в другом компьютере в сети ПЭВМ или где-нибудь еще). Некоторые файлы могут только выдавать информацию (например, клавиатура). Другие файлы могут только принимать ее, например, устройство печати. Напечатанный принтером лист — это зримый образ выведенного программой файла. Третьи файлы позволяют и считывать из себя информацию, и записывать ее. Примером является обычный файл на диске. Определяя файлы в программе, мы можем через них общаться с периферией ПЭВМ, и в том числе накапливать данные и впоследствии обращаться к ним.

- 71 -

Файловые типы Турбо Паскаля (Text, File of... и File) различаются только типами данных, содержащихся в конкретных файлах программы. Задавая в программе структуры данных типа «файл», мы определяем тип этих данных, но не оговариваем их количество в файле. Теоретически файл может быть бесконечной последовательностью данных; практически же на все случаи жизни в ПЭВМ найдутся ограничения, в том числе и на длину файла.

Следующий сложный тип языка — записи. Для тех, кто не знаком с языком Паскаль, это слово поначалу ассоциируется не с тем, что оно на самом деле обозначает. Да, запись может быть записью на диске. Но в исходном значении — это структура данных, аналогичная таблице. У обычной таблицы есть имя, и у каждого ее поля тоже есть имя. Похожим образом в типе данных «запись» указываются названия полей и тем самым вводятся в работу табличные структуры данных. Мы можем, например, ввести тип данных, аналогичный анкете (т.е. той же таблице):

| TYPE

| PERSON=RECORD

| F_I_O_ : String; { фамилия, имя, отчество}

| Ves.Rost : Real; { вес и рост}

| Telephone : Longint { номер телефона}

| END;

В этом определении слово RECORD открывает набор имен полей таблицы-анкеты и типов значений в этих полях, a END — закрывает его, т.е. пара RECORD...END конструирует тип «запись». Тип PERSON теперь задает таблицу из строки (F_I_O_), двух чисел с дробной частью (Ves, Rost) и одного целого числа. Все они называются полями записи типа Person. Далее мы можем ввести в программе переменную Nekto типа Person, и под именем Nekto будет пониматься анкета-таблица с конкретными значениями. Доступ к полям таблицы производится дописыванием к имени всей таблицы имени нужного поля. Имя переменной-записи (оно же имя таблицы) и имя поля разделяются точкой:

Nekto.F_I_O_ — значение строки с фамилией, именем, отчеством;

Nekto.Ves — значение поля Ves.

Полями записей может быть что угодно, даже другие записи. Количество полей может быть велико. Записи частично схожи с массивами: они тоже хранят определяемое заранее количество данных. Но в отличие от массивов и множеств компоненты записи могут иметь разные типы, и доступ к ним происходит не по индексу, а по имени. Записи позволяют существенно упростить обработку слож-

- 72 -

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

Очередной тип, который мы рассмотрим — это объекты. Объект (object) — это принципиально новый тип, вводимый Турбо Паскалем, начиная с версии 5.5 языка. Но это не только новый тип. Это новый подход к программированию. Что такое объект? Представьте себе, что мы сгруппировали некие данные в запись. Это удобно, ибо разнотипные значения теперь хранятся «под одной крышей». В программе эти данные обрабатываются какими-либо методами. Очень часто бывает, что эти методы годны только для обработки полей нашей записи и не работают с другими данными. Но раз так, то не будет ли рациональнее внести методы в список полей самой записи? Как только мы это проделаем, получим новый тип данных — объект.

В программе объекты описываются почти так же, как записи:

TYPE

DataWithMethods = OBJECT

Поле данных 1: его Тип;

Поле данных 2: его Тип;

...

Метод 1;

Метод 2;

Метод 3;

...

END;

Список полей и методов должен начинаться словом OBJECT и заканчиваться END (все об объектах читайте в гл. 13 «Объектно-ориентированное программирование»).

Таким образом, объект — это замкнутый мир данных и средств их обработки. Методы, реализуемые как процедуры и функции, имеют смысл и могут применяться только к полям данных этого же объекта. В то же время объекты привносят новые подходы к построению программ. Вводится такое понятие, как наследование признаков объектов. Это значит, что можно построить ряд все более и более сложных объектов, каждый из которых наследует свойства (данные и методы их обработки) предшественника и является его развитием. А объявив в программе такой ряд объектов, можно будет построить процедуры, которые смогут работать (запускать методы) с любым объектом этого ряда. (Возможность использовать одну процедуру для целого ряда взаимосвязанных через наследование объектов называется полиморфизмом.)

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

- 73 -

использовать другой подход к написанию программ — объектно-ориентированный. И если в первом случае стоит задача разделить алгоритм решения на отдельные процедуры и функции, то во втором — представить задачу как совокупность взаимодействующих объектов, выстраивая при этом ряды объектов — от низшего уровня данных к более высоким — согласно принципу наследования. И если вдруг изменится нижний уровень представления объекта, то достаточно будет изменить только его: все изменения автоматически передадутся по цепочке наследования. Если же, наоборот, понадобится еще больше усложнить объект, то достаточно будет просто продолжить ряд наследования. А процедуры (по свойству полиморфизма) останутся теми же.

Последним среди сложных типов Турбо Паскаля является ссылочный тип. В разд. 4.1.6 рассматривался тип Pointer — адресный тип. Его значения — это указатели на какую-либо ячейку рабочей памяти ПЭВМ. Причем не оговаривается, какое значение и какого типа в этой ячейке может содержаться — оно может быть каким угодно. Но известно, что структуры данных, занимающие более одной ячейки памяти, располагаются последовательно: в виде сплошной цепочки значений. Поэтому, чтобы просто адрес можно было назвать адресом какой-либо структуры данных, надо, кроме адреса первой ячейки структуры, знать еще ее тип и размер. Ссылочный тип — это тот же адресный тип, но «знающий» размер и структуру того куска памяти, на который будет организован указатель. Такие «знающие» указатели называются ссылками. Чтобы описать ссылочный тип, мы должны указать имя базового типа, т.е. тип той структуры (а именно он определяет размер и расположение данных), на которую будет указывать ссылка, и поставить перед ним знак «^», например:

| TYPE

| Dim100 = Array[1..100] of Integer; { просто массив }

| Dim100SS = ^Dim100; { ссылка на структуру типа Dim100 }

Значения типа Dim100SS (ссылки на массив) будут содержать адрес начала массива в памяти. А так как ссылка (пусть она имеет имя SS) «знает», на что она указывает, можно через нее обращаться к элементам массива. Для этого снова используется знак «^», но ставится он уже после имени переменной:

SS^ — массив типа Dim100,

SS^[2] — второй элемент массива SS^, но

SS — адрес массива в памяти.

- 74 -

Узнав все это, изучающие Паскаль обычно спрашивают, зачем столько сложностей. Есть ведь обычные массивы, и можно с ними работать, не вводя промежуточные ссылочные типы. Конечно, можно. Но использование ссылочного типа дает нам уникальную возможность располагать данные там, где мы хотим, а не там, где им предпишет компилятор. Турбо Паскаль вводит специальный набор средств для организации структур данных по ходу выполнения программы. Используя его совместно со ссылками, мы можем явно указать, где будет размещена структура данных, можем разместить ее в свободной от программы памяти ПЭВМ и впоследствии удалить оттуда. Все это позволяет очень гибко использовать отнюдь не безграничные ресурсы памяти ПЭВМ.

Такова вкратце система сложных типов Турбо Паскаля. Она достаточно развита, чтобы решать большинство практических задач. На ее основе всегда можно сконструировать структуры данных «недостающих» типов, например списки, двоичные деревья и многое другое.

- 75 -

 

5.1. Простые константы

Раздел описания констант CONST программы позволяет вводить различного вида константы. Константы — это не более чем средство для сокращения рутинных действии над текстом программы и одновременно улучшения ее читаемости. Пусть описаны типы:

| TYPE

| Diapazon = 14..27; { диапазон }

| Massiv1 = Array [14..27] of Real; { тип массив }

| Massiv2 = Array [15..28] of Integer; { другой массив }

Если в приведенный фрагмент вкралась ошибка и надо срочно сдвинуть диапазоны в типах на четыре значения вниз, то придется исправить только в нем шесть цифр. А во всей программе? Чтобы избавиться от конкретных цифр, можно задать их константами:

| CONST

| Lower = 14;

| Upper = 27;

| TYPE

| Diapason = Lower ..Upper;

| Massiv1 = Array [Lower..Upper] of Real;

| Massiv2 = Array [Lower+1 .. Upper+1] of Integer;

Теперь в той же ситуации достаточно поправить два числа. В этом примере Lower и Upper простые константы (есть и сложные разновидности констант, но они рассматриваются совместно с переменными).

Константы вводятся исключительно для удобства программиста. В работающей программе выполнимый код будет одинаков для обоих рассмотренных примеров. Дело в том, что компилятор запоминает

- 76 -

все значения простых констант и при трансляции программы заменяет все имена констант на их значения. Именно поэтому простые константы не могут стоять слева в операторе присваивания и вообще не могут изменить свое значение в программе. Они могут участвовать в выражениях, вызовах функций, в операторах циклов, их можно выводить на печать (а вот вводить уже нельзя!), лишь бы не было попыток изменить их значение.

Константы описываются в блоке CONST (или в блоках, если их несколько). Синтаксис их прост:

CONST

ИмяКонстанть1 = Значение1;

ИмяКонстанты2 = Значение2;

и т.п. или

ИмяКонстанты = ЗначениеВыраженияСтоящегоСправа;

Имя и значение константы разделяются знаком равенства «=» (но не знаком присваивания «:=»). После задания константы обязательна точка с запятой. Концом блока констант считается начало любого другого блока или описания процедур и функций.

Все, что касается констант в стандарте Паскаля, верно и для Турбо Паскаля. Согласно стандарту значение простой константы имеет простой тип и не может быть записано выражением:

| CONST

| Min = 0; { константа — целое число }

| Мах = 500; { константа — целое число }

| е = 2.7; { константа — вещественное число}

| SpecChar = '\'; { константа — символ }

| HelpStr = 'Нажмите клавишу F1'; { константа — строка }

| NoAddress = nil; { константа — адрес }

| OK = True; { логическая константа истинно }

| { Можно задавать простые константы типа множество: }

| Alpha = [ 'А'..'Я' ];

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

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

- 77 -

| Interval = Мах - Min + 1;

| Key = Chr(27); { символ с кодом 27 }

| e2 = е*е;

| BigHelpString = HelpStr + 'для подсказки';

| Flag = Ptr($0000, $00F0); { задание адреса }

В выражениях могут использоваться все математические операции (+,-,/,*,div,mod), поразрядные (битовые) действия, логические операторы (not, and, or, xor) и операции отношения (=,<,> и т.п., включая операцию in для множеств). Из стандартных функций Турбо Паскаля в выражениях констант могут участвовать только такие:

Abs(X) — абсолютное значение числа X;

Round(X) — округление X до ближайшего целого числа;

Trunc(X) — отсечение дробной части значения X;

Chr(X) — символ с кодом номер X;

Ord(X) — номер значения X в его перечислимом типе;

Pred(X) — значение, предшествующее X в его типе;

Succ(X) — значение, следующее за X в его типе;

Odd(X) — логическая функция проверки нечетности X;

SizeOf (X) — размер типа с именем X;

Length (X) — длина строки X;

Ptr(S,O) — функция задания адреса;

Lo(X), Hi(X) и Swap(X) — операции с машинными словами.

Этот же набор допускается при построении выражений в окнах отладки (Watch и Evaluate).

Все выражения вычисляются при компиляции, а затем лишь подставляются всюду вместо идентификаторов констант. Нельзя ввести простую (именно простую) константу: массив или запись. Турбо Паскаль вводит особый тип констант — типизированных — и позволяет работать с константами сложных типов (кроме файлов). Но такие сложные константы в силу особенности их реализации в языке, по сути, уже являются переменными и рассматриваются вместе с ними.

 

5.2. Переменные

Переменные вводятся в программу для хранения и передачи данных внутри нее. Любая переменная имеет имя (идентификатор). По правилам Турбо Паскаля имя переменной должно начинаться с буквы и может содержать буквы (только латинские), цифры и знак подчеркивания. Длина имени — почти любая (до 126 символов), но

- 78 -

различаются имена по первым 63 символам. Имена объявляемых в программе переменных должны быть перечислены в блоках описания VAR:

VAR

Имя1 : ИмяТипаОднойПеременной;

Имя2 : ИмяТипаДругойПеременной;

...

Имя9 : КонструкцияТипаПеременной;

Каждому имени переменной в блоке VAR должен ставится в соответствие ее тип. Имя и тип разделяются двоеточием. После объявления и описания переменной должен стоять символ «;». Концом блока описания будет начало какого-либо другого блока программы или описание процедур и функций.

Имя типа может быть именем предопределенного в языке типа или введенного программистом в предыдущем блоке описания типов TYPE. Но разрешается составлять типы по ходу объявления переменных:

| VAR

| X : Real; { вещественная переменная }

| T : Test; { переменная введенного ранее типа Test }

| i, j, k : Integer; { три целые переменные }

| Subr : 1..10; { целая ограниченная переменная }

| Dim : Array [0..99] of Byte; { переменная типа массив }

| S1, S2, { четыре переменные типа }

| S3, S4 : Set of Char; { множество символов }

| PointRec : RECORD

| X,Y : Real { запись с двумя полями }

| END;

Однотипные переменные могут перечисляться через запятую перед объявлением их типа. Никаких правил умолчания при задании типа (как в Фортране, например) или особого обозначения (как в Бейсике) нет. Все переменные должны быть описаны соответствующим типом.

Переменные подразделяются на глобальные и локальные. Глобальные — это переменные, которые объявлены в разделах VAR вне процедур и функций. Переменные, которые вводятся внутри процедур и функций, называются локальными. Среди глобальных переменных не может быть двух с одинаковым именем. Локальные же переменные, которые известны и имеют смысл только внутри процедур или функций, могут дублировать глобальные имена. При этом внутри подпрограмм

- 79 -

все обращения к таким именам соответствуют обращениям к локальным переменным, а вне их — к глобальным. Локальные и глобальные переменные всегда хранятся в разных местах и даже при одинаковых именах не влияют на значения друг друга.

Все глобальные переменные хранят свои значения в так называемом сегменте данных. Его максимальный объем теоретически равен 65520 байт (почти 64К), но практически он всегда меньше на 1...2К. Таким образом, сумма размеров всех объявленных глобальных переменных должна быть меньше, чем 63К. Если этого мало, то используются ссылки и динамические переменные.

Локальные переменные существуют только при работе объявляющих процедур или функций и хранят свои значения в специально отводимой области памяти, называемой стеком. После окончания работы процедуры или функции ее локальные переменные освобождают стек. Размер стека можно менять от 1024 байт (1К) до тех же 65520 байт, используя ключ компилятора $М. По умолчанию он равен 16384 байт (16К). Это максимальный объем всех локальных переменных, работающих одновременно.

Техническая подробность: компилятор Турбо Паскаля отводит место для хранения значений глобальных переменных в сегменте данных последовательно, по мере перечисления имен. Например, объявление

| Var

| i,j : Byte; {два раза по 1 байту}

| D : Array [1..10] of Char; { десять однобайтных элементов}

| R : Real; { шесть байтов }

разместит будущие значения переменных, как показано на рис. 5.1. Этот чисто технический момент будет использован впоследствии.

Рис. 5.1

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

 

5.2.1. Совмещение адресов директивой absolute

Турбо Паскаль позволяет управлять при необходимости размещением значений переменных в памяти (ОЗУ). Для этой цели

- 80 -

служит директива absolute с последующим указанием адреса. Возможны два формата задания адреса, с которым в принудительном порядке будет связана переменная. Первый формат — это указание физического адреса нужной ячейки памяти:

| TYPE

| ByteArray1_10 = Array [1..10] of Byte;

| VAR

| Memory : Byte absolute $0000:$0417;

| SystemV : ByteArray1_10 absolute $B800:$0000;

| MemWord : Word absolute $0:$2;

He вдаваясь в подробности задания самого адреса $...:$..., важно отметить, как будут размещены в дальнейшем значения переменных. Все они, вместо того чтобы в порядке следования разместиться в сегменте данных, будут хранить свои значения в явно заданных (абсолютных) адресах. Причем адрес, указываемый после слова absolute, задает первый байт значения. Так, переменная Memory будет хранить и выдавать текущее значение байта системной памяти. Она же будет изменять его присваиваниями типа

Memory := 16;

{ Теперь байт по адресу $0:$417 содержит значение 16. }

Массив SystemV будет начинаться в памяти с указанного ему абсолютного адреса. В данном случае абсолютный адрес будет адресом первого элемента массива, и в этой ячейке будет хранится значение System[1]. Следующий элемент будет расположен сразу за первым в порядке возрастания адреса. Последний, десятый, элемент массива System будет соответствовать значению, хранящемуся в десятой, начиная с абсолютного адреса, ячейке памяти. И, наконец, значение длиной в слово (Word — 2 байта) MemWord будет соответствовать двум последовательным байтам памяти, первый из которых задан его абсолютным адресом в директиве absolute.

Другой формат использования слова absolute служит для совмещения описываемой переменной не с абсолютным адресом ячейки, а с адресом уже объявленной ранее переменной:

| TYPE

| RArray4Type = Array [1..4] of Real;

| Rec4Type = RECORD x1,y1,x2,y2 : Real

| END;

| VAR

| X : Word;

| Y : Word absolute X;

- 81 -

{ массив из четырех значений типа Real: }

dim : RArray4Type;

{ запись из четырех значений типа Real: }

rec : Rec4Type absolute dim;

В этом примере имена X и Y — разные идентификаторы одного и того же значения. Изменение значения X равносильно изменению значения Y, ибо после объявления Y с указанием 'absolute X', ее значение будет располагаться в тех же ячейках памяти, что и X. Но для X до этого будет отведено место обычным путем — в сегменте данных. Можно совмещать разнотипные переменные, как это сделано с dim и rec. Запись с четырьмя полями вещественного типа совмещена со значением массива из четырех таких же чисел. После объявления 'absolute dim' становятся эквивалентными обращения

dim[1] и rec.x1,

dim[2] и rec.y1,

dim[3] и rec.x2,

dim[4] и rec.y2 .

Разрешение подобных совмещений открывает большие возможности для передачи значений между различными частями программ и их использования. Директива absolute — это подобие средств организации COMMON-блоков и оператора EQUIVALENCE в языке Фортран.

При совмещении переменных сложных типов (например, dim и rec) их типы не должны конструироваться по ходу объявления, а обязаны быть введены ранее в блоке TYPE. Нарушение этого правила компилятором практически не анализируется, а последствия его могут быть самыми неприятными, вплоть до «зависания» ПЭВМ (особенно при работе с сопроцессором).

Формально размеры совмещаемых переменных не обязаны быть одинаковыми. Совмещение по имени переменной — это, по сути, совмещение их начал. Поэтому можно использовать такие приемы:

| VAR

| St : String[30];

| StLen : Byte absolute St;

Здесь значение StLen совмещено со значением текущей длины строки St, которое хранится в элементе строки St[0]. Не рекомендуется совмещать большие по длине переменные с меньшими. Если в последнем примере запись значения в StLen может попортить лишь строку St, то в случае

- 82 -

| VAR

| StLen : Byte;

| St : String absolute StLen;

Другие объявления;

изменение St изменит не только байт StLen, но и значения тех переменных, которые будут объявлены после St.

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

Совмещение переменных — мощное, но очень опасное при неумелом обращении средство. Помните об этом!

 

5.2.2. Переменные со стартовым значением или типизированные константы

Когда программа начинает работать, места под значения переменных уже отведены, но не очищены. Это означает, что в ячейках памяти может быть что угодно (остатки предыдущей программы или ее следы). Поэтому в Паскале очень важно, чтобы каждая переменная перед использованием была бы заполнена имеющим смысл или хотя бы пустым (нулевым) значением.

Выполнить это требование можно, начиная программу со «скучной» переписи переменных

х := 0; у := 10;

ch := 'z';

Особенно неприятно задавать значения массивов и записей, так как это надо делать поэлементно.

Турбо Паскаль предлагает решение этой проблемы, позволяя объявлять переменные и тут же записывать в них стартовые значения. Единственное условие: из раздела описания VAR они должны переместиться в раздел (блок) CONST. Рассмотрим объявление сложных или типизированных констант (они же переменные со стартовым значением).

Важно запомнить, что сложные константы — это обычные переменные, которые могут изменять свое значение наравне с другими. Просто они получают значение до начала выполнения программы. Но их же можно рассматривать как константы сложных типов (массивов, записей).

Простые значения задаются переменным обычным приравниванием после описания типа:

- 83 -

| CONST

| R : Real = 1.1523;

| i : Integer = -10;

| S : String[10] = 'Привет!';

| P1 : Pointer = nil;

| P2 : Pointer = Ptr($A000:$1000);

| Done : Boolean = True;

Отличие от простых констант внешне небольшое: просто вклинилось описание типа. Но суть изменилась в корне. Можно использовать выражения, содержащие операции, ряд функций и простые константы (как и ранее). Но типизированные константы уже не могут принимать участие в выражениях для других констант; они ведь не столько константы, сколько переменные.

Стартовые значения сложных переменных задаются по-разному для различных типов. Массивы задаются перечислением их элементов в круглых скобках. Если массив многомерный (массив массивов), то перечисляются элементы-массивы, состоящие из элементов-скаляров. Выглядит это следующим образом:

| TYPE

| Dim1x10 : Array [1..10] of Real;

| Dim4x3x2 : Array [1..4, 1..3, 1..2] of Word;

{** это то же самое, что и задание: **}

{**Array [1..4] of Array [1..3] of Array [1..2] of Word **}

| CONST

| D1x10 : Dim1x10 =

| (0, 2.1, 3, 4.5, 6, 7.70, 8., 9.0, 10, 3456.6);

| D4x3x2 : Dim4x3x2 = (((1,2), (11,22), (111,222)),

| ((3,4), (33,44), (333,444)),

| ((5,6), (55,66), (555,666)),

| ((7,8), (77,88), (777,888)));

Здесь самым глубоким по уровню вложенности в задании переменной D4x3x2 (многомерного массива) оказывается самый дальний в описании типа массив — двухэлементный массив значений Word. Более высокий уровень — это уже массив из трех двухэлементных массивов, а вся структура переменной D4x3x2 состоит из четырех наборов по три массива из двух чисел.

Тот же способ использования скобок применяется и при задании значений типа «запись». Только надо явно указывать имя поля перед его значением:

- 84 -

| TYPE

| RecType = RECORD { тип запись }

| x, y : LongInt;

| ch : Char;

| dim : Array [1..3] of Byte

| END;

| CONST

| Rec : RecType = ( x : 123654; у : -898; ch : 'A';

| dim : (10, 20, 30));

Поле от своего значения должно отделяться знаком «:». Порядок следования полей в задании значения обязан соответствовать порядку их описания в типе, и поля должны разделяться не запятой, а точкой с запятой «;», как это делается в описании типа «запись».

В принципе, можно конструировать тип прямо в описании переменной, например:

| CONST

| XSet : Set Of Char = [ 'а', 'б', 'в' ];

но предпочтительнее использовать введенное ранее имя этого типа.

При задании структур типа Array of Char, базирующихся на символах, можно не перечислять символы, а слить их в одну строку соответствующей длины:

| CONST

| CharArray : Array [1..5] of Char='abcde'; {пять символов}

Типизированные константы (переменные со стартовым значением) могут быть и глобальными, и локальными, как любые другие переменные. Но даже если объявляется переменная со значением внутри процедуры, т.е. заведомо локальная, то ее значение будет размещено не в стеке, а в сегменте данных. (Об этом подробнее см. разд. 6.9.6.2 «Статические локальные переменные».)

Особенностью компилятора Турбо Паскаль (точнее, его редактора связей — компоновщика) является то, что в выполнимый код программы не входят те переменные, которые объявлены, но не используются. То же самое имеет место и для типизированных констант. Но минимальным «отсекаемым» компоновщиком куском текста программы может быть лишь блок описания CONST или VAR. Поэтому, если заведомо известно, что не все объявляемые переменные будут использоваться одновременно, лучше разбивать их на различные блоки объявлений:

- 85 -

| VAR

| x1, х2, хЗ : Real;

| VAR

| y1, y2, y3 : Integer;

| CONST

| Dim1 : Array [4..8] of Char = '4567';

| CONST

| Dim10tladka : Array [1..10] of Char = '0123456789';

и т.д.

Смысл программы это не изменит, а компоновщик сможет доказать свою эффективность.

 

5.3. Операция присваивания и совместимость типов и значений

Если в программе объявлены переменные, то подразумевается, что они будут получать свои значения по ходу ее выполнения. Единственный способ поместить значение в переменную — это использовать операцию присваивания в программе:

Переменная := Значение;

Оператор присваивания — это составной символ «:=». Его можно читать как «становится равным». В операции присваивания слева всегда стоит имя переменной, а справа — то, что представляет собой ее значение (значение как таковое или выражение либо вызов функции, но может быть и другая переменная). После выполнения присваивания переменная слева получает новое значение.

Турбо Паскаль, являясь языком с сильной системой типов, требует соблюдения определенных правил совместимости типов переменных и значений справа и слева от оператора «:=».

Очевидно, что не может быть проблем с присваиванием, если типы переменной и значений идентичны (тождественны). Два типа Type1 и Туре2 считаются идентичными, если:

1. Типы Type1 и Туре2 описаны одним и тем же идентификатором типа, например:

| TYPE

| Тype1 = Boolean;

| Type2 = Boolean;

здесь Type1 и Type2 идентичны. Но в случае

- 86 -

| TYPE

| Type1 = Array [1..2] of Boolean;

| Type2 = Array [1..2] of Boolean;

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

2. Типы Type1 и Type2 описаны как эквивалентные. Это означает, что, например, при описании

| TYPE

| Type1 = Array [1..2] of Boolean;

| Type2 = Type1;

| Type3 = Type2;

значения типов Type1, Type2 и Type3 будут полностью совместимы. Аналогичная картина возникает и при объявлении переменных. Если переменные причислены к одному и тому же типу

VAR

x1, x2, xЗ : Type1;

то они совместимы. Если Type1 — идентификатор типа, а не конструкция, то совместимость сохранится и при объявлении вида

| VAR

| x1 : Type1;

| x2 : Type1;

| x3 : Type2;

Здесь Type2 идентичен типу Type1, но будут несовместимы переменные x1 и x2:

| VAR

| x1 : Array [1..2] of Real;

| x2 : Array [1..2] of Real;

Ограничения на совместимость только по идентичным типам было бы слишком жестким. Поэтому совместимость в Турбо Паскале трактуется несколько шире. Так, типы считаются совместимыми, если:

— оба типа являются одинаковыми;

— оба типа являются вещественными типами;

— оба типа являются целочисленными;

- 87 -

— один тип является поддиапазоном другого;

— оба типа являются поддиапазонами одного и того же базового типа;

— оба типа являются множественными типами с совместимыми базовыми типами;

— один тип является строковым, а другой тип — строковым или символьным типом;

— один тип является указателем (Pointer), а другой — указателем или ссылкой.

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

Существует еще один вид совместимости: совместимость по присваиванию, т.е. правила присваивания значения V2 (собственно значение, переменная или выражение) переменной V1. Они действительны только для операций присваивания и являются немногим более широкими, чем правила совместимости по типам. Значение V2 типа Type1 может быть присвоено переменной V1 типа Type2, если выполняется одно из условий:

1. Type1 и Type2 — тождественные типы, и ни один из них не является файловым типом или структурным типом, содержащим компонент с файловым типом.

2. Type1 и Type2 — совместимые перечислимые типы, и значения типа Type2 попадают в диапазон возможных значений Type1.

3. Type1 и Type2 — вещественные типы, и значения типа Type2 попадают в диапазон возможных значений Typel.

4. Typel — вещественный тип, а Type2 — целочисленный тип.

5. Type1 и Type2 — строковые типы.

6. Type1 — строковый тип, а Type2 — символьный тип.

7. Type1 и Type2 — совместимые множественные типы, и все члены значения множества типа Type2 попадают в диапазон возможных значений Type1.

8. Type1 и Type2 — совместимые адресные типы.

9 Тип объекта Type2 совместим по присваиванию с типом объекта Type1, если Type2 находится в области типа объекта Type1.

10. Тип ссылки Ptr2, указывающий на тип объекта Type2, совместим по присваиванию с типом ссылки Ptr1, указывающим на тип объекта Type1, если Type2 находится в области типа объекта Type1.

- 88 -

Последние два правила, относящиеся к данным типа «объект», не слишком очевидны. Более подробное их описание приводится в гл. 13 «Объектно-ориентированное программирование».

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

С вопросом совместимости очень тесно связан вопрос о типе результатов арифметических выражений. Например, можно ли заранее сказать, какой будет тип у результата выражения справа?

| VAR

| B :Byte;

| W : Word;

| I : Integer;

| R : Real;

...

| R := В*I+W;

На этот счет существуют четкие правила внутреннего преобразования типов значений — участников операций:

1. В случае бинарной операции, использующей два операнда, оба операнда преобразуются к их общему типу перед тем, как над ними совершается действие. Общим типом является встроенный целочисленный тип с наименьшим диапазоном, включающим все возможные значения обоих типов. Например, общим типом для целого и целого длиной в байт является целое, а общим типом для целого и целого длиной в слово является длинное целое. Действие выполняется в соответствии с точностью общего типа, и типом результата является общий тип. Если же один из операндов — вещественный, а второй — целочисленный, то результатом операции может быть только значение вещественного типа.

2. Выражение справа в операторе присваивания вычисляется независимо от размера переменной слева.

Если результат выражения «не вписывается» в тип переменной слева от знака «:=», то может возникнуть ошибка переполнения. В случае вещественной переменной слева при переполнении возникнет ошибка счета 205 (Floating Point overflow). Но если слева стоит целочисленная переменная, то при режиме компиляции {$R+} возникнет ошибка нарушения диапазона 201 (Range Check Error), а при {$R-} программа не прервется, но значение в переменной будет «обрезано» ее диапазоном и перестанет соответствовать выражению справа. Последний случай чреват труднодиагностируемыми ошибками в результатах счета программы.

- 89 -

Другим примером опасности может стать вывод значений выражений оператором Write (или в общем случае подстановка выражений в вызовы процедур или функций):

| VAR

| A, B : Word;

| BEGIN

| A:= 55000;

| B:= A-256;

| Write(A+B);

| END.

Эта программа должна вычислить значение A+B и вывести его на экран. Но она этого не сделает. В режиме компиляции {$R+} запуск программы даст ошибку 201, поскольку общий для A и B тип Word не вмещает их сумму (его «потолок» равен 65535). В режиме {$R-} программа напечатает заведомую ложь.

Выход из подобных ситуаций прост. Надо объявлять хотя бы одного участника выражения более длинным (емким) типом. Так, если описать A как LongInt, то общим для A и B типом станет LongInt, и в нем уместится достаточно большое значение суммы. Можно даже просто, не изменяя объявления переменной, переписать последний оператор в виде

Write(LongInt(A) + B);

используя описываемое ниже приведение типа значения.

 

5.4. Изменение (приведение) типов и значений

В Турбо Паскале имеется очень мощное средство, позволяющее обойти всевозможные ограничения на совместимость типов или значений: определена операция приведения типа. Она применима только к переменным и значениям. Суть этой операции в следующем. Определяя тип, мы определяем форму хранения информации в ОЗУ, и переменная данного типа будет представлена в памяти заранее известной структурой. Но если «взглянуть» на ее образ в памяти с точки зрения машинного представления другого типа, то можно будет трактовать то же самое значение как принадлежащее другому типу. Для этого достаточно использовать конструкцию

ИмяТипа( ПеременнаяИлиЗначение )

Задаваемое имя типа, в который происходит преобразование, должно быть известно в программе. Примеры приведения типов:

- 90 -

| TYPE

| Arr4Byte = Array[1..4] of Byte; { массив из 4-х байтов }

| Arr2Word = Array[1..2] of Word; { массив из двух слов }

| RecType = RECORD

| Word1, Word2 : Word { запись из двух слов }

| END;

| VAR

| L : LongInt; { четырехбайтовое целое со знаком }

| S : ShortInt; { однобайтовое целое со знаком }

| В : Byte; { однобайтовое целое без знака }

| W : Word; { двухбайтовое целое без знака }

| a4 : Arr4Byte; { массив из четырех байтов }

| a2 : Arr2Word; { массив из двух слов по два байта }

| Rec : RecType; { запись из двух слов по два байта }

| BEGIN

| L := 123456; { некое значение переменной L }

| S := -2; { некое значение переменной S }

| a2 := arr2Word( L ); { два слова L перешли в массив a2 }

| a4 := arr4Byte( L ); {четыре байта L перешли в a4 }

| W := RecType( L ).Word1; { доступ к L по частям

| W := arr2Word( L )[ 1 ];

| RecType(L).Word1 := 0; { обнуление первого слова в L }

| B := Byte( S ); { если S=-2, то B станет 254 }

| B := Arr4Byte( a2 )[1]; { запись в B значения первого }

{полуслова массива a2 }

| END.

Приведение типов не переопределяет типы переменных. Оно лишь дает возможность нарушить правила совмещения типов при условии, что соответствующие значения совместимы в машинном представлении. При преобразовании типа переменной ее размер всегда должен быть равен размеру типа, к которому приводится значение. Если после приведения переменной к структуре мы хотим воспользоваться отдельным ее элементом, то просто приписываем индекс (для массивов) или поле (для записей). Вообще говоря, конструкцию ИмяТипа( Переменная ) можно условно считать именем некой необъявленной переменной типа «ИмяТипа» и со значением, хранимым в «Переменной». Приведение типа переменной может стоять как слева, так и справа, т.е. может участвовать в выражениях. Допускается вложенность преобразований при условии сохранения размеров. Как видно из примера, можно изменять определенные байты общей структуры переменной в памяти независимо от ее типа.

- 91 -

Аналогично изменению типа переменных можно изменять тип значений как таковых, а также результирующий тип выражений, т.е. разрешены такие преобразования:

Integer( 'Y' ) { код символа 'Y' в формате Integer }

Boolean( 1 ) { это логическое значение True }

LongInt( 1 ) { значение 1, размещенное в четырех байтах}

Char ( 130-1 ) { символ с кодом ASCII номер 129 }

В этом случае происходит трактование значения в скобках как значения другого типа. Например, символ 'Y' хранится как код 89 и занимает один байт. Но конструкция Integer ('Y') представляет собой значение 89 в формате целого числа со знаком (в двух байтах). Как видно, при преобразовании типа значений соблюдение размера уже не нужно. Новый тип может быть шире, а может быть и короче, чем естественный тип значения.

При приведении значения в более широкий тип (например, LongInt(1)) значения будут целиком записаны в младшие (наименее значащие) байты, что сохранит само значение. В противоположном случае, когда значение приводится к более короткому типу, от него берутся уже не все, а лишь самые младшие байты. При этом старшие байты игнорируются, и приведенное значение не равно исходному. Например, выражение Byte( 534 ) равно 22, поскольку значение 534 кодируется в тип Word и раскладывается на младший и старший байты как 22 + 2*256. Младший байт (22) мы получим, а старший (со значением 2) проигнорируем.

Преобразование типа значения внешне похоже на преобразование типа переменной. Но эффект от него несколько иной (за счет возможности изменения размера), и ограничения на применение другие. В частности, как задаваемый тип, так и тип значения (выражения) должны быть перечислимыми (это все целочисленные типы, тип Char, Boolean и вводимые перечисления) или адресными (адресные значения хранятся как значения LongInt). По понятным причинам преобразование значения не может появиться в левой части присваивания.

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

Приведение типов как переменных, так и значений — нетривиальная операция. Она подразумевает достаточно высокий уровень знаний технических подробностей языка. Например, нужно знать, как хранятся структуры (массивы, записи, множества), адреса, числа, строки в памяти, какие размеры им отводятся. Приведение

- 92 -

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

В следующих частях книги будут рассматриваться вопросы хранения данных в памяти. Кроме того, во многих примерах будет использоваться приведение типов.

- 93 -

 

6.1. Простой и составной операторы

Оператор в программе — это единое неделимое предложение, выполняющее какое-либо действие. Типичный простой оператор — оператор присваивания. Другим примером может служить вызов какой-либо процедуры в программе. Важно, что под любым оператором подразумевается действие (присваивание, сравнение величин, вызов подпрограммы, переход по программе и т.п.). Блоки описания типов, переменных, констант, меток и составляющие их предложения не являются в этом смысле операторами.

Два последовательных оператора обязательно должны разделяться точкой с запятой «;». Этот символ имеет смысл конца оператора, и он же разделяет операторы при записи в одну строку, например:

a:=11; b:=a*a; Write(a,b);

Отсюда вовсе не следует, что можно не закрывать символом «;» единственные в строке операторы.

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

Составной оператор — это последовательность операторов, перед которой стоит слово BEGIN, а после — слово END. Между любыми двумя операторами должна стоять точка с запятой. Она сама по себе не является оператором и поэтому может отсутствовать между оператором и словом END. Зарезервированное слово BEGIN тоже не является оператором (как и все остальные зарезервированные слова), и после него точка с запятой не ставится. Так, чтобы оформить

- 94 -

три приведенных выше оператора в один, но составной, нужно как бы заключить их в операторные скобки BEGIN...END:

| BEGIN

| a:=11;

| b:=a*a;

| Write(a,b)

| END;

При этом последняя точка с запятой перекочевала за слово END. Составной оператор может содержать любое допустимое число простых операторов, состоять лишь из одного оператора или вообще быть пустым. Он допускает вложенность, т.е. может содержать внутри себя другие составные операторы (в этом случае нужно лишь, чтобы внутренний составной оператор открывался позже чем внешний, а закрывался раньше).

Составной оператор — очень важное понятие в структурном программировании. В Паскале все управляющие структуры не различают простой и составной операторы: там, где стоит простой оператор, можно поставить и составной.

 

6.2. Условный оператор (

IF

...

THEN

...

ELSE

)

Условный оператор IF...THEN...ELSE (если...то...иначе) имеет структуру

If Условие THEN Оператор1 ELSE Оператор2;

и служит для организации процесса вычислений в зависимости от какого-либо логического условия. Под условием понимается логическое значение True (истинно) или False (ложно), представленное константой, переменной или логическим выражением, например:

IF True THEN ...; { крайний и бесполезный случай условия }

IF LogicalVar THEN ...; { условие — логическая переменная }

IF not LogicalVar THEN ...; {условие — логическое выражение}

IF x > 5 THEN ...; { условие — результат операции сравнения}

Если условие представлено значением True, то выполняется оператор (простой или составной), следующий за словом THEN. Но если условие не выполняется, т.е. представлено значением False, то будет выполняться оператор (может быть простым или составным), следующий за словом ELSE. Например:

- 95 -

| IF x>5

| THEN { ветвь при x>5 - истинно }

| BEGIN

| x:=x+5; y:=1 { некий составной оператор }

| end

| ELSE { ветвь при x>5 - ложно }

| y:=-1; { простой оператор }

В примере между ключевыми словами нет точек с запятой. Более того, их появление было бы ошибкой, что будет показано ниже. Но точка с запятой в конце всего оператора (после завершения ветви ELSE) обязательна. Она отделяет условный оператор от остальных, следующих за ним по тексту. Альтернативную ветвь ELSE можно опускать, если в ней нет необходимости. В таком «усеченном» условном операторе в случае невыполнения условия ничего не происходит, и выполняется следующий за условным оператор. Имеет «право на жизнь» условный оператор с ветвями, содержащими пустые операторы, например такой:

IF LogicFunc(x) THEN ;

Он полезен в случаях, когда условием является возвращаемое значение какой-либо логической функции, имеющей побочный эффект. Например, известны библиотеки подпрограмм (Turbo Power Toolbox), где для создания окна на экране дисплея имеются функции, собственно строящие окно и возвращающие логическое значение в зависимости от результата построения. Приведенная выше конструкция позволяет проявиться побочному эффекту, игнорируя возвращаемое значение.

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

IF Условие

THEN { Условие выполняется }

if ПодУсловие { ПодУсловие выполняется }

then

BEGIN

...

end

else { ПодУсловие не выполняется }

BEGIN

...

end

ELSE { Условие не выполняется }

BEGIN

...

end;

- 96 -

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

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

IF Условие1

THEN

if Условие2

then ОператорА

ELSE

ОператорБ;

По записи похоже, что ОператорБ будет выполняться только при невыполнении Условия1. Но в действительности он будет отнесен к Условию2 и выполнится лишь при выполнении Условия1 и невыполнении Условия2. Попытка закрыть вложенный условный оператор установкой «;» после ОператораА лишь ухудшит положение. Выход здесь таков: нужно представить вложенное условие как составной оператор

IF Условие1

THEN

BEGIN

if Условие2

then ОператорА

end

ELSE

ОператорБ;

и для ветви ELSE ближайшим «незакрытым» оператором IF окажется оператор с Условием1.

В условии оператора IF может стоять достаточно сложное логическое выражение. В нем придется учитывать приоритет различных логических и математических операций, а также текущую схему компиляции логических выражений в Турбо Паскале. (Подробнее об этом см. разд. 9.3 «Логические вычисления и операции отношения».)

 

6.3. Оператор варианта (

CASE

)

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

- 97 -

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

CASE УправляющаяПеременнаяИлиВыражение OF

НаборЗначений1 : Оператор1;

НаборЗначений2 : Оператор2;

НаборЗначенийЗ : ОператорЗ;

...

НаборЗначенийN : ОператорN

ELSE

АльтернативныйВсемНаборамОператор

END;

Между служебными словами CASE и OF должна стоять переменная или выражение (оно вычислится при исполнении оператора CASE). Тип переменной (или значения выражения) может быть только перечислимым (включая типы Char и Boolean), диапазоном или целочисленным одного из типов Byte, ShortInt, Integer или Word. Все прочие типы не будут пропущены компилятором Турбо Паскаля. Набор значений — это конкретные значения управляющей переменной или выражения, при которых необходимо выполнить соответствующий оператор, игнорируя остальные варианты. Если в наборе несколько значений, то они разделяются между собой запятыми. Можно указывать диапазоны значений. Между набором значений и соответствующим ему оператором обязательно должно ставиться двоеточие «:».

Оператор в конкретном варианте может быть как простым, так и составным. Конец варианта обязательно обозначается точкой с запятой. Турбо Паскаль допускает необязательную часть ELSE. Если значение переменной (выражения) не совпало ни с одним из значений в вариантах, то будет выполнен оператор, стоящий в части ELSE.

Завершает оператор CASE слово END. По-прежнему перед ELSE и END необязательна точка с запятой. Рассмотрим пример оператора варианта (в нем Err — переменная типа Word):

| CASE Err OF

| 0 : WriteLn( 'Нормальное завершение программы' );

| 2, 4, 6 : begin

| WriteLn('Ошибка при работе с файлом');

| WriteLn('Повторите действия снова.')

| end ;

- 98 -

| 7..99 : WriteLn( 'Ошибка с кодом ', Err )

| ELSE {case}

| WriteLn( 'Код ошибки=,Err,' См. описание')

| END ; {case}

Здесь в зависимости от значения переменной Err выводится на экран операторами WriteLn текст соответствующего сообщения. Наличие варианта ELSE (Err не равна 0, 2, 4, 6 и не входит в диапазон 7..99) гарантирует выдачу сообщения в любом случае.

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

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

 

6.4. Оператор цикла с предусловием (

WHILE

)

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

Рассмотрим оператор цикла с предусловием, записываемый как

WHILE Условие DO Оператор;

Конструкция WHILE...DO переводится как «пока...делать». Оператор (простой или составной), стоящий после служебного слова DO и называемый телом цикла, будет выполняться циклически, пока выполняется логическое условие, т.е. пока значение «Условия» равно True. Само условие цикла может быть логической константой, переменной или выражением с логическим результатом.

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

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

- 99 -

выражений и значений, определенных еще до первого выполнения тела цикла. Поясним сказанное примером, вычисляющим значение факториала 10! (рис. 6.1).

| VAR

| Factorial, N : Integer;

| BEGIN

| Factorial := 1; { стартовое значение факториала = 0! }

| N:=1; {стартовое значение для условия цикла}

| WHILE N<=10 DO

| begin { начало тела цикла WHILE }

| Factorial:=Factorial*N; { вычисление факториала N! }

| N := N + 1 { N должно меняться в цикле }

| end ; { конец тела цикла WHILE }

| WriteLn( Factorial ); { вывод результата расчета }

| END.

Рис. 6.1

Обратите внимание на присваивание N:=1 перед циклом. Без него значение N может быть любым, и условие может быть некорректным, не говоря уже о самом значении факториала. Значение N меняется внутри цикла. При этом гораздо безопаснее так писать тело цикла, чтобы оператор, влияющий на условие, был последним в теле. Это гарантирует от нежелательных переборов. Если, скажем, на рис. 6.1 поставить строку N:=N+1; перед вычислением значения Factorial, то результатом программы будет значение 11!. Исправить оплошность можно, заменив стартовое значение N на 0, а условие — на N<10. Но от этого программа вряд ли станет нагляднее. Поскольку циклу WHILE «все равно», что происходит в его теле, тело может содержать другие, вложенные, циклы.

 

6.5. Оператор цикла с постусловием (

REPEAT

...

UNTIL

)

Рассмотренный выше оператор цикла с предусловием решает, выполнять свое тело или нет, до первой итерации. Если это не соответствует логике алгоритма, то можно использовать цикл с постусловием, т.е. решающий, делать или нет очередную итерацию, лишь после завершения предыдущей. Это имеет принципиальное значение лишь на первом шаге, а далее циклы ведут себя идентично. Цикл с постусловием всегда будет выполнен хотя бы один раз.

- 100 -

Оформляется такой цикл с помощью служебных слов REPEAT и UNTIL (повторять до):

REPEAT

Оператор1;

Оператор2;

...

ОператорN

UNTIL Условие;

Первое из них объявляет цикл и открывает его тело, а второе — закрывает тело и содержит условие окончания цикла. Тело цикла может быть пустым или содержать один и более операторов. В последнем случае слова BEGIN и END не нужны: их роль играют слова REPEAT и UNTIL.

Условие — это логическое значение, переменная или выражение с логическим результатом. Но работает оно здесь совсем не так, как в цикле WHILE. Если в цикле WHILE подразумевается алгоритм «пока условие истинно, выполнять операторы тела цикла», то цикл REPEAT...UNTIL соответствует алгоритму «выполнять тело цикла, пока не станет истинным условие».

Иными словами, в цикле с REPEAT...UNTIL условием продолжения итераций будет невыполнение условия (его значение False). Хорошей иллюстрацией к вышесказанному может быть конструкция «вечного цикла»:

REPEAT UNTIL False;

Этот цикл пустой и никогда не прекращающийся. Он хорош только в случае, когда нужно заблокировать программу, и, возможно, весь компьютер. (Но если отбросить шутки, то можно и его пристроить в дело. Обычно так организуются программы с повторяющимися действиями: вначале программы ставится REPEAT, а в конце — UNTIL False. А прервать цикл можно специальными операторами: Exit, Halt. Это имеет смысл, если условий завершения программы много или они очень сложны.)

Если условие конца цикла более гибкое, чем константа False, то в теле цикла должны содержаться операторы, влияющие на само условие. О предварительной корректности условия, как в случае цикла WHILE, заботиться уже необязательно.

 

6.6. Оператор цикла с параметром (

FOR

...

DO

)

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

- 101 -

«строгих» циклов, которые должны быть проделаны данное число раз. Цикл с параметром вводится именно для таких случаев. Синтаксис оформления циклов с параметром следующий:

FOR ПараметрЦикла:=МладшееЗнач TO СтаршееЗнач DO Оператор;

или

FOR ПараметрЦикла := СтаршееЗнач DOWNTO МладшееЗнач DO

Оператор;

Слова FOR...TO (DOWNTO)...DO можно перевести как «для параметра от...до...делать».

Оператор, представляющий собой тело цикла, может быть простым, составным или пустым. В последнем случае за словом DO сразу ставится точка с запятой. Параметр цикла, а также диапазон его изменения (от стартового до конечного значения включительно) может быть только целочисленного или перечислимого типа. Сам параметр должен быть описан совместно с прочими переменными. Шаг цикла FOR всегда постоянный и равен «интервалу» между двумя ближайшими значениями типа параметра цикла. Изменение параметра цикла может быть возрастающим, но может быть и убывающим. В первом случае МладшееЗначение должно быть не больше чем Старшее, а во втором — наоборот. Примеры оформления циклов с параметром приведены на рис. 6.2.

| VAR

| i : Integer; { описание параметров циклов}

| c : Char;

| b : Boolean;

| e : (elem1, elem2, elem3 ); {вводимый перечислимый тип}

| BEGIN

| FOR i:= -10 TO 10 DO Writeln(i);

| FOR i:= 10 DOWNTO -10 DO Writeln(i);

| FOR c:= 'a' TO 'r' DO Writeln(с);

| FOR b:=True DOWNTO False DO Writeln(b);

| FOR e:= elem1 TO elem3 DO Writeln(Ord(e));

| END.

Рис. 6.2

Если параметр возрастает, то между границами его значений ставится слово TO, если же убывает, то ставится слово DOWNTO. Соответственно с этим меняются местами старшее и младшее зна-

- 102 -

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

FOR i := 5 ТО 4 DO ...;

FOR i : = 4 DOWNTO 5 DO ...;

а цикл

FOR i := N TO N DO ...;

выполнит операторы своего тела строго один раз.

Запрещается изменять параметр цикла и его старшее и младшее значения (если они заданы переменными или выражениями с ними) изнутри тела цикла. Кроме того, параметр цикла не может участвовать в построении диапазонов этого же цикла. Компилятор таких «незаконных» действий не замечает, но программа, содержащая цикл с заголовком типа

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

не заслуживает никакого доверия, даже если запускается. Если же необходимо досрочно завершить цикл FOR (для чего велик соблазн искусственно «подрастить» параметр цикла), то можно воспользоваться оператором перехода Goto (о нем см. следующий раздел). В техническом описании Турбо Паскаля отмечается, что после завершения цикла FOR значение его параметра не определено. При экспериментальной проверке этого факта скорее всего получится обратный результат: параметр будет иметь конечное значение своего диапазона. Тем не менее, не следует опираться на это в своих программах. Лучше переприсвоить значение параметра после окончания цикла — так будет корректнее. Исключение — выход из цикла переходом Goto. В этом случае значение переменной (параметра цикла) останется таким же, каким было на момент выполнения оператора Goto.

- 103 -

Циклы с параметром — очень быстрые и генерируют компактный выполнимый код. Но всем им присущ один традиционный в Паскале недостаток — параметр должен принадлежать к перечислимому типу, а шаг не может быть изменен. Так, в первых двух циклах на рис. 6.2 шагом будет значение +1 и -1 соответственно, в цикле от 'а' до 'г' параметр C примет последовательные значения 'а', 'б', 'в', 'г', т.е. каждый следующий элемент — это значение функции Succ(C). Следствием этого являются проблемы организации циклов с шагом, отличным, например, от 1, а тем более циклов с вещественным параметром.

Для разрешения таких проблем приходится использовать обходные пути: обращаться к циклам с условиями. Так, цикл с вещественным параметром r от 3,20 до 4,10 с шагом 0,05 можно запрограммировать циклом WHILE:

r:=3.20;

WHILE r<=4.10 do

BEGIN

...

r := r + 0.05

end;

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

 

6.7. Оператор безусловного перехода Goto

Оператор Goto, имеющийся во многих алгоритмических языках, включая и Турбо Паскаль, можно с полным правом назвать «злосчастным». В разгар моды на структурное программирование он подвергся сильным гонениям, ибо было доказано, что можно вообще программировать без него. Из-за того же Goto здорово доставалось Фортрану и раннему Бейсику, большей частью справедливо, так как от пары десятков переходов вдоль и поперек программа не становится более понятной.

Но на практике выбор между чистотой идеи (структурное программирование) и элементарным удобством (использование Goto) был предрешен, и в структурном Паскале мы можем использовать безусловные переходы по программе.

Полный синтаксис оператора перехода — это

Goto Метка;

- 104 -

где метка — описанный в блоке LABEL идентификатор (цифры от 0 до 9999 или собственно идентификатор). Метка может стоять в программе «где угодно» между операторами. При этом каждая метка может появиться только один раз (рис. 6.3):

| LABEL

| m10, m20, StopLabel, 1;

| VAR

| i : ShortInt;

| BEGIN

| 0001:

| IF i<10 THEN Goto m10 ELSE Goto m20;

| ...

| m10 : WriteLn('i меньше 10');

| Goto StopLabel;

| m20 : i := i - 1;

| ...

| Goto 1;

| StopLabel:

| END.

Рис. 6.3

Метка от оператора должна отделяться символом «:». Если метка обозначается цифрой, то предшествующие нули не являются значащими. Так, на рис. 6.3 метки 1 и 0001 эквивалентны. Обычно метки размещаются у операторов, но могут стоять и у слова END, что означает переход на конец текущего блока BEGIN...END (на рисунке это еще и выход из программы). Перед BEGIN метки не ставятся. Следует избегать переходов (и расстановки меток), передающих управление внутрь составных операторов циклов, да и вообще переходов в составные операторы, вложенные в тот, где выполняется оператор Goto. Другое дело — выход из вложенных операторов во внешние. В таких случаях применение Goto — достаточно безопасный и максимально эффективный способ вернуть управление внешнему оператору.

Область действия операторов перехода и связанных с ними меток строго локализована. Метки, описанные вне процедур или функций, имеют своей областью действий только основной блок программы. Но метки, описанные внутри определения процедур или функций, имеют смысл только внутри них, поэтому запрещены переходы по Goto между процедурами и между процедурами и основным блоком.

- 105 -

При практическом программировании на Паскале необходимость в использовании оператора Goto возникает не часто (если, конечно, не писать стилем Фортрана или Бейсика на Паскале). Иногда один переход позволяет избежать очень широких циклов, но злоупотребление переходами не будет признаком высокой культуры программирования.

 

6.8. Операторы Exit и Halt

Турбо Паскаль обладает средствами безусловного выхода из программных блоков (процедур, функций, основного блока программы). Это очень удобно, так как позволяет завершить программу или процедуру без предварительных переходов по меткам. К таким операторам завершения относятся вызовы системных процедур Exit и Halt.

Вызов Exit завершает работу своего программного блока. Если выполняется Exit в процедуре, то выполнение ее завершится и ход программы вернется к следующему за вызовом этой процедуры оператору. При этом процедура вернет значения, которые успели вычислиться к моменту выполнения Exit (если она должна их возвратить). Сама программа не прервется. Но если Exit выполняется в основном блоке программы, выход из него будет эквивалентен нормальному ее завершению. Процедура Exit — в некотором роде избыточная. Ее действие полностью эквивалентно безусловному переходу (Goto) на метку, стоящую перед последним словом END содержащей ее процедуры, функции или основного блока. Но использование Exit позволяет избежать лишней возни с метками и улучшает читаемость программ. Таким образом, Exit — это средство выхода из программного блока, а не из составного оператора, например цикла FOR. Вызов Exit может быть в трижды вложенном цикле процедуры, но его действие все равно будет относится к процедуре, как к программному блоку.

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

- 106 -

На основе процедуры Halt можно легко построить программу, например ASK.PAS, для организации диалога в ВАТ-файлах MS-DOS (рис. 6.4).

| VAR i : Word; { ======ПРОГРАММА ASK.PAS ======== }

| BEGIN

| { ...вывод на экран текста альтернатив выбора... }

| Write( 'Введите Ваш выбор: ');

| ReadLn(i); { ввод номера альтернативы с экрана)

| Halt(i) { остановка программы и назначение }

| END. { ERRORLEVEL в MS-DOS номера i }

Рис. 6.4

Теперь в ВАТ-файле надо запускать откомпилированную программу ASK.EXE и сразу после нее анализировать, что будет находиться в переменной MS-DOS ERRORLEVEL.

Имеет смысл при нескольких вызовах Halt в тексте программы назначать им разные коды завершения. Тогда можно будет при отладке или работе определить, чем вызвано прерывание программы.

 

6.9. Процедуры и функции

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

Определить простейшую процедуру довольно просто: практически любой составной оператор, вынесенный из основного блока программы и объявленный предложением

PROCEDURE ИмяПроцедуры;

становится процедурой, и вместо этого составного оператора в основном блоке может подставляться одно лишь ИмяПроцедуры.

Согласно более общему определению процедура может иметь параметры, метки перехода внутри себя и свои, локальные, переменные (рис. 6.5). Обязательными элементами процедур и функций тоже является заголовок и тело, т.е. тот же составной оператор.

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

ИмяПроцедуры(Параметр1, Параметр2,);

- 107 -

PROCEDURE ИмяПроцедуры (ПарамЗнач1 : ТипЗнач1;

ПарамЗнач2 : ТипЗнач2;

VAR ПарамПерем1 : ТипПерем1;

VAR ПарамПерем2 : ТипПерем2; ... );

LABEL

Перечисление меток внутри тела процедуры

CONST

Описание локальных констант процедуры

TYPE

Описание локальных типов

VAR

Описание локальных переменных

Описание вложенных процедур и (или) функций

BEGIN

Тело процедуры

END;

Рис. 6.5

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

FUNCTION ИмяФункции( Список параметров ) :

ИмяСкалярногоТипаЗначенияФункций;

Что и как может возвращать функция при ее вызове, мы рассмотрим чуть позже.

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

 

6.9.1. Параметры. Глобальные и локальные описания

Поскольку процедуры и функции должны обладать определенной независимостью в смысле использования переменных (а также типов и констант), при их введении в программу возникает разделение данных и их типов на глобальные и локальные. Глобальные константы, типы, переменные — это те, которые объявлены в программе вне процедур или функций. Наоборот, локальные — это константы, типы и переменные, существующие только внутри процедур или функций, и объявленные либо в списке параметров (только переменные), либо в разделах CONST, TYPE, VAR внутри процедуры или функции.

- 108 -

Процедуры и функции могут, наряду со своими локальными данными, использовать и модифицировать и глобальные. Для этого нужно лишь, чтобы описание процедуры (функции) стояло в тексте программы ниже, чем описания соответствующих глобальных типов, констант и переменных (рис. 6.6).

PROGRAM Main;

| VAR

| Xmain, Ymain : LongInt; {глобальные переменные}

| Res : Real;

| PROCEDURE Proc1( a,b : Word; VAR Result : Real );

| VAR

| Res : Real; { локальная Res, закрывающая глобальную }

| BEGIN

| Res := a*a + b*b; { локальные действия }

| Result:= Xmain+Ymain*Res; {работают глобальные значения}

| Xmain := Xmain+1; { модифицируется глобальное значение}

| END;

TYPE

CONST Другие глобальные объявления, уже

VAR недоступные из процедуры Proc1;

BEGIN

Основной блок, в котором может вызываться Proc1

END.

Рис. 6.6

При совпадении имен локальной и глобальной переменных (типов, констант) сильнее оказывается локальное имя, и именно оно используется внутри подпрограммы. Так, существует неписанное правило: если подпрограмма содержит в себе циклы FOR, то параметры циклов должны быть описаны как локальные переменные. Это предупредит неразбериху при циклическом вызове процедур.

Мы уже отмечали, что параметры, описываемые в заголовке процедур и функций, по сути, являются локальными переменными. Но кроме того, они обеспечивают обмен значениями между вызывающими и вызываемыми частями программы (т.е. теми же процедурами или функциями). Описываемые в заголовке объявления подпрограммы параметры называются формальными, а те, которые подставляются на их место при вызове, — фактическими, ибо они при выполнении как бы замещают все вхождения в подпрограмму своих формальных «двойников».

- 109 -

Параметры подпрограмм разделяются на параметры-значения и параметры-переменные. Параметры-значения — это локальные переменные подпрограммы, стартовые значения которых задаются при вызове подпрограммы из внешних блоков (а те локальные переменные, которые описаны в разделе VAR между заголовком и телом подпрограммы, должны получать свои значения присваиванием внутри тела подпрограммы). Параметры-значения, описанные в заголовке, могут изменять свои значения наряду с прочими переменными, но эти изменения будут строго локальными и никак не передадутся в вызывающие операторы. Для того чтобы подпрограмма изменила значение переданной ей переменной, нужно объявлять соответствующие параметры как параметры-переменные, вставляя слово VAR перед их описанием в заголовках. Рассмотрим внутренний механизм передачи параметров подпрограмм. При вызове процедуры или функции каждой локальной переменной, описанной внутри процедуры, и каждому параметру-значению отводится место для хранения данных в специальной области памяти, называемой стеком. Эти места принадлежат переменным ровно столько времени, сколько выполняется подпрограмма. Причем ячейки, соответствующие параметрам-значениям, сразу заполняются конкретным содержимым, заданным в вызове подпрограммы. По-другому организуются параметры-переменные. Вместо копии значения подпрограмма получает разрешение работать с тем местом, где постоянно (т.е. все время работы самого вызывающего программного блока) хранится значение переменной, указанной в вызове на месте параметра-переменной. Все действия с параметром-переменной в подпрограмме на самом деле являются действиями над подставленной в вызов переменной.

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

Рассмотрим пример процедуры (рис. 6.7), принимающей любое число и возвращающей его квадрат. Если значение квадрата числа превышает значение 100, то оно считается равным 100. При этом должен устанавливаться глобальный «флаг».

На рис. 6.7 отмечены оба способа обмена данными с процедурой: непосредственной модификацией глобальных переменных и передачей переменной через VAR-параметр. Обратите внимание на использование локальной переменной X. Подобные приемы иногда позволяют не вводить лишних локальных переменных.

- 110 -

| VAR

| GlobalFlag : Boolean; {глобальный флаг}

| PROCEDURE GetSQR( X : Real; VAR Sq : Real );

| { процедура не имеет локальных переменных, кроме X }

| CONST

| SQRMAX =100; { локальная простая константа }

| BEGIN { начало тела процедуры }

| { В X запишется квадрат его последнего значения: }

| X := X * X;

| { Результат сравнения запишется в глобальный флаг: }

| GlobalFlag := ( X > SQRMAX );

| if GlobalFlag then

| X:=SQRMAX; { ограничение X }

| Sq := X { возвращение значения }

| END ; { конец тела процедуры }

| VAR

| SqGlobal : Real;

| BEGIN { основной (вызывающий) блок }

| GetSQR ( 5, SqGlobal );

| WriteLn( SqGlobal, ' Флаг: ', GlobalFlag )

| END.

Рис. 6.7

Оставим ненадолго процедуры и рассмотрим функции. Идентификатор функции возвращает после вызова скалярное значение заданного типа. Для присвоения функции значения ее имя должно хотя бы однажды появиться в левой части оператора присваивания в теле самой функции. Вызов функции производится уже не обособленно, а в том месте, где необходимо значение функции (в выражениях, вызовах других подпрограмм и т.п.). Например, процедуру GetSQR на рис. 6.7 можно переписать в виде функции (рис. 6.8).

| VAR GlobalFlag : Boolean; { глобальный флаг }

| FUNCTION GetSQR( X : Real ) : Real;

| CONST SQRMAX =100;

| BEGIN

| X := X*X;

| GlobalFlag:=(X>SQRMAX);

| if GlobalFlag then X:=SQRMAX;

| GetSQR := X { возвращение значения }

| END;

Рис. 6.8

- 111 -

| BEGIN { основной (вызывающий) блок }

| WriteLn( GetSQR( 5 ), ' Флаг: ', GlobalFlag )

| END.

Рис. 6.8 (окончание)

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

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

Большое значение имеет соблюдение правил соответствия типов при подстановке параметров. Нельзя (да и не получится — компилятор не пропустит!) конструировать типы в описаниях параметров. Можно использовать только уже известные идентификаторы типов. То же самое можно сказать о типе возвращаемого значения функции. И, конечно, число и порядок следования параметров в вызове должен соответствовать описанию процедуры или функции. Кроме того, в Турбо Паскале существует правило, требующее, чтобы параметры, имеющие файловый тип (или сложный тип с файловыми компонентами), были обязательно описаны как VAR-параметры.

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

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

- 112 -

 

6.9.2. Опережающее описание процедур и функций

Текст программы транслируется в выполнимый код последовательно сверху вниз. При этом переменные, типы, константы и подпрограммы должны описываться до того, как начнутся их упоминания в операторах или выражениях. В противном случае компилятор объявит имя неизвестным, и придется перемещать описания подпрограмм вверх по тексту программы. В случаях с процедурами и функциями этого можно избежать, используя опережающее описание директивой FORWARD:

PROCEDURE ИмяПроцедуры(параметры); FORWARD;

FUNCTION ИмяФункции( параметры ) : ТипЗначения; FORWARD;

......

PROCEDURE ИмяПроцедуры; { список параметров уже не нужен }

Тело процедуры

FUNCTION ИмяФункции; { достаточно указать только имя }

Тело функции

......

Эта директива объявляет заголовок подпрограммы, откладывая описание содержимого «на потом». Местоположение этого описания уже не играет роли, и в нем можно не указывать параметры, а ограничиться лишь именем подпрограммы. Основное описание не может иметь никаких директив (FORWARD, EXTERNAL и др.).

Директива FORWARD существует в языке в основном для развязки закольцованных вызовов. Так, ситуацию на рис. 6.9 можно разрешить только с ее помощью:

PROCEDURE a( у : TypeXY ); FORWARD;

PROCEDURE b( x : TypeXY );

BEGIN

...

a(p); {процедура b вызывает a}

END;

PROCEDURE a;

BEGIN

...

b( q ); {но сама a вызывает b }

END;

Рис. 6.9

- 113 -

 

6.9.3. Объявление внешних процедур

Турбо Паскаль — язык не слишком коммуникабельный по отношению к прочим языкам. Он не поддерживает генерацию объектных файлов в формате OBJ и вследствие этого не может поставлять написанные на нем процедуры и функции для связи с другими языками. Единственное, что можно — это использовать при компиляции и компоновке программ на Турбо Паскале внешние подпрограммы в виде OBJ-файлов, созданных другими компиляторами. OBJ-файлы должны при этом удовлетворять определенным требованиям к используемой модели памяти и способу передачи значений. Гарантируется совместимость кодов, полученных компилятором Turbo Assembler. He должно быть проблем и с кодами от ассемблера MASM или ему подобных. Возможен импорт объектных кодов, полученных в Turbo C и других языках, но на практике он труднореализуем.

Команды подстыковки объектных файлов в программу на Турбо Паскале задаются директивами компилятора {$L ИмяФайла.OBJ}, установленными в подходящих местах программы. А те процедуры и функции, которые реализованы в этих файлах, должны быть объявлены своими заголовками и специальным словом EXTERNAL, например:

{$L memlib.obj} { включение объектного кода }

procedure MemProc1; external;

PROCEDURE MemProc2( X,Y : Byte ); EXTERNAL;

FUNCTION MemFunc1( X :Byte; VAR Y :Byte ): Word; EXTERNAL;

Подключенные таким образом внешние функции или процедуры в дальнейшем ничем не отличаются от написанных в тексте. Обычно директиву включения OBJ-файла и объявления внешних подпрограмм удобно размещать рядом. Порядок следования директивы $L и описаний заголовков может быть произвольным.

 

6.9.4. Процедуры и функции как параметры

Отличительной особенностью Турбо Паскаля является разрешение передавать в процедуры и функции имена других подпрограмм, оформляя их как параметры. И точно так же, как передавалось значение, может передаваться некая функция его обработки. Особенно важным это становится при программной реализации алгоритмов вычислительной математики (хотя можно назвать и ряд других областей). Например, становится возможным написать процедуру интегрирования любой функции вида f(t) по следующей

- 114 -

схеме (рис. 6.10). Неочевидным здесь может показаться только введение функционального типа и то, как он определяется.

PROCEDURE Integrate LowerLimit, UpperLimit : Real;

VAR

Result : Real;

Funct : Функциональный тип);

VAR Описание локальных переменных процедуры

t : Real;

BEGIN

Численное интегрирование по t от LowerLimit до

Upper limit функции Funct, причем для получения

значения функции при заданном аргументе t достаточно

сделать вызов Funct(t).

Результат интегрирования должен быть возвращен через

параметр-переменную Result.

END;

Рис. 6.10

Функциональный или процедурный тип (в зависимости от того что описывается) — отнюдь не тип возвращаемого значения, а тип заголовка подпрограммы в целом. Так, на рис. 6.10 параметр Func есть одноместная функция вида f(t), возвращающая вещественное значение. Класс таких функций может быть описан типом

| TYPE

RealFunctionType = function ( t : Real ) : Real;

В этом описании имя подпрограммы не ставится — оно здесь не играет роли. Но обязательно перечисляются типы параметров и, если тип описывает функцию, тип результата. Идентификаторы параметров могут быть выбраны произвольно. Основная смысловая нагрузка падает на их типы и порядок следования. Тип, к которому могла бы принадлежать процедура Integral (см. рис. 6.10), должен был бы выглядеть примерно так:

| TYPE

ProcType = procedure ( А, В : Real; VAR X : Real;

f : RealFunctionType );

а тип процедуры без параметров:

NoParamProcType = procedure;

После объявления процедурного (функционального) типа его можно использовать в описаниях параметров подпрограмм. И, ко-

- 115 -

нечно, необходимо написать те реальные процедуры и функции, которые будут передаваться как параметры. Требование к ним одно: они должны компилироваться в режиме {$F+}. Поскольку по умолчанию принят режим {$F-}, такие процедуры обрамляются парой соответствующих директив. На рис. 6.11 дан пример функции, принадлежащей введенному выше типу RealFunctionType.

| { $F+} { включение режима $F+ }

| FUNCTION SinExp ( tt : Real ) : Real;

| BEGIN

| SinExp := Sin(tt)*Exp(tt)

| END;

| {$F-} { восстановление режима по умолчанию }

Рис. 6.11

Такая функция может быть подставлена в вызов подпрограммы на рис. 6.10:

Integral( 0, 1, Res1, SinExp )

и мы получим в переменной Res1 значение интеграла в пределах [0,1]. Не всякую функцию (процедуру) можно подставить в вызов. Нельзя подставлять: во-первых, процедуры с директивами inline и interrupt (из-за особенностей их машинного представления); во-вторых, вложенные процедуры или функции; в-третьих, стандартные процедуры и функции, входящие в системные библиотеки Турбо Паскаля. Нельзя, например, взять интеграл функции синуса:

Integral(0, 1, Res2, Sin)

хотя встроенная функция Sin внешне подходит по типу параметра. Последнее ограничение легко обходится переопределением функции (рис. 6.12).

| { $F+}

| FUNCTION Sin2( X : Real ) : Real;

| BEGIN

| Sin2 := Sin( X )

| END;

| {$F-}

Рис. 6.12

- 116 -

Теперь вызов процедуры интегрирования переписывается как

Integral( 0, 1, Res2, Sin2 )

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

 

6.9.5. Переменные-процедуры и функции

Рассмотрим программу на рис. 6.13. В ней вводятся две переменные-процедуры P1 и P2 и демонстрируются возможные действия с ними.

| TYPE DemoProcType = procedure ( А,В : Word );

| VAR

| Р1, Р2 : DemoProcType; { переменные-процедуры} P : Pointer; { просто указатель }

| { Значения переменных-процедур : }

| {$F+}

| PROCEDURE Demo1( X,Y : Word );

| BEGIN WriteLn( 'x+y=', x+y ) END;

| PROCEDURE Demo2( X,Y : Word );

| BEGIN WriteLn( 'x-y=', x-y ) END;

| {$F-}

| BEGIN { основной блок программы }

| P1 := Demo1; { присваивание значений переменным }

| P2 := Demo2;

| P1( 1, 1 ); { то же самое, что и вызов Demo1(1,1) }

| P2( 2, 2 ); { то же самое, что и вызов Demo2(2,2) }

| { Ниже в указатель Р запишется адрес процедуры Р1: }

| DemoProcType( P ) := P1;

| DemoProcType(P)( 1, 1 ); { то же, что и вызов Р1(1,1) }

| { Так значение указателя Р передается переменной : }

| @P2 := Р;

| Р2( 2,2 ); { процедура Р2 в итоге стала равна Р1 }

| END.

Рис. 6.13

Процедурные переменные по формату совместимы с переменными типа Pointer и после приведения типов могут обмениваться с ними значениями. Для того чтобы переменная-процедура понималась как указатель на адрес подпрограммы в ОЗУ, она должна предваряться оператором @. Советуем не злоупотреблять операциями обмена значений таких переменных, тем более с приведениями типов. Програм-

- 117 -

мы с подобными приемами очень трудно отлаживать, и они имеют тенденцию «зависать» при малейшей ошибке.

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

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

TYPE

ProcType = ПроцедурныйИлиФункциональныйТип;

DemoRecType = RECORD

X,Y : Word;

Op : ProcType;

END;

VAR

Rec1,Rec2 : DemoRecType;

Используя такие структуры, можно хранить в них не только данные, но и процедуры их обработки. Причем в любой момент можно сменить процедуру или функцию, понимаемую под полем Op.

Обращаем внимание на еще одну особенность работы с процедурными переменными. Если надо убедиться, что процедуры или функции, понимаемые под двумя переменными, одинаковы, то операция сравнения запишется (для переменных Rec1.Op и Rec2.Op) как

IF @Rec1.Op = @Rec2.Op then ... ;

Если убрать оператор @, то при значениях полей Op, соответствующих процедурам, это будет просто синтаксически неверно, а при значениях Op, соответствующих функциям без параметров, будут сопоставляться не сами поля Op, а результаты вызовов функций.

 

6.9.6. Специальные приемы программирования

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

- 118 -

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

| TYPE

| Vector100Type = Array[1..100] of Real; {вектор }

| MatrixType = Array[1..10,1..10] of Real; { матрица }

| Matrix2Type = Array[1..50,1..2 ] of Real; { матрица }

| VAR

| V : Vector100Туре: { область памяти на 100 элементов }

| PROCEDURE P1;

| VAR M : MatrixType absolute V; { M совмещается с V }

| BEGIN

| В процедуре возможны обращения M[ i,j ], эквивалентные

| обращениям V[(i-1)*10+j]

| END;

| PROCEDURE P2;

| VAR M2 : Matrix2Type absolute V; { M2 совмещается с V }

| BEGIN

| В процедуре возможны обращения M2[ i,j ], эквивалентные

| обращениям V(i-1)*2+j]

| END;

| PROCEDURE P3;

| VAR V3 : Vector100Type absolute V; {V3 совмещается с V}

| BEGIN

| Обращения V3[i] в процедуре эквивалентны обращениям V[i]

| END;

| BEGIN

| Основной блок, содержащий вызовы P1, P2, P3 и, может быть,

| обращения к общей переменной (области памяти) V

| END.

Рис. 6.14

Здесь процедуры имеют доступ к одной и той же области данных (т.е. к ста вещественным значениям), но осуществляют его разными методами. Поскольку нельзя совмещать значения локальных переменных с локальными, как минимум одна переменная из разделяющих общую область памяти должна быть глобальной. В примере на рис. 6.14 это переменная V.

- 119 -

Описанный выше прием программирования аналогичен, по сути, объявлению общих блоков в языке Фортран и во многих случаях позволяет составлять компактные и эффективные программы.

6.9.6.2. Статические локальные переменные. Обыкновенные локальные переменные в подпрограммах всегда «забывают» свое значение в момент окончания работы соответствующей подпрограммы. А при повторном вызове стартовые значения локальных переменных совершенно случайны. И если надо сохранять от вызова к вызову какую-нибудь локальную информацию, то ни в коем случае нельзя полагаться на локальные переменные, описанные в разделах VAR процедур и функций или как параметры-значения в заголовках. Для сохранности между вызовами информация должна храниться вне подпрограммы, т.е. в виде значения глобальной переменной (переменных). Но в этом случае приходится отводить глобальные переменные, по сути, под локальные данные. Турбо Паскаль позволяет решать эту проблему, используя статические локальные переменные или, что то же самое, локальные переменные со стартовым значением. Они вводятся как типизированные константы (рис. 6.15) по тем же правилам, что и их глобальные аналоги (см. разд. 5.2.2).

| PROCEDURE XXXX( ...);

| VAR ... { обычные локальные переменные }

| CONST { статические локальные переменные }

| A : Word = 240;

| B : Real = 41.3;

| ARR : Array[-1..1] of Char=('ф', 'х', 'ц');

| BEGIN

| Тело процедуры, в котором могут изменяться значения

| A, B, Arr и других переменных

| END.

Рис. 6.15

Особенность переменных, объявленных таким образом, заключается в том, что, хотя по методу доступа они являются строго локальными, свои значения они хранят вместе с глобальными переменными (в сегменте данных). Поэтому значения переменных A, B и Arr на рис. 16.15 сохранятся неизменными до следующего вызова процедуры и после него. В них можно накапливать значения при многократных обращениях к процедурам или функциям, их можно использовать как флаги каких-либо событий и т.п.

- 120 -

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

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

PROCEDURE PDemo ( VAR V1,V2 );

FUNCTION FDemo ( A : Integer; VAR V ) : Real;

Бестиповыми могут быть только параметры-переменные (т.е. те, которые передаются как адрес, а не как значение). Объявленные выше переменные V1, V2 и V могут иметь любой тип. Через них можно передавать подпрограммам строки, массивы, записи или другие данные. Но при этом процедура или функция должна явно задавать тип, к которому внутри нее приравниваются бестиповые переменные. Рассмотрим пример функции, суммирующей N элементов произвольных одномерных числовых массивов (рис. 6.16).

| PROGRAM Demo_Sum;

| VAR

| B1 : Array [-100.. 100] of Byte;

| B2 : Array [ 0 .. 999] of Byte;

| B3 : Array [ 'a'..'z'] of Byte;

| S : String;

| {$R-} { выключаем режим проверки индексов массивов }

| FUNCTION Sum( VAR X; N : Word ) : LongInt;

| TYPE

| XType = Array [ 1..1 ] of Byte;

| VAR

| Summa : Longint; i : Word;

| BEGIN

| Summa := 0;

| for i:=1 to N do

| Summa := Summa* XType( X )[i];

| Sum := Summa

| END;

Рис. 6.16

- 121 -

| { $R+} { можно при необходимости восстановить режим }

| BEGIN

| { Заполнение каким-либо образом массивов B1, B2 и B3; }

| ...

| S := '123456789';

| { печать суммы всех значений элементов массива B1 : }

| WriteLn( Sum( B1, 201));

| { сумма элементов B2 с 100-го по 200-й включительно: }

| WriteLn( Sum( B2[100], 101));

| { сумма 10 элементов массива B3, начиная с 'b'-го : }

| WriteLn( Sum( B3['b'], 10));

| {печать суммы кодов символов строки S с '1'-го по '9'-й}

| WriteLn( Sum( S[1], 9));

| END.

Рис 6.16 (окончание)

Как видно, функция Sum не боится несовместимости типов. Но она будет корректно работать только с массивами, элементами которых являются значения типа Byte. Мы сами задали это ограничение, определив тип XType, к которому впоследствии приводим все, что передается процедуре через параметр X. Обращаем внимание на диапазон описания массива XType: 1..1. Если режим компиляции $R имеет знак минус (состояние по умолчанию), то можно обратиться к массиву с практически любым индексом i и будет получен i-й элемент, считая от первого. Мы задаем индексы 1..1 чисто в иллюстративных целях. Можно было записать

| TYPE

ХТуре = Array [ 0..65520 ] of Byte;

забронировав максимальное число элементов (описание типа без объявления переменной не влияет на потребление памяти программой). В таком случае состояние ключа компиляции $R не играет роли. Функция Sum может начать отсчитывать элементы с любого номера (см. рис. 6.16). Можно даже послать в нее строку, и ее содержимое будет принято за байты (а не символы) и тоже просуммировано. Несложно написать обратную процедуру для заполнения произвольной части различных массивов. Надо лишь, чтобы базовый тип этих массивов совпадал с тем, который вводится внутри процедуры для приведения бестипового параметра. И, конечно, вовсе не обязательно ограничиваться одними массивами. Рассмотренный пример можно распространить и на записи, и на ссылки, и на

- 122 -

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

6.9.6.4. Рекурсия. Использование рекурсии — традиционное преимущество языка Паскаль. Турбо Паскаль в полной мере позволяет строить рекурсивные алгоритмы. Под рекурсией понимается вызов функции (процедуры) из тела этой же самой функции (процедуры).

Рекурсивность часто используется в математике. Так, многие определения математических формул рекурсивны. В качестве примера можно привести формулу вычисления факториала:

и целой степени числа:

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

| FUNCTION Fact( n : Word ) : Longlnt;

| BEGIN

| if n=0

| then Fact := 1

| else Fact := n * Fact( n-1 );

| END;

и степени n числа x:

| FUNCTION IntPower( x : Real; n : Word ) : Real;

| BEGIN

| if n=0

| then IntPower := 1

| else IntPower := x * IntPower( x, n-1);

| END;

Если в функцию передаются n>0, то происходит следующее: запоминаются известные значения членов выражения в ветви ELSE (для факториала это n, для степени — x), а для вычисления неизвестных вызываются те же функции, но с «предшествующими»

- 123 -

аргументами. При этом вновь запоминаются (но в другом месте памяти!) известные значения членов и происходят вызовы. Так происходит до тех пор, пока выражение не станет полностью определенным (в наших примерах — это присваивание в ветви THEN), после чего алгоритм начинает «раскручиваться» в обратную сторону, изымая из памяти «отложенные» значения. Поскольку при этом на каждом очередном шаге все члены выражений уже будут известны, через n таких, «обратных» шагов мы получим конечный результат.

Необходимым для работоспособности рекурсивных процедур является наличие условия окончания рекурсивных вызовов (например, проверка значения изменяющегося параметра). Действия, связанные с такой проверкой, уже не могут содержать рекурсивных вызовов. Если это условие не будет выполняться, то глубина рекурсии станет бесконечной, что неизбежно приведет к аварийному останову программы.

Зачастую внесение рекурсивности в программы придает им изящность. Но всегда оно же «заставляет» программы расходовать больше памяти. Дело в том, что каждый «отложенный» вызов функции или процедуры — это свой набор значений всех локальных переменных этой функции, размещенных в стеке. Если будет, например, 100 рекурсивных вызовов функции, то в памяти должны разместиться 100 наборов локальных переменных этой функции. В Турбо Паскале размер стека (он регулируется первым параметром директивы компилятора $M) не может превышать 64К — а это не так уж много.

Несмотря на наглядность рекурсивных описаний, во многих случаях те же задачи более эффективно решаются итерационными методами, не требующими «лишней» памяти при сопоставимой скорости вычислений. Например, функция вычисления целой степени числа X может быть переписана следующим образом:

| FUNCTION IntPower(x : Real; n : Word ) : Real;

| VAR

| i : Word; m : Real;

| BEGIN

| m : = 1;

| for i:=1 to n do

| m:=m*x;

| IntPower := m

| END;

Примечательно, что даже компилятор чисто рекурсивного языка Turbo Prolog везде, где только можно, старается преобразовать рекурсию в итерационные действия.

Отметим, что в общем случае класс функций вида

- 124 -

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

В заключение несколько слов о работе оператора Exit в рекурсивных процедурах. Он срабатывает всегда на один «уровень» глубины рекурсии. Таким образом, выйти из рекурсивной подпрограммы до ее естественного завершения довольно непросто.

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

 

6.10. Модули. Структура модулей

Модуль (UNIT) в Турбо Паскале — это специальным образом оформленная библиотека определений типов, констант, переменных, а также процедур и функций. Модуль в отличие от программы не может быть запущен на выполнение самостоятельно: он может только участвовать в построении программы или другого модуля. Но в отличие от фрагментов, подключаемых к программе при компиляции директивой {$1 ИмяФайла}, модули предварительно компилируются независимо от использующей их программы. Результатом компиляции модуля является файл с расширением .TPU (Turbo Pascal Unit). Для того чтобы подключить модуль к программе (или другому модулю), необходимо и достаточно указать его имя в директиве USES.

Все системные библиотеки Турбо Паскаля реализованы как модули, и чтобы воспользоваться, например, библиотеками функций операционной системы DOS и графики Graph, нужно только указать директиву

USES

DOS, Graph;

и дальше использовать любое содержимое библиотек, как будто оно предопределено в языке.

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

- 125 -

построения собственных библиотек процедур и функций, которые впоследствии могут подключаться к разным программам, не требуя при этом никаких переделок. Во-вторых, именно модульность позволяет создавать программы практически любого размера. Дело в том, что ни программа, ни модуль, не могут произвести выполнимый код объемом более 64K, если они не используют при построении другие модули. В то же время сумма объемов модулей, составляющих программу, ограничена лишь объемом ОЗУ ПЭВМ, и то, если не используется оверлейная структура. Общая структура модуля приводится на рис. 6.17.

UNIT ИмяМодуля;

INTERFACE ← начало раздела объявлений

USES { используемые при объявлениях модули: }

Имя_Модуля1, Имя_Модуля2, ... ;

CONST Блок объявления библиотечных констант

TYPE Блок объявления библиотечных типов

VAR Блок объявления библиотечных переменных

Заголовки библиотечных процедур и (или) функций

IMPLEMENTATION ← начало раздела реализации

USES { используемые при реализации модули:}

Имя_Модуля101, Имя_Модуля202, ... ;

CONST Блок объявления внутренних констант

TYPE Блок объявления внутренних типов

VAR Блок объявления внутренних переменных

LABEL Блок описания меток блока инициализации

BEGIN

Блок инициализации модуля

END.

Рис. 6.17

Модуль разделяется на четыре части:

— заголовок модуля (UNIT имя);

— раздел объявлений или интерфейс (INTERFACE);

— раздел реализации (IMPLEMENTATION);

— раздел инициализации (между BEGIN и END).

Все блоки, составляющие эти разделы (см. рис. 6.17), являются необязательными, и могут отсутствовать (как могут и появляться неоднократно). Обязательные слова, входящие в модуль, продемонстрированы на рис. 6.18, где показан пустой модуль.

- 126 -

UNIT Пустой;

INTERFACE

IMPLEMENTATION

END.

Рис. 6.18

Обращаем внимание на отсутствие точек с запятой после ключевых слов. Если не вводится раздел инициализации, то начинающее его слово BEGIN не ставится.

Заголовок модуля вводит имя, по которому модуль будет подключаться к другим программам. Имя должно быть уникальным (не иметь повторов внутри модуля) и соответствовать имени файла (с расширением .PAS) , хранящего исходный текст модуля (а после компиляции на диск имени файла с расширением .TPU).

Имя модуля как идентификатор имеет до 64 значащих символов. Но имя файла на диске не может превышать длину в восемь символов! Тем не менее имя модуля не обязательно ограничивать восемью символами. Пусть их будет больше, но при этом первые восемь должны совпадать с именем файла. А в основной программе в директиве USES должно стоять полное имя, как и в заголовке самого модуля.

Раздел объявлений, начинающийся словом INTERFACE, содержит описания типов, констант и переменных, которые будут привноситься в программу при подключении модуля. В нем же описываются заголовки процедур и функций, составляющих собственно библиотеку подпрограмм. В разделе обявлений указываются только заголовки, потому что информация о содержимом подпрограмм модуля не нужна на этапе компиляции, а используется только при компоновке программы. Исключение составляют процедуры с директивой inline (см. разд. 14.7.2). Они могут целиком задаваться в разделе объявлений. Недопустимы заголовки с директивами interrupt (см. разд. 16.6) и forward.

Если при объявлении типов, данных или подпрограмм используются константы и типы, введенные в других модулях (библиотеках), то эти модули должны быть перечислены в директиве USES сразу после ключевого слова INTERFACE. В модулях директива USES может появляться дважды. Второй раз — в разделе реализации. Рекомендуется указывать в разделе объявлений только те модули, которые необходимы. Прочие лучше подсоединить в другом месте.

- 127 -

Раздел реализации состоит, как правило, из тел процедур и функций, объявленных в разделе объявлений. Как и в случае с опережающим описанием (forward), тела подпрограмм могут иметь сокращенный заголовок: без указания параметров. Но если заголовок дан в полном виде, то он должен в точности соответствовать данному ранее объявлению.

В разделе реализации могут быть введены свои типы, константы и переменные. Они будут считаться глобальными по отношению к подпрограммам этого раздела, а также операторам раздела инициализации (если последний имеется). В программе, подключающей модуль, объявленные при реализации данные и типы недоступны.

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

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

Раздел инициализации завершает текст модуля. Если он отсутствует, то просто ставится слово END с точкой после конца последнего тела подпрограммы раздела реализации. В противном случае ставится слово BEGIN, и далее программируются действия, которые будут произведены перед выполнением основной программы (работа скомпилированной программы всегда начинается с выполнения блоков инициализации используемых ею модулей, и лишь потом выполняется основной блок самой программы). Обычно в разделе инициализации происходит заполнение стартовыми значениями библиотечных переменных и какие-нибудь одноразовые действия, которые должны выполниться именно в начале программы. На рис. 6.19 приводится пример модуля с инициализацией.

 

6.11. Особенности работы с модулями

Порядок подключения модулей в программу, вообще говоря, существенен. Подключение модулей происходит по ходу их перечисления: слева направо. В этом же порядке срабатывают блоки инициализации. (Инициализация происходит только при работе программы. При подключении модуля к модулю инициализации не будет.) Некоторые коммерческие пакеты библиотек на Турбо Паскале, реализованные в виде модулей, требуют соблюдения определенного порядка их перечисления при подключении. Первыми обыч-

- 128 -

| UNIT Colors; { Модуль, вводящий цветовые константы }

| INTERFACE

| TYPE

| ColorType = Array[0..15] of Byte;{определено 16 цветов}

| CONST

| Black : Byte = 0; Blue : Byte = 1;

| Green : Byte = 2; Cyan : Byte = 3;

| Red : Byte = 4; Magenta : Byte = 5;

| Brown : Byte = 6; LightGray : Byte = 7;

| DarkGray : Byte = 8; LightBlue : Byte = 9;

| LightGreen : Byte = 10; LightCyan : Byte = 11;

| LightRed : Byte = 12; LightMagenta : Byte = 13;

| Yellow : Byte = 14; White : Byte = 15;

| VAR

| CurrColors: ColorType absolute Black; {текущие значения}

| PROCEDURE SetMonoColors; (настройка цветов на режим MONO}

| PROCEDURE SetColorColors; (настройка цветов в режим ЦВЕТ}

| IMPLEMENTATION

| CONST ( значения констант для режимов: }

| ColorColors : ColorType =

| (0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);

| MonoColors : ColorType =

| (0,1,7,7,7,7,7,7,7,7, 7, 7, 7, 7,15,15);

| PROCEDURE SetMonoColors;

| BEGIN

| CurrColors := MonoColors;

| END;

| PROCEDURE SetColorColors;

| BEGIN

| CurrColors := ColorColors;

| END;

| VAR

| ch : Char;

| BEGIN

| { Запрос и настройка на соответствующий режим: }

| Write('Тип Вашего монитора(Ц-цветной, М-монохромный)?');

| ReadLn( ch ):

| if ch in ['M', 'm','М', 'м']

| then

| SetMonoColors;

| END.

| Примечание: для того чтобы модуль корректно вводил константы надо, чтобы в директиве USES программы он стоял после модуля CRT.

Рис. 6.19

- 129 -

но подключают системные модули Турбо Паскаля (из библиотеки TURBO.TPL) и лишь затем все остальные, хранящиеся в виде TPU-или даже PAS-файлов.

Порядок подключения может влиять на доступность библиотечных типов, данных и даже процедур. Например, если модули U1 и U2 описывают в разделах объявлений одноименные тип T, переменную V и процедуру P, но реализуют их по-разному, то после подключения модулей директивой

USES

U1, U2;

обращения к T, V и P будут эквивалентны обращениям к содержимому библиотеки U2. Более того, если далее в основной программе эти имена объявляются заново, то они «замещают» собой имена, относящиеся к модулю. (Заметим, что повтор идентификаторов в модулях и программе не является ошибкой, но всегда будет неверным введение одинаковых имен в пределах одного модуля или программы.) Тем не менее доступ к содержимому любого модуля всегда возможен, если перед идентификатором уточнять его местонахождение, указывая имя модуля. Так, если нам нужны T, V и P именно из модуля U1, то обращаться к ним надо, как к

U1.T, U1.V и U1.P( ... ).

Переменная V из модуля U2 должна превратиться в U2.V и т.д.

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

Другой особенностью использования модулей является решение проблемы закольцованности. Иногда может возникнуть ситуация, когда модуль U1 использует что-либо из модуля U2 и в то же время U2 обращается к процедурам модуля U1. Решение подобных проблем зависит от того, в каком разделе возникла закольцованность. Если оба модуля подключают друг друга директивой USES в разделе IMPLEMENTATION, то закольцованность автоматически разрешается компилятором Турбо Паскаля. Но если хотя бы один из модулей подключает другой в разделе INTERFACE, то разрешать противоречие придется программным путем. Проблема будет решена, если ввести третий модуль и поместить в него все те типы, переменные или подпрограммы из первых двух модулей, которые ссылаются друг на друга. После этого надо их удалить из обоих исходных модулей, а взамен подключить созданный из них третий модуль.

- 130 -

Подобный прием очень часто используется для введения общих для программы и (или) нескольких независимых модулей типов, констант и переменных. Создается модуль из одних только описаний, как на рис. 6.20.

| UNIT Conmon;

| INTERFACE

| TYPE

| ComArrayType = Array [0..99] of LongInt;

| CONST

| MaxSize = 100;

| VAR

| ComArray : ComArrayType;

| Flag : Byte;

| {и т.п.}

| IMPLEMENTATION

| END.

Рис. 6.20

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

 

6.12. Система библиотечных модулей языка

В системе Турбо Паскаль определен ряд стандартных модулей TPU Они обеспечивают функции ввода-вывода, работы со строками, управления экраном дисплея, работы с принтером и т.п. В процессе работы компилятора система генерирует коды только для строк, не содержащих вызов каких-либо функций, а вместо генерации кодов для этих функций подключает (уже в процессе компоновки) соответствующий стандартный модуль. Рассмотрим назначение этих модулей подробнее:

1. SYSTEM TPU включает все стандартные процедуры и функции, которые объявлены в стандартном ANSI Паскале (Ln, Exp, Sin, Cos и т.д.), а также обеспечивает работу с командной строкой. По сути, это системная библиотека Турбо Паскаля.

2. DOS.TPU включает стандартные процедуры для работы с функциями операционной системы MS-DOS и объявления вспомогательных глобальных переменных.

3. CRT.TPU содержит библиотеку процедур, которые работают с клавиатурой и дисплеем, обеспечивая полное управление ими и получение информации об их состоянии.

- 131 -

4. PRINTER.TPU обеспечивает быстрый и легкий доступ к принтеру.

5. GRAPH.TPU дает возможность использовать более пятидесяти графических высокоуровневых процедур.

6. OVERLAY.TPU обеспечивает полную поддержку и администрирование оверлейных структур программ.

7. WIN.TPU является приложением к модулю CRT. Предоставляет новые возможности при работе с окнами.

8. TURBO3.TPU, GRAPH3.TPU обеспечивают совместимость программ, написанных на Турбо Паскале версии 3.0 и использующих его процедуры, функции и глобальные переменные. В нашей книге эти модули рассматриваться не будут.

Ряд модулей включаются в библиотеку поддержки языка Турбо Паскаль, которая именуется TURBO.TPL (Turbo Pascal Library). Состав этой библиотеки может изменяться с помощью утилиты TPUMOVER.EXE. Помните: модуль SYSTEM.TPU всегда должен быть в составе TURBO.TPL.

Подключение модулей TPU к программе осуществляется на этапе трансляции строкой примерно следующего вида:

USES

DOS, CRT, Printer;

Модуль System не надо объявлять — он включается в тело программы по умолчанию.

Многие из системных модулей вводят глобальные переменные, которые размещаются в той же области памяти (сегменте данных) что и глобальные переменные использующей модули программы. При этом уменьшается объем свободного пространства для хранения переменных (сегмент данных ограничен размером 64K). Потребление сегмента данных системными модулями показано в таблице:

Модуль -- Объем привносимых переменных

System -- 664 байт

CRT -- 20 байт

DOS -- 6 байт

Printer -- 256 байт

Overlay -- 24 байт

Graph -- 1070 байт

Turbo3 -- 256 байт

Graph3 -- 0 байт

- 132 -

 

7.1. Массивы (Array) и работа с ними

Массив — это регулярная структура данных, объявляемая специальной конструкцией языка

Array [ диапазоны индексов ] of ТипКомпонентов

Наиболее часто массив используют для хранения значений векторов, например:

VAR

V : Array [ 1..3 ] of Real;

объявляя тем самым структуру из трех значений типа Real, проиндексированных заданным диапазоном целых чисел (V[1], V[2] и V[3]). Если индексация компонентов (элементов) массива задается числовым диапазоном, как в приведенном примере, то надо соблюдать лишь два требования: во-первых, диапазон не должен принадлежать типу LongInt, т.е. он обязан «уместиться» максимум в типе Word, a во-вторых, произведение количества компонентов массива, задаваемого диапазоном индексов, на размер компонента в байтах, не может превышать 65520 байт (почти 64K). Последнее требование является общим не только для всех массивов, но и для прочих структур данных. Таким образом, могут быть описаны массивы

- 133 -

Array [9..99] of Char; { массив из 91 элемента }

Array [-10.. 10] of LongInt; { массив из 21 элемента }

Это очень удобно, так как позволяет не заботиться о приведении индексов к диапазону 1..N, как, например, приходится поступать при работе с Фортраном или некоторыми версиями Бейсика.

В общем случае ничто не обязывает объявлять диапазон индексов массива числами. В качестве индексов можно использовать любые перечислимые типы, как встроенные, так и вводимые. Индексы могут задаваться по-прежнему диапазоном, а если диапазон соответствует всему типу, то можно вместо него просто записать имя этого перечислимого типа:

TYPE

Monthtype = ( January, February, March, April, May );

ComplectType = Array [ MonthType ] of Word;

SpringType = Array [ March..May ] of Word;

VAR

Complect : ComplectType; { пять элементов типа Word }

Spring : SpringType; { три элемента типа Word }

Alpha : Array [ 'A'..'z'] of Char;

Switch : Array [Boolean] of Byte; { два элемента }

Элементы массивов будут индексироваться значениями заданных перечислимых типов или их диапазонов: Complect [January] — первый, a Spring[May] — последний элементы в своих массивах; аналогичен смысл обращений Alpha [ 'А' ] и Switch [True].

Рассмотренные массивы — одномерные, т.е. такие, у которых компоненты — скаляры. Разрешено объявлять массивы массивов:

TYPE

VectorType = Array [ 1..3 ] of Real; { вектор }

MatrixType = Array [ 1..10] of VectorType; { матрица10x3 }

Описание типа двумерного массива MatrixType могло быть записано по-другому:

TYPE

MatrixType = Array [ 1..10] of Array [ 1..3 ] of Real;

или как

MatrixType = Array [ 1..10, 1..3 ] of Real;

Последний вариант наиболее наглядно представляет описание матрицы. Количество измерений формально не ограничено, но сумма размеров всех компонентов массива не должна превосходить 64K.

- 134 -

Каждое измерение совершенно не зависит от остальных, и можно объявлять массивы с разными индексами:

VAR

M : Array [ -10..0, 'A'..'C', Boolean ] of Byte;

Эквивалентная запись:

M : Array [-10..0] of

Array [ 'A'..'C' ] of

Array [Boolean] of Byte;

Интересно, что тип элемента массива M зависит от числа указанных при нем индексов. Так,

M[0] — массив-матрица типа Array['A'..'C',Boolean] of Byte,

М[0, 'B'] — вектор типа Array[Boolean] of Byte,

M[0, 'B', False] — значение типа Byte.

Если будут использоваться различные уровни «детализации» многомерных массивов, то надо будет позаботиться о совместимости по типу. Так, при приведенном выше описании массива M нельзя реально поставить подмассив M[0] в оператор присваивания, так как это не по правилам совместимости. Надо переписать объявление типа примерно так:

TYPE

ArrayBType = Array[Boolean] of Byte;

ArrayCType = Array ['A'..'C' ] of ArrayBType;

ArrayMType = Array [-10..0] of ArrayCType;

VAR

B : ArrayBType;

C : ArrayCType;

M : ArrayMType;

и лишь после этого будут разрешены присваивания вида

M[ -1 ] := C;

B := M[ -1, 'A' ];

Подобные вопросы совместимости можно обойти, используя приведение типов, а также специальную процедуру Move Турбо Паскаля, но это будет не повышением эффективности программы, а скорее свидетельством непродуманного объявления типов в ней.

Турбо Паскаль позволяет записывать индексы не через запятую, а как бы изолировано:

M[ -3, 'B', True ] эквивалентно M[ -3 ][ 'B' ][ True ]

- 135 -

Компонентом массива может быть не только другой массив, но и запись, и указатель, и какой-либо другой тип. Если R — массив записей (RECORD), то доступ к полю каждой записи производится после указания индекса:

R[ i ].ПолеЗаписи

В памяти ПЭВМ массивы хранятся как сплошные последовательности компонентов, причем быстрее всего изменяется самый «дальний» индекс, если их несколько. В примере задания стартового значения многомерному массиву (см. разд. 5.2.2) порядок перечисления элементов (без учета скобок) соответствует порядку размещения значений в памяти. Адрес начала массива в памяти соответствует адресу его первого элемента (элемента с минимальными значениями индексов).

Турбо Паскаль имеет специальный режим компиляции, задаваемый ключом $R. Если вся программа или фрагмент ее компилировался в режиме {$R+}, то при обращении к элементам массивов будет проверяться принадлежность значения индекса объявленному диапазону, и в случае нарушения границ диапазона программа прервется с выдачей ошибки 201 (Range check Error). Напротив, в режиме {$R-} никаких проверок не производится, и некорректное значение индекса извлечет «как ни в чем не бывало» какое-нибудь значение — но, увы, не принадлежащее данному массиву. Обычно программу отлаживают в режимах $R+, а эксплуатируют при режиме $R-. Это несколько уменьшает размер ЕХЕ-файла и время его выполнения.

К двум совместимым массивам A и B применима только операция присваивания:

A := B;

которая копирует поэлементно массив B в массив A.

Всевозможные математические действия над массивами (матрицами) необходимо реализовывать самим или использовать специальные библиотеки (например, Turbo Numeric Toolbox).

Для совместимости с другими версиями Паскаля Турбо Паскаль допускает использование составных символов (. и .) вместо квадратных скобок:

M[ 0 ] эквивалентно M(. 0 .)

Кроме того, ключевое слово Array в описаниях массивов может предваряться зарезервированным словом PACKED (упакованный, сжатый):

- 136 -

VAR

X : PACKED Array [ 1..100 ] of Real;

В Турбо Паскале данные и так хранятся максимально плотно, и слово PACKED практически игнорируется. Мы рекомендуем избегать его включения в тексты программ.

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

 

7.2. Тип «запись» (Record) и оператор присоединения With

Для компактного представления комбинаций разнотипных данных их можно объединять в структуры-записи. Каждая запись состоит из объявленного числа полей. Тип «запись» определяется конструкцией

RECORD

Поле1 : ТипПоля1;

Поле2 : ТипПоля2;

...

ПолеN : ТипПоляN

END;

Если тип нескольких полей совпадает, то имена полей могут быть просто перечислены, например:

| TYPE

| PointRecType = RECORD

| x,y : Integer

| END;

После объявления в программе переменной типа «запись»

| VAR

| Point : PointRecType;

к каждому ее полю можно обратиться, указав сначала идентификатор переменной-записи, а затем через точку — имя поля: Point.x и Point.y — значения полей записи (но просто Point — уже комбинация двух значений).

- 137 -

Независимо от количества объявленных переменных данного типа, поля каждой из них будут называться одинаково, как они названы в описании типа. Поскольку имена полей «скрыты» внутри типа, они могут дублировать «внешние» переменные и поля в других описаниях записей, например:

| TYPE

| PointRecType = RECORD

| X,Y : Integer

| END;

| ColorPointRecType = RECORD

| X,Y : Integer; Color:Word

| END;

| VAR

| X, Y : Integer;

| Point : PointRecType;

| ColorPoint : ColorPointRecType;

В программе X, PointX и ColorPoint.X — совершенно разные значения. Поле записи может иметь практически любой тип (массив, другая запись, множество). Доступ к вложенным элементам таких структур осуществляется по тем же правилам, что и обычно:

Переменная_СложнаяЗапись.ЕеПоле_Запись.ПолеПоляЗаписи

или

Переменная_С_полем_массивом.ПолеМассив[i]

Порядок описания полей в определении записи задает их порядок хранения в памяти. Так, значения полей переменной ColorPoint хранятся как шесть последовательных байтов:

2 ( это X, тип Integer) + 2 ( Y, тип Integer) + 2 (для Color типа Word).

Запись может иметь вариантную часть. Это означает, что можно задать в пределах одного типа несколько различных структур. Непосредственный выбор структуры будет определяться контекстом или каким-либо сигнальным значением. Вариантные поля указываются после того, как перечислены поля фиксированные. Вариантные поля и оформляются особым образом. Рассмотрим пример описания типа VRecType — записи с вариантами.

| TYPE

| VRecType = RECORD { тип записи с вариантами }

| Number : Byte; { номер измерения длины }

| case Measure : Char of { признак единицы длины }

| 'д','Д' (inches : Word); {длина в дюймах}

| 'с','С' (cantimeters : LongInt); { длина в см }

| '?' (Comment1, Comment2 : String[16]) { тексты }

| END;

- 138 -

В данном случае в записи имеется обычное фиксированное поле Number. Другое фиксированное поле — Measure. Оно всегда присутствует в структуре записи, но параллельно с этим выполняет роль селектора (иногда его называют полем тега от английского «Tag Field»). Поле-селектор обрамляется словами CASE и OF, и за ним следует перечисление вариантов третьего поля, взятых в круглые скобки. Какой именно вариант поля будет принят при работе с записью, обозначается содержимым селектора (Measure в приведенном примере). Значения селектора, указывающие на тот или иной вариант, записываются перед соответствующими вариантами (аналогично тому, как это происходит в операторе выбора CASE). Пусть объявлена переменная VRec типа VRecType. В зависимости от содержимого поля-селектора Measure будут корректно работать поля записи, показанные в табл. 7.1.

Таблица 7.1

Важно понимать, что в любое время доступны поля только одного из всех возможных вариантов, описанных в типе (или ни одно из них). Все варианты располагаются в одном и том же месте памяти при хранении, а размер этого места определяется самым объемным из вариантов. Так, запись типа VRecType будет храниться как 36 байт (1 байт — Number, 1 байт — Measure и 2*(16+1) байт на самый длинный вариант — с типом поля String[16]) независимо от выбора варианта.

Следствием такого способа хранения вариантов является опасность наложения значений при неправильных действиях с записями:

| VAR

| VRec : VRecType;

| BEGIN

| VRec.Measure := 'Д'; { выбираем дюймы }

| VRec.Inches := 32; { запишем 32 дюйма }

{ Теперь, не изменяя значения поля Comment1, опросим его: }

| WriteLn(VRec.Comment1);

| WriteLn(VRec.Comment1);

| END.

- 139 -

Результатом будет печать значения числа 32 в формате String. Подобные ошибки никак не диагностируются, и вся ответственность ложится на программиста. Хуже того, поле-селектор — не более чем указание, какое поле соответствует его значению. Можно, игнорируя поле-селектора, обращаться к любому из полей-вариантов. Но поскольку значение для всех вариантов одно, оно будет трактоваться по-разному согласно типу каждого поля.

Несмотря на подобные неприятности, использование записей с вариантами и полем-селектором иногда очень удобно (если, конечно, не ошибаться). Например, если есть набор изделий с параметрами в различных системах измерения, то его можно представить в программе как массив записей с типом, подобным VRecType. Корректно заполнив поле каждой записи в массиве, мы можем потом легко опрашивать их: сначала значение поля селектора, а затем в зависимости от его значения один из вариантов хранения длины или комментария, например для массива AVRec из 100 записей типа VRecType:

| for i:=1 to 100 do

| case AVRec[i].Measure of

| 'д','Д' :WriteLn('Длина в дюймах ', AVRec[i].inches);

| 'с','С' :WriteLn('Длина в см ', AVRec[i].cantimeters);

| '?' :WriteLn('Нет данных из-за', AVRec[i].Comment1);

| end; {case}

Если не нужен явный указатель на использование определенного варианта, можно обойтись без поля селектора, заменив его именем любого перечислимого типа. Нужно лишь, чтобы этот тип имел элементов не меньше, чем будет вариантов. Запись VRec может быть описана иным способом:

| TYPE

| VRecType = RECORD { тип записи с вариантами }

| Number : Byte; { номер измерения длины )

| case Byte of { признак единицы длины }

| 1 : (inches : Word); { длина в дюймах}

| 2 : (cantimeters : LongInt); { длина в см }

| 3 : (Comment1, Comment2 : String[16]) { тексты }

| END;

Поля-варианты по-прежнему разделяют общую область памяти, а имя поля, записанное в программе, определяет, в каком типе будут считаны данные, т.е., как и в предыдущем случае, можно считать значение, записанное ранее в другом формате. И это никак не будет продиагностировано. Значения констант перед вариантами в задании

- 140 -

типа — чистая условность. Они могут быть любыми, но только не повторяющимися. Обычно для двух вариантов в CASE вписывают тип Boolean (значения True и False), для большего числа вариантов — любой целочисленный тип.

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

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

| TYPE

| CharArrayType = Array [1..4] of Char;

| VAR

| V4 : RECORD

| case Boolean of

| True : ( С : CharArrayType );

| False : ( B1, B2, B3, B4 : Byte );

| END;

Размер переменной V4 — четыре байта (оба варианта равны). Обращение к V4.C — это обращение к массиву из четырех символов к V4.C[1] — к первому элементу этого массива. Но одновременно можно обратиться и к ASCII-кодам элементов V4.C[1], V4.C[2], .... V4.C[4], используя поля V4.B1, V4.B2 V4.B4.

Переменная типа «запись» может участвовать только в операциях присваивания. Но поле записи может принимать участие во всех операциях, применимых к типу этого поля. Для облегчения работы с полями записей в языке вводится оператор присоединения. Его синтаксис таков:

WITH ИмяПеременной_Записи DO Оператор;

Внутри оператора (он может быть и составным) обращение к полям записи уже производится без указания идентификатора самой переменной:

| VAR

| DemoRec : RECORD X,Y : Integer END;

| ...

| WITH DemoRec DO

| BEGIN

| X:=0; Y:=120

| END; {with}

Внутри области действия оператора WITH могут указываться и

- 141 -

переменные, не имеющие отношения к записи. Но в этом случае надо следить, чтобы они не совпадали по написанию с полями записи (рис. 7.1).

| PROGRAM MAIN;

| VAR

| X, Y : Integer;

| RecXY : RECORD X,Y: Integer END ;

| BEGIN

| X:=10; Y:=20; { значения переменных X и Y }

| WITH RecXY DO BEGIN { работаем с записью RecXY }

| X := 3.14*X; { Где какой X и Y ? }

| Y := 3.14*Y

| END ; {with}

| ...

| END.

Рис. 7.1

На рис. 7.1 действия внутри оператора WITH проводятся только над полями записи RecXY. Чтобы сохранить оператор WITH и «развязать» имена X и Y, надо к переменным X и Y приписать так называемый квалификатор — имя программы или модуля (UNIT), в которой они объявлены (для этого программа должна иметь заголовок). Так, оператор присоединения с рис. 7.1 можно исправить следующим образом:

| WITH RecXY DO

| BEGIN

| X := 3.14*Main.X;

| Y := 3.14*Main.Y

| END;

и проблема исчезнет.

В случае, если одно из полей записи само является записью (и снова содержит поля-записи), можно распространить оператор присоединения на несколько полей вглубь, перечислив их через запятую. Но в этом случае внутри тела оператора можно обращаться только к последним полям:

WITH ИмяЗаписи, Поле_3апись Do

BEGIN

Обращения к именам полей Поля_3аписи,

т.е. к тем, которым предшествовала конструкция

ИмяЗаписи.Поле_3апись.

END; {with}

- 142 -

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

 

7.3. Тип «множество» (Set). Операции с множествами

Турбо Паскаль поддерживает все основные операции с множествами. Множество, если оно не является пустым, всегда содержит что-то, и говоря «множество», необходимо указывать — «чего?». В Паскале множества определяются как наборы значений из некоего скалярного (перечислимого) типа. Скалярные типы — Byte и Char вводятся языком, они — перечислимые (их элементы можно поштучно назвать) и могут служить основой для построения множеств. Если же их станет мало, то всегда можно ввести свой скалярный тип, например:

TYPE

VideoAdapterType = (MDA, Hercules, AGA, CGA, MCGA, EGA, VGA, Other, NotDetected);

и использовать переменную

VAR

VideoAdapter : VideoAdapterType;

которая может иметь только перечисленные в задании типа значения. А далее можно ввести переменную — множество из тех же значений.

В описании множества как типа используется конструкция Set of и следующее за ней указание базового типа, т.е. того скалярного типа, из элементов которого составлено множество. Способов задания множеств несколько:

TYPE

SetOfChar = Set of Char; { множество из символов }

SetOfByte = Set of Byte; { множество из чисел }

SetOfVideo = Set of VideoAdapterType;

{ множество из названий видеоадаптеров }

SetOfDigit = Set of 0..9;

{ множество из чисел от 0 до 9 }

SetOfDChar = Set of '0'..'9';

{ множество из символов '0','1',...,'9'}

SetOfVA = Set of CGA..VGA;

{ подмножество названий видеоадаптеров }

- 143 -

Как видно из примеров, можно в задании типа множества «урезать» базовый тип, задавая поддиапазон его значений. В итоге множество сможет состоять только из элементов, вошедших в диапазон.

Если перечислимый тип вводится только для подстановки его имени в Set of, то можно на нем сэкономить и перечислить значения сразу в конструкции Set of. Не забудьте круглые скобки!

TYPE

SetOfVideo = Set of (MDA, Hercules, AGA, CGA, MCGA,

EGA, VGA, Other, NоtDetected);

SetOfGlasn = Set of ('А', 'И', 'О', 'У', 'Э');

Можно опустить фазу описания типа в разделе TYPE и сразу задавать его в разделе описания переменных:

VAR

V1 : Set of ...

В Турбо Паскале разрешено определять множества, состоящие не более чем из 256 элементов. Столько же элементов содержат типы Byte и Char, и это же число является ограничением количества элементов в любом другом перечислимом базовом типе множества, задаваемом программистом. Каждый элемент множества имеет сопоставимый номер. Для типа Byte номер равен значению числа, в типе Char номером символа является его ASCII-код. Всегда нумерация идет от 0 до 255. По этой причине не являются базовыми для множеств типы ShortInt, Word, Integer, LongInt.

Множества имеют весьма компактное машинное представление: 1 — элемент расходует 1 бит. Поэтому для хранения 256 элементов достаточно 32 байт (для меньшего диапазона значений множеств цифра будет еще меньше).

Переменная, описанная как множество, подчиняется специальному синтаксису. Элементы множества должны заключаться в квадратные скобки:

SByte := [1, 2, 3, 4, 10, 20, 30, 40];

SChar := ['а', 'б','в'];

SChar := ['г'];

SVideo = [ CGA, AGA, MCGA];

SDiap := [1..4]; {то же, что [1, 2, 3, 4]}

SComp := [1..4, 5, 7, 10..20];

SCharS := ['а..п', 'р..я']; Empty := [];

Пустое множество записывается как [].

- 144 -

Порядок следования элементов внутри скобок не имеет значения так же, как не имеет значения число повторений. Например, многократное включение элемента в множество

SetVar := ['а', 'б', 'а', 'а'];

эквивалентно однократному его упоминанию.

В качестве элементов множеств в квадратные скобки могут включаться константы и переменные соответствующих базовых типов. Более того, можно вместо элементов подставлять выражения, если тип их результата совпадает с базовым типом множества:

VAR

X : Byte; S : Set of Byte;

...

X := 3;

S := [ 1, 2, X ];

S := S + [ X+1 ]; {и т.п. }

Операции, применимые к множествам, сведены в табл. 7.2.

Таблица 7.2

- 145 -

Как видно, операции над множествами разделяются на операции сопоставления множеств и операции, создающие производные множества. И те, и другие будут работать лишь в том случае, когда их операнды сопоставимы. Это означает, что в операциях могут участвовать только те множества, которые построены на одном базовом типе (так, несопоставимы множества значений типа Char и типа Byte).

Операции сопоставления всегда двухместные. Результатом операции сопоставления будет логическое значение True или False. В этом смысле они близки операциям сравнения. Рассмотрим некоторые примеры сопоставлений (в них X — обозначение переменной базового типа множества, a S — обозначение некоего непустого сопоставимого множества) (рис. 7.2).

Операция проверки вхождения в множество in бывает очень полезна при проверке попадания в диапазоны перечислимых типов:

if Ch in ['а', 'х', 'А', 'Х'] then ...

if J in [ 100..200 ] then ...

В подобных конструкциях можно указывать множество-константу

- 146 -

Рис. 7.2

справа от оператора in, не вводя промежуточных описаний переменных-множеств .

Вторая группа операций над множествами реализует математические действия над ними: объединение (сумма), разность (дополнение) и пересечение множеств. Результатом операций всегда будет множество. В табл. 7.2 указаны два множества в записи, но их может быть и больше. Некоторые примеры операций приведены на рис. 7.3. Операции объединения и пересечения не зависят от мест операндов, но

[1, 2, 3, 4, 4 ] + [ 3, 4, 4, 5, 6] даст [1, 2, 3, 4, 5, 6] ([1..6])

[ '1', '2' ] + [ '8', '9' ] даст [ '1', '2', '8', '9' ]

[ X ] + [] даст [X]

[ X ] + [ Х+1 ] + [ Х+2 ] даст [ X .. Х+2 ]

[ 1, 2, 3, 4, 4] - [3, 4, 4, 5, 6] даст [ 1, 2 ]

[ '1', '2' ] - ['8', '9'] даст [ '1', '2' ]

[ X ]-[] даст [ X ]

[] - [ X ] даст []

[ 1, 2, 3, 4, 4 ] * [3, 4, 4, 5, 6] даст [ 3, 4 ]

[ '1', '2'] * [ '8', '9' ] даст []

[ X ] * [] даст []

[ A ] * [ A, B ] * [ A, B, С ] даст [ А ]

Рис. 7.3

- 147 -

результат операции дополнения чувствителен к порядку следования, и S1-S2 не будет в общем случае равно S2-S1. Поэтому результат выражений типа S1-S2-S3 будет зависеть от порядка вычислений (слева направо или наоборот), устанавливаемых компилятором. Обычно принято вычислять слева направо, но лучше не закладывать так явно в программу особенности компиляторов, в том числе не искать «многоместных» разностей. Их лучше вычислять через промежуточные переменные.

Достоинства множеств очевидны: гибкость представления наборов значений (правда, ограниченных типов и размеров), удобство их анализа. Механизм работы с множествами Турбо Паскаля соответствует базовым математическим действиям с конечными множествами. Значения типа «множество» очень компактно кодируются, и множество из 256 элементов займет всего лишь 32 байта. Множества хорошо работают там, где нужно проводить анализ однотипных выборок значений или накапливать произвольно поступающие значения.

Недостатки множеств — это обратная сторона их достоинств. За компактность представления приходится платить невозможностью вывода множеств на экран, хотя отладчик это проделывает. Причем, эта проблема трудноразрешима, ибо отсутствует механизм изъятия элемента из множества. Довод, что и в математике такое действие не определено, малоутешителен. Можно только убедиться в его наличии в множестве. Ввод множеств возможен только по элементам, как на рис. 7.4.

| VAR

| S : Set of Char; { переменная-множество }

| C : Char; { элемент множества }

| BEGIN

| S := []; С := #0; { обнуление значений }

| while C<> '.' do begin

| { цикл до ввода '.' : }

| ReadLn( C ); { чтение символа в C и }

| S := S + [ С ] { добавление его к S }

| end ; {while}

| S := S - [ '.' ] { можно выбросить точку }

| ...

| END.

Рис. 7.4

Несмотря на эти недостатки, множества — удобный инструмент обработки данных и оптимальный для некоторых приложений способ хранения данных.

- 148 -

 

8.1. Символьный и строковый типы (Char и String)

Язык Турбо Паскаль поддерживает стандартный символьный тип Char и, кроме того, динамические строки, описываемые типом String или String[ n ].

Значение типа Char — это непустой символ из алфавита ПЭВМ, заключенный в одинарные кавычки, например, ' ', 'А', '7' и т.п. Кроме этой, классической, формы записи символов, Турбо Паскаль вводит еще две. Одна из них — представление символа его кодом ASCII с помощью специального префикса # :

#97 = Chr(97) = 'а' (символ 'а'),

#0 = Chr(0) (нулевой символ),

#32 = Chr(32) = ' ' (пробел).

Символы, имеющие коды от 1 до 31 (управляющие), могут быть представлены их «клавиатурными» обозначениями — значком «^» и буквой алфавита с тем же номером (для диапазона кодов 1...26) или служебным знаком (для диапазона 27...31):

^A = #1 = Chr(1) – код 1,

^B = #2 = Chr( 2) – код 2,

...

^ = #26 = Chr(26) – код 26.

^[ = #27 = Chr(27) – код 27,

…

^_ = #31 = Chr(31) – код 31,

в том числе ^G — звонок (7), ^I — TAB (код 9), ^J — LF (код 10), ^M — CR (код 13) и т.п.

Рассмотрим более подробно строковый тип. Максимальная длина строки составляет 255 символов. Строки называются динамическими, поскольку могут иметь различные длины в пределах объявленных границ. Например, введя переменные

- 149 -

VAR

S32 : String[ 32];

S255 : String[255];

мы можем хранить в S32 строчные значения, длиной не более 32 символов, а в S255 — не более 255. Описание String без указания длины отводит место, как и описание String[255].

Тип String без длины является базовым строковым типом, и он совместим со всеми производными строковыми типами.

При попытке записать в переменную строку длиннее, чем объявлено в описании, «лишняя» часть будет отсечена. Можно присваивать пустые строки. Их обозначение (две одинарные кавычки подряд).

Значением строки может быть любая последовательность символов, заключенная в одинарные кавычки:

'abcde-абвгд'

'123 ? 321'

' '

''''

Последняя конструкция есть строка из одной одинарной кавычки.

При необходимости включать в строку управляющие коды можно пользоваться «клавиатурными» обозначениями. В этом случае значение состоит из как бы склеенных кусков:

^G 'После сигнала нажмите '^J' клавишу пробела '^M^J

В такой записи не должно быть пробелов вне кавычек.

Более общим способом включения символов (любых) в строку является их запись по ASCII-коду через префикс #. Механизм включения в строку остался тем же:

'Номер п/п'#179' Ф.И.О. '#179' Должность '#179

#7#32#179#32#32#179 (то же, что ^G'| |')

Строки различных длин совместимы между собой в операторах присваивания и сравнения, но «капризно» ведут себя при передаче в процедуры и функции. Если тип объявленного строкового параметра в процедуре или функции является производным от типа String, то при вызове процедуры или обращении к функции тип передаваемой строки должен совпадать с типом параметра. Имеется ключ компилятора $V, управляющий режимом проверки типов соответствующих формальных и фактических параметров-строк. В режиме {$V+} такая проверка проводится и при несогласованности типов выдает сообщение об ошибке. Но если отключить ее, то можно подстав-

- 150 -

лять в вызовы процедур и функций фактические параметры, имеющие другой, отличающийся от формальных, производный от String тип. При этом во время работы программы могут возникнуть наложения значений одних строк на другие и путаница в значениях. Для того чтобы писать процедуры, работающие со строками любых строковых типов, нужно описывать формальные параметры исключительно типом String и компилировать программу в режиме {$V-}. Это даст процедурам и функциям гибкость и безопасность данных.

При описании параметров производным строковым типом нельзя конструировать типы в описаниях процедур (функций). Например, объявление

FUNCTION Xstr( S : String[32] ) : String[6];

совершенно неправильно. Корректно оно выглядит таким образом:

TYPE

String32 = String[32];

String6 = String[6];

...

FUNCTION Xstr( S : String32 ) : String6;

Можно, вообще говоря, рассматривать строки как массив символов. Турбо Паскаль разрешает такую трактовку, и любой символ в строке можно изъять по его номеру (рис. 8.1).

| VAR

| i : Byte;

| S : String[20];

| BEGIN

| S := 'Массив символов.....';

| for i:=1 to 20 do WriteLn( S[i]);

| ReadLn {Пауза до нажатия клавиши ввода}

| END.

Рис. 8.1

Отдельный символ совместим по типу со значением Char. Иными словами, можно совершать присваивания, представленные на рис. 8.2.

Каждая строка всегда «знает», сколько символов в ней содержится в данный момент. Символ S[0] содержит код, равный числу символов в значении S, т.е. длина строки S всегда равна Ord(S[0]). Эту особенность надо помнить при заполнении длинных строк

- 151 -

| VAR

| ch : Char;

| st : String;

| BEGIN

| st := 'Hello';

| ch := st[1]; { ch = H }

| st[2] := 'E'; { st = 'HEllo' }

| ch := 'x';

| st := ch; { st = 'x' }

| END.

Рис. 8.2

одинаковым символом. В самом деле, не писать же в программе S := '... и далее, например, 80 пробелов в кавычках! Проблему заполнения решает встроенная процедура FillChar:

VAR St : String;

...

FillChar( St[1], 80, ' ' );

St[0] := Chr(80); {!!!}

Здесь St[1] указывает, что надо заполнять строку с первого элемента. Можно начать заполнение и с любого другого элемента. В данном случае строка заполняется с начала 80 пробелами (' ' или #32). Очень важен последующий оператор: так как строка «закрашивается» принудительно, ей надо сообщить, сколько символов в ней стало, т.е. записать в St[0] символ с кодом, равным ее новой длине.

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

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

 

8.2. Операции над символами

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

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

- 152 -

'R' = 'R'

'r' > 'R' (код 114 > кода 82)

Операции сравнения записываются традиционным способом:

<, <=, =, >=, >, <>.

Каждый символ можно рассматривать как элемент множества Set of Char и применять к нему операцию проверки на включение in:

Var Ch : Char;

. . .

ch := 'a';

if Ch in ['a'..'z'] then . . .

К символьным значениям и переменным могут быть применены также функции, приведенные в табл. 8.1.

Таблица 8.1

Функции Succ и Pred хороши для последовательного перебора символов. Следует только помнить, что не определены значения Succ(#255) и Pred(#0).

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

 

8.3. Операции над строками

Строки можно присваивать, сливать и сравнивать. Слияние строк записывается в естественном виде (рис. 8.3). Если сумма получается длиннее, чем описанная длина левой части оператора присваивания, излишек отсекается.

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

- 153 -

| VAR

| S1, S2, S3 : String;

| BEGIN

| S1 := 'Вам ';

| S2 := 'привет';

| S3 := S1 + S2; { S3 = 'Вам привет' }

| S3 := S3 + ' !'; { S3 = 'Вам привет !' }

| END.

Рис. 8.3

'abcd' = 'abcd' --> TRUE,

'abcd' <> 'abcde' --> TRUE,

'abcd' <> ' abcd' --> TRUE.

Если при посимвольном сравнении окажется, что один символ больше другого (его код больше), то строка, его содержащая, тоже считается большей. Остатки строк и их длины не играют роли. Любой символ всегда больше «пустого места»:

'abcd' > 'abcD' ( так как 'd'>'D' ),

'abcd' > 'abc ' ( так как 'd'>' ' ),

'aBcd' < 'ab' ( так как 'B'<'b' ),

' ' > '' ( так как #32 > '' ).

Можно, конечно, использовать нестрогие отношения: >= и <=.

Для работы со строками реализовано большое количество процедур и функций (табл. 8.2):

Таблица 8.2

- 154 -

 

8.3.1. Редактирование строк

Функция Length(S : String) возвращает текущую длину строки S. Вообще говоря, можно вместо нее пользоваться конструкцией Ord( S[0] ), что то же самое.

Функция Concat производит слияние переданных в нее строк. Вместо нее всегда можно пользоваться операцией «+»:

S3 := Concat( S1,S2 ); { то же, что S3 := S1 + S2 }

S3 := Concat( S3,S1,S2 ); { то же, что S3 := S3 + S1 + S2 }

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

8.3.1.3. Функция Сору(S : String; Start, Len : Integer) позволяет выделить из строки последовательность из Len символов, начиная с символа Start. Если Start больше длины всей строки S, то функция вернет пустую строку, а если Len больше, чем число символов от Start до конца строки S, то вернется остаток строки S от Start до конца. Например:

SCopy = Сору( 'АВС***123', 4, 3 ) { SСору='***' }

SCopy = Copy( 'ABC', 4, 3 ) { SCopy=' '}

SCopy = Copy( 'ABC***123', 4,11 ) { SCopy='***123' }

- 155 -

Используя процедуру Copy, построим игровой пример появления строки на экране (рис. 8.4).

| USES CRT; { используется модуль CRT }

| { Процедура выводит строку S в позиции (X,Y), }

| { с эффектом раздвижения и звуковым сигналом. }

| PROCEDURE ExplodeString(X,Y: Byte; S: String; С: Word );

| VAR

| i,L2 : Byte;

| BEGIN

| L2 := (Length(S) div 2 ) + 1; { середина строки }

| if X < L2 then

| X:=L2; { настройка X }

| for i:=0 to L2-1 do

| begin { цикл вывода: }

| GotoXY( X-i, Y ); { начало строки }

| { Вывод расширяющейся центральной части строки: }

| Write( Copy( S, L2-i, 2*i+1 ));

| Sound(i*50); { подача звука }

| Delay(С); { задержка С мс }

| NoSound { отмена звука }

| end { конец цикла }

| END;

| { ========= ПРИМЕР ИСПОЛЬЗОВАНИЯ ПРОЦЕДУРЫ ======== }

| BEGIN

| ClrScr; { очистка экрана }

| ExplodeString( 40, 12, '12345678900987654321', 30);

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.4

8.3.1.4. Процедура Delete( VAR S : String; Start, Len : Integer ) видоизменяет сроку S, стирая Len символов, начиная с символа с номером Start:

S := 'СТРОКА';

Delete(S, 2, 4); {S='CA'}

После стирания подстроки ее оставшиеся части как бы склеиваются.

Если Start=0 или превышает длину строки S, то строка не изменится. Также не изменит строку значение Len=0. При Len, большем чем остаток строки, будет удалена подстрока от Start и до конца S. Это можно использовать при «подрезании» строк до заданной величины:

- 156 -

Delete( S, 16, 255)

Здесь строки S длиною менее 17 символов пройдут через процедуру неизменными, а все остальные будут укорочены до длины в 16 символов.

8.3.1.5. Процедура Insert( Subs : String; VAR S : String; Start: Integer) выполняет работу, противоположную той, что делает Delete. Insert вставляет подстроку Subs в строку S, начиная с позиции Start:

S: = 'Начало-конец';

Insert( 'середина-', S, 8 );

{ теперь S = 'Начало-середина-конец' }

Если измененная строка S оказывается слишком длинной, то она автоматически укорачивается до объявленной длины S (при этом, как всегда, «теряется» правый конец).

Пример использования пары процедур Insert и Delete можно увидеть на рис, 8.5, где приводится функция создания строки с текстом посередине.

| { Функция возвращает строку длиной Len, заполненную символом Ch, со вставленной в середину подстрокой S }

| FUNCTION CenterStr( S: String; Len: Byte; Ch: Char ) : String;

| VAR

| fs : String; { промежуточная строка-буфер }

| ls, l2 : Byte; { вспомогательные переменные }

| BEGIN

| FillChar(fs[1], Len, Ch); { заполнение строки fs Ch }

| fs[0] := Chr( Len ); { восстановление длины fs }

| ls := Length( S ); { длина входной подстроки S }

| if ls>=Len then

| begin { если некорректны параметры}

| CenterStr:=S; Exit { то ничего с S не делается }

| end ;

| l2 := ( Len-ls } div 2 +1;{место начала вставки в fs }

| Delete( fs, l2, ls ); {очистка места в центре fs }

| Insert( S, fs, l2 ); {и вставка туда строки S }

| CenterStr := fs {итоговое значение функции }

| END;

| {=== ПРИМЕР ВЫЗОВА ФУНКЦИИ ===}

| BEGIN

| WriteLn(CenterStr( 'Работает!', 80, '='));

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.5

- 157 -

8.3.1.6. Функции Pos(Subs, S : String) : Byte возвращает номер символа в строке S, с которого начинается включение в S подстроки Subs. Если же S не содержит в себе Subs, то функция вернет 0. Пример использования функции дан на рис. 8.6, где построена модификация процедуры преобразования Str.

| { Процедура преобразования числа X в строку S}

| { Вход : X — числовое значение; }

| { F — полная длина поля числа; }

| { N — число цифр после запятой. }

| { Выход: строка S, в которой предшествующие }

| { числу пробелы заменены на 0. }

| PROCEDURE ZStr( X : Real; F,N : Byte; VAR S : String );

| VAR p : Byte;

| BEGIN

| Str( X:F:N, S ); { строка с пробелами }

| { Цикл замены пробелов на нули : }

| while Pos(' ', S) > 0 do S[Pos(' ', S)] := '0';

| p := Pos('-',S); { позиция минуса в числе }

| if р <> 0 then begin

{ Если минус имеется, то }

| S[p] := '0'; S[1] := '-' { переместить его в нача-}

| end ; { ло строки S. }

| END;

| { ======= ПРИМЕРЫ ВЫЗОВОВ ФУНКЦИИ ======= }

| CONST

| r : Real = 123.456;

| b : Byte = 15;

| i : Integer = -3200;

| St : String = ' ';

| BEGIN

| ZStr( r, 10, 5, St ); WriteLn( St ); { 0123.4560 }

| ZStr{ b, 10, 1, St ); WriteLn( St ); { 0000015.0 }

| ZStr( i, 10, 0, St ); WriteLn( St ); { -00003200 }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.6

Очевидным недостатком функции Pos является то, что она возвращает ближайшую стартовую позицию Subs в S от начала строки, т.е. вызов

P := Pos( 'noo', 'Boonoonoonoos');

завершит свою работу, вернув значение 4, хотя есть еще и 7, и 10.

- 158 -

На рис. 8.7 приведен вариант функции, использующей функцию Pos и возвращающей позицию любого вхождения Subs в S, если оно существует.

| { Функция возвращает номер символа, с которого начинается N-e вхождение подстроки Subs в строку S. Одновременно возвращается общее число вхождений Count. При неудаче поиска функция возвращает значение 0. }

| FUNCTION PosN( Subs, S : String; N : Byte;

| VAR Count : Byte ) : Byte;

| VAR

| p, PN : Byte; { вспомогательные переменные }

| BEGIN

| Count:=0; PN:=0;

| repeat { Цикл по вхождениям : }

| p := Pos( Subs, S ); { поиск вхождения }

| if Count

| Inc( Count ); { счетчик вхождений }

| Delete( S, 1, p ) { уменьшение строки }

| until p=0; { конец цикла, если р=0 }

| Dec( Count ); { надо уменьшить Count }

| if N<=Count { N не больше, чем Count? }

| then PosN := PN {Да, возвращаем позицию }

| else PosN := 0; { Нет, возвращаем 0 }

| END;

| VAR { ===== ПРИМЕР ВЫЗОВА ФУНКЦИИ ===== }

| C : Byte; {количество вхождений подстроки в строку }

| BEGIN

| WriteLn('3-я позиция noo в Boonoonoonoos начинается',

| ' с символа ', PosN('noo','Boonoonoonoos',3,С):3);

| WriteLn( 'Всего найдено вхождений : ', С );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 8.7

 

8.3.2. Преобразование строк

8.3.2.1. Процедура Str( X [: Width [: dec ] ]; VAR S : String)

служит для преобразования числовых значений в строковые. Это, в частности, необходимо для работы с процедурами модуля Graph OutText и OutTextXY. X может быть переменной или значением целого или вещественного типов. Можно задавать поля формата, указывая ширину поля для числа и число знаков после десятичной

- 159 -

точки. Для целых значений можно задать только поле Width, для вещественных — либо оба поля (формат с фиксированной точкой), либо одно — Width. В последнем случае задается экспоненциальный формат общей длиной Width. Напомним, что экспоненциальный формат чувствителен к использованию сопроцессора. Так, для поля Width, равного 13, будем иметь

в режиме {$N-}: -1.234567E+10,

в режиме {$N+}: -1.2346Е+0010.

Если число имеет меньше знаков, чем дано в поле, то оно будет выровнено по правому краю, пустое место заполнится пробелами. Можно задать поле Width отрицательным, в этом случае выравнивание происходит по левому краю, а излишки как бы стираются:

Str(6.66 : 8 : 2, S); { S=' 6.66' }

Str(6.66 : -8 : 2, S); { S='6.66' }

Str(6.66 : 8 : 0, S); { S=' 7' }

Можно задать значения полей формата целочисленными переменными или константами:

VAR

F, n : Integer;

S : String;

...

F:=-5; n:=1;

Str( -123.456 : F : n, S);

Возможность задания поля константой решает проблему экспоненциального формата для случаев использования математического сопроцессора. Достаточно применить команды условной компиляции:

{$IFOPT N+}

CONST FORMAT_E =14; { формат: +n.nnnnnE+NNNN }

{$ELSE}

CONST FORMAT_E =12; { формат: +n.nnnnnE+NN }

{$ENDIF}

...

Str(x : FORMAT_E, S);

Теперь формат будет устанавливаться при компиляции в зависимости от режима использования сопроцессора.

Последнее замечание: если формат с точкой ограничивает число знаков в дробной части, то она будет округлена при преобразовании:

Str(1.234567:6:4, S); {S='1.2346'}

Само значение числа при этом не изменится.

- 160 -

8.3.2.2. Процедура Val(S : String; VAR V; VAR ErrCode : Integer) преобразует числовые значения, записанные в строке S в числовую переменную V. Если преобразование возможно, то переменная ErrCode равна нулю, в противном случае она содержит номер символа в S, на котором процедура застопорилась. Тип V должен соответствовать содержимому строки S. Если в S имеется точка или степень числа Е+nn, то V должна быть вещественного типа, в остальных случаях может быть и целой. Массу сложностей доставляют проблемы переполнения: если S='60000', a V в вызове процедуры будет подставлена типа Byte, то что получится в итоге?

Возможны два варианта. Первый — при работе программы проверяются диапазоны и индексы (режим $R+); при переполнении возникнет фатальная ошибка счета, и программа прервется. Второй — проверка отключена (режим $R-); все зависит от типа V: если он вещественный или LongInt, то при переполнении ErrCode<>0, a V содержит числовой «мусор». Но если V имеет тип «короче» чем LongInt, то ErrCode при переполнении молчит (равно 0), а в V записывается результат переполнения, мало похожий на содержимое S. Не слишком «прозрачно», не так ли? В техническом описании языка после изложения всего этого дается совет, как обойти все эти условности. При преобразовании строк с целыми числами рекомендуется на место V подставлять переменную типа LongInt. Пусть надо перевести строку S с целым значением в переменную WordV типа Word. Схема будет такой:

{$r-}

VAR LongV : LongInt; WordV : Word;

…

WordV := 0; { начальная очистка WordV }

Val( S, LongV, ErrCode }; { вызов преобразования }

if ErrCode=0

then begin { в S записано число }

if ( LongV >= 0 ) and ( LongV <= 65535 )

then { Все в порядке! }

WordV := LongV

else { Иначе несовместимость! }

WriteLn('Ошибка диапазона при преобразовании ',LongV );

end {then}

else { содержимое S не годится }

WriteLn('Ошибка в строке ',S,' в символе ',S[ErrCode]);

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

- 161 -

 

9.1. Базовые операции

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

В сложных выражениях порядок, в котором выполняются операции, соответствует приоритету операций (табл. 9.1).

Таблица 9.1

Первый (высший) приоритет

Унарные операции

- 162 -

Второй приоритет

Бинарные операции

Третий приоритет

Бинарные операции

- 163 -

Четвертый (низший) приоритет

Бинарные операции

Примечания:

1. Под вещественными понимаются тип Real и вещественные типы, поддерживаемые математическим сопроцессором (типы с повышенной точностью).

2. Под целыми понимаются целочисленные типы языка.

3. В таблице указан оператор @, не имеющий никакого отношения к математике. Он включен только для показа его приоритета.

При вычислениях сначала применяются операции наивысшего порядка, затем более низкого. Операции равного приоритета вычисляются слева направо:

2*3/4/5 = ((2 * 3)/4)/5

Применение скобок позволяет явно расставлять приоритеты и менять порядок вычислений.

Значение выражения X/Y всегда будет вещественного типа, независимо от типов операндов. Если Y равно 0, то произойдет фатальная ошибка (номер 200) и останов программы.

- 164 -

Значение выражение i div j представляет собой математическое частное i/j, округленное в меньшую сторону до значения целого типа. Если j равно 0, то результатом будет фатальная ошибка.

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

i mod j = i - (i div j) * j

Знак результата операции mod будет тем же, что и знак i. Если j равно нулю, то результатом будет фатальная ошибка.

 

9.2. Битовая арифметика

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

Битовая арифметика хорошо развита в языке Турбо Паскаль. Необходимость в ее применении возникает, когда надо работать не с десятичными значениями чисел, а с их двоичным представлением. В этом случае можно сравнивать отдельные биты двух чисел, выделять двоичные фрагменты, заменять их и т.п. Это часто используется при работе с видеопамятью в текстовом или графическом режимах. Кроме того, есть ряд чисто математических задач, которые удобно решать в двоичном представлении.

Ограничение на битовые операции одно: они должны применяться только над целыми типами — Byte, ShortInt, Word, Integer, LongInt и совместимыми с ними. Именно эти типы кодируют значения в правильные двоичные числа, как в школьном учебнике по информатике. (То, что в памяти некоторые целые типы хранят свои байты значений в обратном порядке, никак не влияет на поразрядные действия и логику работы с ними. Все особенности учитываются самими поразрядными операциями, и мы можем о них даже не вспоминать.) Например, значения 4 и 250 типа Byte представляются как двоичные наборы 00000100 и 11111010, число 65535 типа Word — это уже 16 бит: 11111111 11111111 и т.д.

Общая формула для значений типов Byte и Word имеет вид

Byte : Значение = B7*27 + B6*2б + B5*25 +...+ B1*2* + B0;

Word : Значение = B15*215 + B14*214+...+B7*27 +...+ B0.

Множители B0, B1 и т.п. — это значения соответствующих битов, равные либо 0, либо 1, а числовые множители — это 2 в степени номера бита.

- 165 -

Внутреннее отличие имеют представления целых типов со знаком: ShortInt, Integer и LongInt. По размеру тип ShortInt равен типу Byte, a Integer — типу Word. Но они могут хранить отрицательные целые числа, правда, меньшие по абсолютному значению чем 255 и 65535:

ShortInt : -128 ..127 ( 8 бит ),

Integer : -32768 .. 32767 ( 16 бит ),

LongInt : -2147483648 .. 2147483647 ( 32 бит ).

Самый левый бит в представлении отрицательного числа всегда равен 1, если значение отрицательное, и 0 в противном случае. Формула перевода битов в значение для типов ShortInt, Integer, LongInt такова:

Shortlnt : Знач= -B7*27 + B6*26 + B5*25 +...+ B1*21 + B0;

Integer : Знач=-B15*215 + B14*214+...+B7*27 +...+ B0;

LongInt : Знач=-B31*231 + B30*230+...+B15*215 +...+ B0;

Примеры кодировки отрицательных чисел для типа ShortInt (бит знака числа отделен здесь пробелом) :

-1 :1 1111111 ( -1*128 + 127 )

-2 : 1 1111110 ( -1*128 + 126 )

-3 : 1 1111101 ( -1*128 + 125 )

-125 : 1 0000011 ( -1*128 + 3 )

-128 : 1 0000000 ( -1*128 + 0 )

Если в кодировании положительных значений абсолютное значение числа тем больше, чем больше единиц в его записи, то для отрицательных значений нули и единицы как бы поменяются местами — и абсолютное значение числа тем больше, чем больше будет в записи нулей. Поэтому, например, двоичное представление того же числа -128 в формате Integer (это уже 16 бит) будет 11111111 10000000.

Вещественные типы кодируются каждый раз по-разному, но всегда достаточно сложно: одна группа битов составляет мантиссу числа, вторая — порядок, да еще знак... Битовые операции к вещественным числам (типам) не применяются.

Посмотреть двоичную форму представления целых чисел можно с помощью функции (рис. 9.1). Операции shl и shr из примера на рис. 9.1 будут рассмотрены чуть позже.

- 166 -

| { ФУНКЦИЯ ПЕРЕВОДА ЦЕЛОГО ЧИСЛА В ДВОИЧНОЕ ПРЕДСТАВЛЕНИЕ}

| { X - целое число (можно передавать и другие типы ) }

| { NumOfBits - число позиций в двоичном представлении }

| FUNCTION Binary( X:LongInt; NumOfBits : Byte ) : String;

| VAR

| bit, i : Byte; { вспомогательные переменные }

| s : String[32];

| BEGIN

| s: = ' '; { обязательная чистка строки }

| for i:=0 to 31 do begin { цикл перевода }

| bit := ( X shl i ) shr ( 31 ); { выделение бита }

| s := s + Chr( Ord( '0' ) + bit ) { запись в строку }

| end ; { for } { конец цикла }

| Delete( s, 1, 32-NumOfBits ); { отсечение лишних битов}

| Binary := s { возвращаемая строка }

| END;

| VAR i : Integer; {=== ПРИМЕР ВЫЗОВА === }

| BEGIN

| for i:=-5 to 5 do

| WriteLn(i:7, '--> ', Binary( i, 8*SizeOf(i)));

| Readln { пауза до нажатия клавиши ввода }

| END.

Рис. 9.1

Итак, какие же действия предоставляет поразрядная арифметика? Первая группа — это логические операции над битами (табл. 9.2).

Таблица 9.2

Not — поразрядное отрицание — «переворачивает» значение каждого бита на противоположное. Так, если A в двоичном виде представляется как 01101100, то not A станет 10010011:

not [1] = 0

not [0] = 1

Квадратные скобки вокруг аргументов обозначают действие над одним битом.

- 167 -

And — так называемое логическое умножение или поразрядная операция 'И':

[0] and [1] = [1] and [0] = [0]

[0] and [0] = [0]

[1] and [1] = [1]

Здесь аргументы специально взяты в скобки — их надо рассматривать как отдельные единичные биты; реальные же примеры не столь очевидны:

(6 and 4) = 4

(6 and 1) = 0

и т.п. Все станет ясно, если 6 и 4 представить как двоичные числа:

0000110 (6) 0000110 (6)

and 0000100 (4) и and 0000001 (1)

______________ ______________

0000100 (4) 0000000 (0)

Впрочем, вовсе не обязательно записывать числа в виде нулей и единиц. Операция and в 99% случаев нужна для двух целей: проверить наличие битов или убрать ( т.е. обнулить) некоторые из них.

Такая проверка нужна, когда число является набором флагов. Например, большое число системных ячеек памяти ПЭВМ содержит сведения о конфигурации машины или ее состоянии. При этом один байт может трактоваться так: бит 6 равен 1 — значит включен режим CapsLock, бит 4 равен 0 — следовательно какой-либо другой режим Lock выключен и т.д. Пусть A содержит этот самый байт с восемью флагами, и надо проверить состояние бита номер 5 (нумерация идет справа налево, от 0 до 7). Единица в бите 5 дает число 25 = 32. Это второй аргумент. Если в A в пятом бите есть единица, то должно выполниться условие

( A and 32 ) = 32

Осталось оформить все это в оператор IF. Можно проверить наличие сразу нескольких «включенных» битов, например, 5-го, 2-го и 0-го. Число с единицами в этих позициях и нулями в остальных равно 2+2 + 1 = 32+4+1 = 37. Если A среди прочих имеет единицы в битах 5, 2 и 0, то в этом случае будет истинным выражение

( A and 37 ) = 37

Исключение или выключение битов достигается следующим образом. Пусть надо исключить бит 3 из переменной A типа Byte (здесь важно знать тип, в который «умещается» текущее значение A). Исключить — значит, задать нулем. Первым делом определяется

- 168 -

число, в котором все биты равны 1, кроме бита номер 3. Для типа Byte оно равно (255 – 23) = 247, где 255 — максимальное значение, вписываемое в байт. Если теперь это число логически умножить на A, то единицы в 247 никак не повлияют на состояние битов в переменной A, а ноль в третьем бите заместит любое значение в A на том же месте. Таким образом, можно записать

A := A and (255 – 8);

чтобы получить значение A с отключенным 3-м битом.

Все это верно и для нескольких битов сразу: если надо исключить биты 3 и 7, то просто запишем

A := A and (255 – 8 – 128);

где 8 = 23 и 128 = 27.

Or — логическое сложение; оно же операция 'ИЛИ', определяется следующими действиями над битами:

[1] or [0] = [0] or [1] = [1]

[0] or [0] = [0]

[1] or [1] = [1]

Квадратные скобки обозначают один бит. Эта операция может с успехом применяться при включении (установки в 1) отдельных битов двоичного представления целых чисел. Так, если надо, чтобы бит 4 значения A стал равным единице, а остальные не изменились, то следует записать

A := A or 16;

где 16 = 24 . При этом не имеет значения, что было в 4-м бите значения A. В любом случае там появится единица.

Аналогичным образом можно включать сразу несколько битов, например, 4-й, 1-й и 0-й:

A := A or (16 + 2 + 1);

Кроме перечисленных, введена еще одна операция xor — исключающее 'ИЛИ' (математическое название — «сложение по модулю 2»). Эта операция возвращает 0, если оба ее аргумента равны, и 1 в противном случае:

[1] xor [1] = [0]

[0] xor [0] = [0]

[1] xor [0] = [0] xor [1] = [1]

Операцию xor можно с успехом применять при смене значения бита (или нескольких битов) на противоположные. Пусть необходимо

- 169 -

переключить состояние бита 5 числа А. Это будет сделано операцией A xor 32 , где 32 = 25.

Исключающее 'ИЛИ' обладает одной особенностью: примененное дважды к одной и той же переменной, оно восстановит ее исходное значение, т.е. всегда выполняется равенство:

A = ( A xor B ) xor B

Следующая группа поразрядных операций — циклические сдвиги (табл. 9.3).

Таблица 9.3

Приоритет операций shl и shr одинаков и среди всех остальных невысок (см. табл. 9.1). Поэтому, как правило, выражения сдвига должны быть заключены в скобки.

Суть операций shr и shl одинакова: они сдвигают двоичную последовательность значения A на N ячеек (битов) вправо или влево. При этом те биты, которые «уходят» за край разрядности (8, 16 и 32 в зависимости от значения A), теряются, а освободившееся место с другой стороны заполняется нулями (всегда при сдвиге влево и иногда вправо) или единицами (только при сдвиге вправо отрицательных значений типа ShortInt, Integer и LongInt). Например, число с двоичным представлением 11011011 будет трансформироваться при сдвигах влево следующим образом:

( 11011011 shl 0 ) = 11011011

( 11011011 shl 1 ) = 10110110

( 11011011 shl 2 ) = 01101100

( 11011011 shl 3 ) = 11011000

( 11011011 shl 4 ) = 10110000

...

( 11011011 shl 7 ) = 10000000 ( 11011011 shl 8 } = 00000000

Если бы число имело значение типа Word от 256 до 65535, то эффект был бы тем же, только биты «переезжали» бы в поле длиной 16 бит. Для LongInt поле составит 32 бита. При применении операций shl и shr к отрицательным величинам типов ShortInt, Integer, LongInt освобождаемое слева место заполняется единицами.

- 170 -

Конечно, операции сдвига достаточно специфичны и реально нужны только при обработке битовых последовательностей. Пример их использования был дан на рис. 9.1. Там каждый бит последовательно сдвигается к самому левому краю, стирая тем самым все впереди стоящие биты, а затем возвращается в самую правую позицию, стирая тем самым все стоящие правее его биты. В итоге получаем число, равное 0 или 1, в зависимости от содержимого очередного бита.

Операция shl может заменять умножение целых чисел на степени двойки:

J shl 1 = J*2

J shl 2 = J*4

J shl 3 = J*8

Сжатие и кодирование информации. Обычная емкость памяти ПЭВМ (640K) — не так уж велика, как может показаться. Часто вопросы эффективного хранения данных становятся важными для работоспособности программ. Пусть, к примеру, нужно хранить в памяти выборку целых чисел со значениями от 0 до 15, состоящую из 80000 чисел. Так как минимальный тип для каждого числа применительно к Турбо Паскалю — Byte, то всего понадобится 80000 байт. Массив на 80000 байт не пропустит компилятор (максимум, что он сможет «переварить», — это 64K). Кроме того, для представления значения от 0 до 15 достаточно четырех битов, а отводится восемь.

Именно здесь заложена идея и принцип сжатия информации: в одном байте можно уместить два четырехбитовых значения. Тогда понадобится всего 40000 байт, что дает двукратный выигрыш! При этом потери заключаются в необходимости кодирования и декодирования значений. Процедуры преобразования могут иметь вид, показанный на рис. 9.2.

Если бы значения в выборке были целыми и имели диапазон 0..3 (т.е. занимали два бита), то можно было бы в один байт уместить четыре таких значения и т.д. Логика останется той же, изменятся лишь параметры в процедурах преобразования.

К сожалению, подобный подход нельзя применить к вещественным значениям. Единственное, что можно посоветовать — это посмотреть, нужны ли именно вещественные формы хранения данных. Так, если хранится массив вещественных (Real — 6 байт на элемент) значений размеров чего-либо в метрах с точностью до сантиметра, и самое длинное измерение не превосходит 2,55 м, то гораздо эффективнее будет хранить их как массив размеров в сантиметрах. И одно значение будет свободно размещаться в одном байте! Тип Byte занимает 1 байт — экономия шестикратная.

- 171 -

| { Процедура кодирования X1 и X2 в один байт (X1, X2<=15) }

| PROCEDURE Code2to1( X1,X2 : Byte; VAR X1X2 : Byte );

| BEGIN

| X1X2 := X1 + (X2 shl 4 )

| END;

| {Процедура декодирования X1 и X2 из одного байта }

| PROCEDURE DeCode1to2{ X1X2 : Byte; VAR X1,X2 : Byte );

| BEGIN

| X1 := X1X2 and 15; { X1X2 and $F }

| X2 := X1X2 shr 4

| END ; VAR {== ПРИМЕР ВЫЗОВА ==}

| C, C1, C2 : Byte;

| BEGIN

| Code2to1(8,7, C);

| WriteLn('8 и 7 - кодируются в —> ',C);

| DeCode1to2(C, C1, C2);

| WriteLn(C:3, — декодируются в --> ',C1:-3,' и ',C2);

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 9.2

 

9.3. Логические вычисления и операции отношения

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

В Турбо Паскале введены четыре логических операции (табл. 9.4, где L1 и L2 — логические константы, переменные или выражения, равные True или False).

Таблица 9.4

- 172 -

Результат операции всегда имеет тип Boolean и может иметь только одно из двух значений : True (истинно) или False (ложно). Логические операции имеют различные приоритеты (см. табл. 9.1), и в случае, если L1 и L2 сами являются логическими выражениями, лучше расставлять скобки, явно задавая порядок логических вычислений. Так, например, запись

not L1 and L2

будет воспринята компилятором как

(not L1) and L2,

в то время как, может быть, нужно было записать

not (L1 and L2).

С порядком логических вычислений тесно связана особая возможность Турбо Паскаля — поддержка двух различных моделей генерации кода для операций or и and — полное вычисление и вычисление по короткой схеме (частичное вычисление). При полном вычислении подразумевается, что каждый член логического выражения, построенного с помощью операций or и and, всегда будет вычисляться, даже если результат всего выражения уже известен. Вычисление по короткой схеме прекращается, как только результат всего выражения становится очевиден. Во многих случаях эта модель более удобна, поскольку она обеспечивает минимальное время выполнения и, как правило, минимальный объем кода. Вычисление по короткой схеме делает возможными такие конструкции, которые в противном случае были бы недопустимы, например:

if ( J <> 0 ) and ( ( 2/J ) > х ) then ... ;

while ( i <= Length(S) ) and ( S[i] <> ' ' ) do ... ;

В обоих случаях, если результатом первого вычисления будет значение False, вычисление второго выражения не выполняется (а если бы попыталось выполниться, то возникла бы ошибка).

- 173 -

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

if LogFunc(x) and LogFunc2(x) then ... ;

где LogFuncl и LogFunc2 — кроме анализа значения x, производят модификацию данных или выдачу сообщений.

Схема вычисления задается с помощью ключа компилятора $B. Обычно значением по умолчанию является состояние {$B-} (установленное в меню настройки компилятора Options/Compiler). В этом случае генерируется код с вычислением по короткой схеме. В случае директивы {$B+} генерируется код с полным вычислением.

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

Типы операндов и результаты операций отношения (сравнения) приведены в табл. 9.5. Сравнивать можно совместимые простые значения, указатели, символы, строки. Подобие операций сравнения существует и для множеств. Результат операции отношения — всегда логическое значение True или False.

Таблица 9.5

- 174 -

Когда операции отношения применяются для операндов простых типов, то это должны быть совместимые типы. Однако, если один операнд имеет вещественный тип, то другой может быть целого типа. Можно сравнивать и логические значения. Всегда выполняется True>False.

Обычно логические выражения встречаются в программе либо в операторах управления с условием (IF, WHILE, REPEAT...UNTIL и др.), либо в присваивании значений в логические переменные. С помощью приведения типов можно вставлять логические выражения прямо в числовые. Например, если надо ограничить величину X, например, значением 15, то обычно строится конструкция

if X>15 then X:=X-15;

Но если учесть, что False хранится как байт со значением 0, a True — как байт со значением 1, то можно обойтись без if:

X := X - 15 * Byte( X>15 );

Здесь 15 вычтется только, если (X>15)=True, что значит 1. Иначе же, вычтется 15*0. Можно и из байтов делать логические значения приведением к типу Boolean. Но тут надо помнить, что

Boolean( X ) = False, если X=0,

Boolean( X ) = True , если X<>0.

Значение X должно иметь тип Byte. Как видно, ненулевое значение всегда «истинно».

- 175 -

Еще одно замечание: при сравнении вещественных значений нельзя быть уверенным в его корректности. Например, выражения X и ( 2.23 * X / 2.23 ) формально тождественны, но из-за ошибок округления в вещественном типе будут различаться. Еще большие проблемы возникают при работе с расширенным набором вещественных типов, разрешенных при наличии математического сопроцессора 80X87. Советуем посмотреть разд. 9.5, посвященный использованию сопроцессора, где рассказывается, как бороться с подобными трудностями.

 

9.4. Математические процедуры и функции

Системная библиотека математических процедур и функций Турбо Паскаля приведена в таблицах 9.6 и 9.7.

Таблица 9.6

МАТЕМАТИЧЕСКИЕ ФУНКЦИИ

- 176 -

Таблица 9.7

МАТЕМАТИЧЕСКИЕ ПРОЦЕДУРЫ

Необходимо сделать следующие замечания к таблицам: под целым типом понимается один из целочисленных типов языка — от Byte и ShortInt до LongInt; под вещественным типом понимается тип Real или иной тип с плавающей точкой (при использовании сопроцессора), если речь идет о входном значении; возвращаемое функцией вещественное значение соответствует типу Real, если не используется математический сопроцессор (ключ компилятора {$N-}) или типу Extended, если сопроцессор используется (ключ {$N+}).

Математические функции очень чувствительны к диапазону своих аргументов. Кроме того, возвращаемые значения целых типов должны в них умещаться, иначе возможны фатальные последствия. Большинство из приведенных функций являются стандартными для языков программирования и не нуждаются в комментариях. Однако ряд функций является специфическим. Рассмотрим их.

- 177 -

 

9.4.1. Обсуждение математических функций языка

9.4.1.1. Функция Pi. Эта функция генерирует число «Пи» с точностью, зависящей от наличия сопроцессора и содержит 10 или 14 знаков после запятой. Она может использоваться в вычислениях как константа, но не может быть подставлена в вычислимые константы раздела CONST!

9.4.1.2. Функция ArcTan(X). Она возвращает главное значение арктангенса (в диапазоне от -Pi/2 до +Pi/2). Это не всегда удобно, и можно определить функцию арктангенса угла наклона отрезка, один конец которого соответствует началу координат, а другой задан координатами X и Y (рис. 9.3).

{ Функция возвращает значение угла наклона отрезка (0,0)-(X,Y) к оси X в радианах. Возвращаемое значение находится в диапазоне 0..2*Pi и учитывает знаки значений X и Y. }

| FUNCTION ATAN2( X,Y : Real ) : Real;

| VAR a : Real;

| BEGIN

| if X=0 then a:=Pi/2

| else a:=Abs( ArcTan( Y/X ) );

| case ( Byte(X>0) + Byte(Y>=0) ) of

| 2 : ATAN2 := a;

| 1 : if X>0 then ATAN2 := 2*Pi-a

| else ATAN2 := Pi - a;

| 0 : ATAN2 := Pi + a

| end {case}

| END;

{==== ПРОВЕРКА РАБОТОСПОСОБНОСТИ ФУНКЦИИ ====}

| CONST { константа перевода радиан в градусы }

| R2D = 180/3.1415926;

| VAR

| i : Integer;

| x, sx, ex : Real;

| BEGIN

| for i:=0 to 360 do begin

{ цикл по градусам }

| x:=i/R2D; { перевод в радианы }

| sx:=Sinx); cx:=Cos(x); { синус и косинус i }

| x:=ATAN2(cx,sx)*R2D; { угол в градусах }

| WriteLn(i:3, 'град. Функция возвращает: ', x:-10:6 )

| end ; { конец цикла по i }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 9.3

- 178 -

Эта функция возвращает корректное значение угла в диапазоне от 0 до 2*Pi, что гораздо удобнее в технических расчетах.

9.4.1.3. Доопределение функций. Часто ощущается нехватка функций arccos и arcsin. Но их нетрудно написать самим (рис. 9.4).

| { Функция возвращает главное значение arcCos X (в рад) }

| FUNCTION ArcCos( x : Real ): Real;

| BEGIN

| if x=0

| then ArcCos:=Pi/2

| else ArcCos:=ArcTan(Sqrt(1-Sqr(x)) / x) + Pi*Byte(x<0)

| END;

| {Функция возвращает главное значение арксинуса X(в рад)}

| FUNCTION ArcSin( x : Real ) : Real;

| BEGIN

| if Abs(x)=1

| then ArcSin:=0

| else ArcSin:=ArcTan(x / Sqrt( 1-Sqr(x) ) )

| END;

Рис. 9.4

Аналогичным образом можно построить библиотеку любых необходимых математических функций, сделав в итоге свой собственный математический модуль. Все необходимые «кирпичики» имеются в базовом наборе языка. Так, например, можно ввести десятичный логарифм (рис. 9.5) или степенную функцию (рис. 9.6).

| { Функция возвращает значение десятичного логарифма }

| FUNCTION Log10( x : Real ) : Real;

| BEGIN

| Log10:= Ln(x)/Ln(10)

| END;

Рис. 9.5

| { Функция возвращает значение A в степени X (A>0) }

| FUNCTION Pwr(a,x : Real ) : Real;

| BEGIN

| Pwr := Exp( x * Ln(a) )

| END;

Рис. 9.6

- 179 -

9.4.1.4. Функции Frac, Int и Trunc. Эти функции соответствуют математическим функциям взятия дробной и целой части числа соответственно. Помните, что

Frac( X ) = X - Int( X )

и знак X переходит на значение функции Frac.

Функция Trunc отличается от Int только типом возвращаемого значения. Int записывает целое число в вещественном формате (после точки — нули), a Trunc — в целочисленном. Такая двойственность необходима для совместимости в операторах присваивания.

9.4.1.5. Функция Round. Эта функция округляет число X до ближайшего целого числа с избытком:

Round (5.5) = 6 Round (-5.5) = -6

Round (5.9) = 6 Round (-1.51) = -2

Round (5.49) = 5 Round (-1.4) = -1

При подключении математического сопроцессора эта функция начинает работать несколько в другом режиме и может выдавать иные результаты.

 

9.4.2. Генераторы случайных чисел

С функцией-генератором случайных чисел Random связано много условностей. Она всегда возвращает равномерно распределенное случайное число. Диапазон или, вернее, интервал распределения таких чисел задается видом вызова функции. Если Random вызывается без аргумента, то она вернет вещественное случайное число r в диапазоне 0 <= r < 1. Но если вызов содержал аргумент N типа Word — Random( N ), то вернется случайная величина (целая!) из диапазона 0 <= r < N. При N=0 функция вырождается и возвращает константу 0.

У функции-генератора случайных чисел Random есть одна неприятная особенность: при последовательных запусках программы выдавать одинаковые случайные последовательности. Другими словами, пока программа работает, любое обращение к Random даст вполне «случайное» значение (период повторяемости, конечно, есть, но очень большой). Но если запустить программу второй раз, то ее вычисления в точности повторят предыдущий запуск: «случайные» значения будут теми же, что и в прошлый раз. А это значит, что многократный запуск программ, моделирующих случайные процессы наберет статистику, одинаковую с единичным прогоном. Во избежание этого рекомендуем включать в начало программы вызов процедуры Randomize. Эта процедура записывает случайное число (взятое со встроенного таймера) в так называемую «затравку» случай-

- 180 -

ной последовательности, сбивая тем самым ее на новые числа. Того же эффекта можно достичь, если записывать произвольное (но каждый раз разное!) значение в системную переменную RandSeed типа LongInt.

Функции Random генерируют случайную равномерно распределенную на интервале последовательность чисел. На ее основе можно сконструировать последовательности с другими законами распределения. Наиболее часто требуется нормальное распределение. Один из вариантов генератора показан на рис. 9.7.

| { Функция Gauss возвращает случайное вещественное число }

| {распределенное по нормальному закону с математическим }

| {ожиданием mo и средне-квадратическим отклонением Sigma}

| FUNCTION Gauss( mo, Sigma : Real ) : Real;

| VAR

| a, b, r, sq : Real;

| BEGIN

| repeat

| a := 2 * Random - 1;

| b := 2 * Random - 1;

| r := Sqr(a) + Sqr(b)

| until ( r < 1 );

| sq := Sqrt( -2 * Ln(r)/r);

| Gauss := mo + Sigma*a*sq

| END;

Рис. 9.7

Функцию Gauss несложно модифицировать, чтобы она возвращала целые значения.

 

9.4.3. Оптимизация сложения и вычитания

Процедуры Inc и Dec (аналогичные названия имеют команды ассемблера) введены в язык для оптимизации операций сложения и вычитания целых чисел. При компиляции Inc(i) даст более эффективный и быстрый код, чем традиционное i := i + 1. Выигрыш составит до 30%, что очень важно при использовании в циклических процессах.

 

9.5. Использование математического сопроцессора 80X87

Применение сопроцессора значительно увеличивает точность математических расчетов и ускоряет их выполнение. Дело лишь в малом — наличии его и умении использовать.

- 181 -

Чтобы программа могла задействовать возможности сопроцессора, она должна в своем начале иметь директиву (ключ режима компилятора) $N+ :

{$N+ программа для 80X87}

PROGRAM Name;

USES

...

Режим компиляции $N+ является глобальным и не может меняться в дальнейшем. При создании модулей (UNIT), ориентированных на работу с сопроцессором, т.е. использующих вводимые им типы, указание ключа $N+ в них необязательно. Важно лишь, чтобы он был в главной программе, включающей в себя эти модули.

При необходимости отключить сопроцессор должен указываться ключ $N-. При этом программа может перестать компилироваться (компилятор «забудет» типы чисел с повышенной точностью).

Если в ПЭВМ установлен сопроцессор, то компилятор сам определяет ключевое слово CPU87 для условной компиляции. Это можно использовать для автоматического выбора режима компиляции:

{$IFDEF CPU87} {$N+} {$ELSE} {$N-} {$ENDIF}

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

После компиляции выполнение программы всякий раз начинается с проверки наличия сопроцессора и определения его типа. Результат проверки записывается в предопределенную переменную системной библиотеки — Test8087 типа Byte (табл. 9.8).

Таблица 9.8

Если программа компилировалась в режиме {$N+}, а значение Test8087 получилось равным 0, то программа остановится с выдачей сообщения о необходимости сопроцессора. Существует, однако, средство отключить автоматическую проверку наличия сопроцессора при запуске программы. Надо ввести системную переменную MS-DOS с именем 87 и значениями Y (от YES — да) и N (от NO — нет). Лучше всего это сделать в файле AUTOEXEC.BAT, вставив строку

- 182 -

SET 87=Y (или N)

Значение системной переменной MS-DOS 87, равное Y, прикажет считать сопроцессор подключенным, а N — соответственно отключенным. Вообще говоря, лучше не обманывать технику и программы. Приберегите эту методику (с SET 87=) на самый крайний случай.

Турбо Паскаль дает возможность эмулировать работу сопроцессора программным путем. Это означает, что можно создать программу, которая будет работать с высокой точностью независимо от наличия сопроцессора. Обнаружен сопроцессор — хорошо, он и будет нагружен, нет сопроцессора — вся точность будет получена имитацией его. Понятно, что в последнем случае будут потери во времени счета, и немалые. Включением эмуляции управляет ключ $Е. Он имеет смысл только рядом с ключом $N. Возможны такие их сочетания:

{$N+, E+} — подключение библиотеки для эмуляции сопроцессора; при его отсутствии точность обеспечивается программно за счет скорости; {$N+, E-} — программа сможет работать только на машинах с сопроцессором;

{$N-,E+} и {$N-,E-} — сопроцессор не используется, ключ эмуляции игнорируется. Программа работает только с обычной точностью и скоростью.

Если в программу вставлен внешний код директивой {$L Имя-Файла.OBJ}, то для работы с сопроцессором этот код должен быть получен с учетом использования инструкций 80X87.

Преимущества от использования сопроцессора — это, в первую очередь, скорость вычислений, которая может вырасти в несколько раз. Второе преимущество — увеличение точности вычислений с плавающей точкой. В расчете на математический сопроцессор вводятся типы, приведенные в табл. 9.9.

Таблица 9.9

Все эти типы — вещественные, за исключением Comp, который является «очень длинным» целым типом (хранит только целые

- 183 -

значения). Диапазон этого типа в таблице задан округленно, так как реальные числа (от -2 до 263-1) слишком длинны.

Обычный тип Real (6 байт, диапазон 2.9Е-39...1.7Е+38, 11-12 значащих цифр) будет работать с сопроцессором, но крайне неэффективно. Этот формат — чужой для сопроцессора, и время, «съедаемое» преобразованием его в сопроцессорный тип, перекрывает ускорение. А точности не добавляется. Поэтому лучше всего ввести свой тип, например Float, и понимать под ним либо Real, либо чисто сопроцессорный вещественный тип в зависимости от режима компиляции.

{$N... <-- какой-либо режим }

{$IFOPT N+}

TYPE

Float = Double; { или любой другой тип для 80X87 }

{$ELSE>

TYPE

Float = Real; { без 80X87 — только этот тип }

{SENDIF}

VAR { переменные типа Float }

r : Float;

d : Array [1..9] of Float;

Целые типы Турбо Паскаля работают с сопроцессором без каких-либо оговорок.

Особо важным является вопрос точности вычислений. При использовании сопроцессора все стандартные математические операторы и функции языка, возвращающие обычно значения Real, начинают возвращать значения типа Extended. В связи с этим имеет смысл опираться именно на этот тип как базовый. Тем не менее вполне возможно, что в программе будут участвовать переменные разных типов. В таких случаях при необходимости будет производиться преобразование значений, а значит, потеря точности. При вычислении значений правых частей операторов присваивания результат имеет точность, совпадающую с наиболее точным из типов членов выражения (или, что то же самое, с наиболее емким типом). Это означает, что в присваивании

VAR

e1, e2 : Extended;

e3 : Double;

result : Single;

...

result := e1*e2/e3;

- 184 -

значение выражения справа будет вычислено как тип Extended. Но при присваивании его переменной result «малого» типа Single будет произведено усечение, и резко уменьшится число значащих цифр после десятичной точки. Подобные ситуации надо предвидеть и стараться избегать их. Особенно неприятны они в циклах суммирования:

VAR

е : Extended:

Sum : Single;

i : Word;

...

BEGIN

e:=1.23456e-12;

Sum:=0;

for i:=32767 to 65535 do Sum := Sum + i/e;

...

END.

Здесь подобные потери будут повторены тысячи раз, и накопленная ошибка может быть соизмерима с самой суммой. Исправить ситуацию легко: надо ввести дополнительную переменную eSum точного типа Extended для сумматора, и переписать цикл:

eSum:=0;

for i:=32767 to 65535 do eSum := eSum + i/e;

Sum:=eSum;

Теперь потери будут значительно меньше.

По той же причине (из-за усечения точности) некорректной является операция сравнения двух разнотипных вещественных переменных или переменной с выражением (последнее, как уже отмечалось, может быть вычислено в типе Extended). Так, сравнение в примере:

VAR

e : Extended;

d : Double;

...

e := Cos( Pi/8 );

d := e;

{==>} if d=e then ...

при формальной правильности и очевидности даст результат False — ложно, так как d имеет меньше значащих цифр, чем e. Обычно при сравнении вещественных значений проверяют не их совпадение, а степень расхождения. Если эта степень соизмерима с точностью представления наиболее грубого числа, то значения можно считать

- 185 -

равными. Так, условие if в последнем примере следовало бы переписать так:

if Abs(d-e) < 1.0Е-15 then ...

Здесь 1.0Е-15 — точность для типа переменной d (Double).

Продолжим перечень особенностей применения сопроцессора. Его наличие в ПЭВМ и использование сильно влияет на работу функции округления Round: она начинает округлять полуторные значения в сторону ближайшего четного целого числа (это называется «банковским способом»)! Например:

без сопроцессора с сопроцессором

Round(0.5) --> 1 Round(0.5) --> 0

Round(1.5) --> 2 Round(1.5) --> 2

Round(2.5) --> 3 Round(2.5) --> 2

Round(3.5) --> 4 Round(3.5) --> 4

С остальными значениями (без '.5') функция работает нормально.

Некоторые неприятности могут поджидать любителей рекурсивного подхода к написанию функции. Возможны, в принципе, ситуации, когда рекурсивные вызовы переполнят внутренний стек данных сопроцессора, рассчитанный на восемь уровней рекурсии, и возникнет сбой программы. Возможным решением будет разнесение сложнорекурсивных выражений типа Fn:=Fn(N-1)+Fn(N-2) по локальным переменным, например, f1:=Fn(N-1); и f2:=Fn(N-2). После этого выражение Fn:=f1+f2 будет безопасным для сопроцессора.

Завершая тему использования сопроцессора, напомним, что и расширенные вещественные типы, и тип Real при работе с сопроцессором 80X87 выводятся на печать операторами Write и WriteLn с 4 цифрами в показателе степени:

при $N- WriteLn(123.4) выдаст 1.2340000000Е+02,

но при $N+ WriteLn(123.4) выдаст 1.234000000000000Е+0002.

Этот факт надо учитывать при форматированном выводе и при преобразовании чисел в строку процедурой Str.

- 186 -

 

10.1. Система адресации MS-DOS

Адресуемое пространство памяти в операционной системе MS-DOS организовано сегментами: последовательными блоками памяти по 64K каждый. Если известен сегмент, то дальнейшее уточнение места объекта в памяти происходит по его смещению, т.е. номеру байта от начала сегмента. Это, может быть, не самый эффективный способ адресации памяти, но на нем основана операционная система MS-DOS и все программы для нее. Таким образом, любая ячейка адресуемого пространства MS-DOS определяется парой чисел СЕГМЕНТ:СМЕЩЕНИЕ. При этом сегмент может начинаться с любого физического адреса, что порождает множественность способов адресации ячейки памяти. Например, такие разные адреса, как $83FD:$000B, $7FFD:$400B и $759D:$E60B в действительности адресуют к одной и той же ячейке. Иногда может быть интересно получить сплошной адрес ячейки, отсчитанный от начала памяти 0000:0000. Такое число получить очень просто: оно равно СЕГМЕНТ *16 + СМЕЩЕНИЕ.

Существует понятие нормализации адреса. Под этим понимается приведение его к такому виду, что смещение находится в диапазоне от 0 до 15 ($000F). Если вычислен сплошной адрес ячейки памяти, то его можно легко пересчитать в нормализованный «обычный» формат:

СЕГМЕНТ = Сплошной_адрес div 16

и

СМЕЩЕНИЕ = Сплошной_адрес mod 16,

где div и mod — операции деления нацело и взятие остатка от деления соответственно.

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

- 187 -

 

10.2. Распределение памяти при выполнении программ

Рассмотрим распределение памяти для выполнимого кода программ на Турбо Паскале (рис. 10.1).

Рис. 10.1

При запуске программы (ЕХЕ-файла) MS-DOS организует в памяти нечто вроде анкеты длиной 256 байт на этот файл, называемой PSP (Program Segment Prefix). Структура PSP описывается в технических руководствах по MS-DOS. Сегмент, с которого начинается отсчет PSP, может быть получен через предопределенную в системной библиотеке (модуле System) переменную PrefixSeg типа Word.

После PSP начинается код ЕХЕ-файла. Он может занимать более одного сегмента. Когда выполняется какой-либо из блоков кода (основной блок, процедуры из модулей), он считается размещенным

- 188 -

в некотором сегменте кода. Реальное значение сегмента при этом содержится в регистре CS процессора.

Статические глобальные переменные основного блока и все типизированные константы, включая локальные, располагаются в сегменте данных, который запоминается регистром DS процессора. Общий объем переменных и типизированных констант не может в сумме превышать 64K.

Заметим, что реальный сегмент может быть и меньше чем 64K. В самом деле, он может начинаться где угодно. Если самый последний байт в нем имеет смещение, например 255 ($00FF), то следующий сегмент может отсчитываться от следующего же байта.

Следом за сегментом данных следует область стека. В ней располагаются локальные переменные и параметры-значения процедур и функций во время их работы по вызову. Сегмент стека содержится в регистре SS процессора. Турбо Паскаль отводит под стек один сегмент, и поэтому область стека не может превышать 64K.

Стек заполняется от своей верхней границы (она может быть назначена директивой компилятору $М) по направлению к началу, т.е. к старту сегмента. Специальный регистр SP процессора содержит смещение указателя стека в сегменте SS (указатель стека — это как бы отметка уровня заполнения стека).

Имеется предопределенная системная переменная StackLimit типа Word, которая логически примыкает к рассматриваемым вопросам. Она содержит минимальное допустимое значение указателя стека. Когда программа запускается, указатель стека имеет максимальное значение, равное отведенной под стек памяти. При работе стек заполняется «сверху вниз», и указатель как бы снижается. Как только он спустится настолько, что свободная часть стека станет меньше чем значение StackLimit, возникнет ошибка времени счета номер 202 Stack overflow (переполнение стека), и программа прервется.

Нормальное значение StackLimit — это 0, а в режиме компиляции {$N+, E+} — 224. Обычно нет необходимости менять это значение.

Выше стека программа отводит себе память под буфер для работы оверлеев — перекрывающихся частей программы. Если они не используются, то буфер не отводится (подробнее об этом см. гл. 18 «Модуль Overlay»).

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

- 189 -

 

10.3. Анализ расположения кода и областей данных программы

При программировании на низком уровне или использовании вставок машинных кодов в программу необходимо иметь средства анализа положения программы в ее данных в оперативной памяти. Системная библиотека Турбо Паскаля содержит набор средств для этого. Перечень специальных функций анализа памяти приведен в табл. 10.1.

Таблица 10.1

Функция : Тип -- Возвращаемое значение

CSeg : Word -- Содержимое регистра CS процессора

DSeg : Word -- Содержимое регистра DS процессора

SSeg : Word -- Содержимое регистра SS процессора

SPtr : Word -- Содержимое регистра SP процессора

При работе программы ее текущий исполнимый код находится в кодовом сегменте, что фиксируется в регистре CS, а статические переменные основного блока и типизированные константы располагаются в сегменте данных, который запоминается регистром DS. Локальные переменные и параметры процедур и функций при вычислениях располагаются в стеке, и сегмент стека содержится в регистре SS. Последний регистр – SP – содержит смещение указателя стека в сегменте SSeg.

 

10.4. Тип Pointer

В Турбо Паскале предопределен специальный адресный тип Pointer — указатель: можно объявлять переменные, значением которых будет адрес ячейки памяти:

VAR

Р : Pointer; { переменная-указатель }

Значения этого типа занимают 4 байта памяти и содержат адрес какой-либо ячейки памяти. Адрес хранится как два слова: одно из них определяет сегмент, а другое — смещение. Значение указателя не может быть в явном виде выведено на экран или печать. Его надо предварительно расшифровывать. Для работы с указателями

- 190 -

вводится специальный набор функций. Кроме того, указатели полностью совместимы со ссылочным типом и могут использоваться (с оговорками) как ссылки. Указатели могут обмениваться значениями через оператор присваивания (:=), и сравниваться операторами = и <>. Но сравнение их — весьма ненадежная операция. Так, когда два указателя содержат один и тот же адрес в памяти, но записанный в них разными способами, они считаются различными. Таким образом, два указателя считаются одинаковыми, если в них записаны одинаковые значения сегмента и смещения. Во всех остальных случаях они считаются неравными. Понятия «больше» и «меньше» к значениям типа Pointer неприменимы.

Если мы хотим указать в программе на значение по указанному в переменной типа Pointer адресу, то мы должны использовать символ «^» после имени указателя, например: Р^. Это есть операция разыменования. Подробно этот вопрос рассмотрен при описании работы со ссылками, а особенности разыменования указателей обсуждаются вместе с работой функции Ptr.

 

10.5. Средства для работы с адресами

В разд. 10.3 были рассмотрены средства анализа расположения частей работающей программы. Обсудим инструментарий, применимый к данным, используемых программой. Это операции достаточно низкого уровня, но некоторые из рассматриваемых здесь функций можно с успехом применять и на более высоком уровне, в частности при работе с ссылками и динамическими данными. Список таких функций приведен в табл. 10.2.

Таблица 10.2

Функция : Тип -- Возвращаемое значение

Addr(X) : Pointer -- Ссылка на начало объекта X в памяти

Seg(X) : Word -- Сегмент, в котором хранится объект X

Ofs(X) : Word -- Смещение в сегменте для объекта X

Prt(S, O : Word) : Pointer -- Ссылка на место в памяти, заданное значениями смещения O и сегмента S

SizeOf(X) : Word -- Размер объекта X в байтах

Операция @X : Pointer -- Возвращает ссылку на начало объекта X памяти (аналог функции Addr)

 

10.5.1. Определение адреса переменных

Функции Addr(X), Seg(X) и Ofs(X), а также оператор @ возвращают адрес объекта X или компоненты адреса. Под X можно понимать любой объект: переменные любых типов, объекты, процедуры и функции (но не константы).

Функция Addr(X) и оператор @ возвращают значение типа Pointer — адрес объекта X. Их действие одинаково:

VAR

X : String; p, q : Pointer;

...

р: = Addr( X );

q: = @X;

{Теперь p=q, и адреса равны; они указывают на один объект }

Значение типа Pointer не может быть выведено на экран. Но так как этот тип состоит из двух слов (Word), хранящих сегмент и смещение, можно вывести их в отдельности, используя функции Seg и Ofs (обе типа Word):

WriteLn( 'Сегмент ', Seg( р ), ' смещение ', Ofs( р ));

В то же время значения ссылок можно получить в режиме отладки. Они будут выводиться в окна наблюдения и модификации (Watch и Evaluate).

Может возникнуть вопрос — а зачем вообще нужна функция Addr, если есть Seg и Ofs, тем более что нельзя распечатать ее значение? Ответ: функция Addr и оператор @ нужны для привязывания ссылок, т.е. динамических переменных, к статическим данным, а также для работы с массивами данных в виде OBJ-файлов, связанных с выполнимым файлом на этапе компоновки. Пример компоновки внешних данных дан при описании работы с образом экрана на диске в разд. 20.4 «Работа с образом экрана на диске».

Заметим, что если P — ссылка, то Addr(P) или @P, а также Seg(P) и Ofs(P) вернут адрес или сегмент со смещением самой переменной-ссылки P в области статических данных, но Addr(P^) или @Р^ и Seg(P^) с Ofs(P^) возвратят содержимое ссылки P, т.е.

Р = Addr( Р^).

Рассмотрим действие оператора @ с различными типами переменных. При использовании с глобальными переменными или типизированными константами оператор вернет адрес этих переменных, как правило, в сегменте данных. При использовании его внутри процедур и функций с параметрами-переменными оператор @

- 192 -

применительно к ним вернет адреса фактических переменных, подставленных в вызов процедуры или функции. Но применение оператора @ к параметру-значению, как и к любой локальной переменной, даст адрес в стеке, где временно расположено значение. Можно применять этот оператор и к идентификаторам процедур и функций (это даст точку входа в процедуру или функцию), но что с ней потом делать, не привлекая вставки на ассемблере, неясно.

 

10.5.2. Создание адреса функцией Ptr

Функция Ptr( Seg, Ofs : Word) выполняет противоположную функции Addr работу: организует ссылку на место в памяти, определяемое заданными сегментом и смещением. Необходимость в такой функции возникает всякий раз, когда требуется наложить динамическую структуру на системную область памяти (системные, т.е. зарезервированные, области памяти достаточно жестко фиксированы, и их адреса описаны в специальной литературе). Если, например, известно, что образ текстового экрана начинается с адреса $В000 : $0000 и занимает 4000 байт (цветной и черно-белый режимы, 80 столбцов на 25 строк), то можно «наложить» на него структуру, например массив, используя ссылку на такой массив и функцию Ptr (рис. 10.2):

| TYPE

| VideoArray = Array [0..3999] of Byte;

| VAR

| V : ^VideoArray; { ссылка на структуру }

| BEGIN

| V := Ptr( $B000, 0 );

| { Далее V^[i] обращается непосредственно к ячейкам видеопамяти в текстовом режиме }

| ...

| END.

Рис. 10.2

Обращаем внимание на отсутствие вызовов New и Dispose. Они не нужны, так как массив буквально накладывается, а не создается вновь.

Так как значение типа Pointer, возвращаемое функцией Ptr, совместимо со всеми ссылочными типами, можно наложить любую структуру на какой угодно участок памяти. Кроме того, его разрешается разыменовывать, т.е. записывать конструкции вида

Ptr( $40, $40 )^

- 193 -

Но в чистом виде такая конструкция имеет мало смысла, ибо не определена структура, на первый байт которой указывает это разыменование. А определить эту структуру можно операцией приведения (преобразования) типа:

B := Byte( Ptr($40, $40)^); {B — значения байта $40:$40 }

W := Word( Ptr($40,$40)^ ); { W — значение слова $40:$40 }

X := VideoArray( Ptr($B800,0)^); { X — статический массив типа VideoArray содержит теперь в себе образ видеопамяти (текстовое изображение) }

и т.д.

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

 

10.5.3. Определение размеров типов и переменных

Функция SizeOf(X): Word возвращает объем в байтах, занимаемый X. Причем X может быть не только переменной, но также и идентификатором типа (рис. 10.3).

| TYPE

|  XType = Array[1..10, 1..10] of byte;

|CONST

|  L : Longint = 123456;

| VAR

|  X : String;

| BEGIN

|  WriteLn(SizeOf(Xtype): 10,  SizeOf(L): 10, SizeOf(X))

| END.

Рис. 10.3

Значение SizeOf(строка) всегда дает максимальное значение длины строки. Реальное значение дает функция Length.

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

Применительно к данным типа «объект» (OBJECT) эта функцию должна использоваться более осторожно, так как у объектов может не быть заранее предопределяемого размера. Обсуждение этого можно найти в гл. 13.

 

11.1. Ссылочные переменные

Основным механизмом для организации динамических данных является выделение в специальной области памяти, называемой «кучей», непрерывного участка (блока) подходящего размера и сохранения адреса начала этого участка в специальной переменной. Такие переменные называют ссылочными переменными или просто ссылками (reference). Часто используется синоним этого термина — «указатель» (pointer), но в Турбо Паскале это название имеет особый смысл.

В Турбо Паскале для определения ссылочной переменной нужно описать ее как переменную, имеющую ссылочный тип. В качестве ссылочного можно использовать встроенный тип Pointer или любой другой тип, определенный пользователем следующим образом:

TYPE

ИмяСсылочногоТипа = ^ИмяБазовогоТипа;

где ИмяБазовогоТипа — любой идентификатор типа. В результате

- 195 -

этого определения создаваемые затем ссылочные переменные будут указывать на объекты базового типа, определяя тем самым динамические переменные базового типа. Например:

TYPE { БАЗОВЫЕ ТИПЫ }

DimType = Array [1..10000] of Real; { массив }

RecType = RECORD { запись }

...

END;

ObjType = OBJECT { объект }

...

| END;

{ ССЫЛОЧНЫЕ ТИПЫ }

IntPtr = ^Integer; { ссылка на целое значение }

DimPtr = ^DimType; { ссылка на массив данных }

RecPtr = ^RecType; { ссылка на запись }

ObjPtr = ^ObjТуре; { ссылка на объект }

XXXPtr = Pointer; { ссылка вообще — указатель }

Условимся называть в дальнейшем указателем, а не ссылкой те переменные, которые имеют обобщенный тип Pointer. Этот тип совместим со всеми прочими ссылочными типами.

Все ссылочные переменные имеют одинаковый размер, равный 4 байтам, и содержат адрес начала участка оперативной памяти, в котором размещена динамическая структура данных. Отношение между ссылочной переменной и объектом, на который она указывает, наглядно представлено на рис. 11.1. Здесь J — ссылочная переменная, указывающая на значение целого типа (VAR J : ^Integer). Сравните с простой переменной I типа Integer на том же рисунке.

Рис. 11.1

Чтобы ссылка ни на что не указывала, ей присваивается значение nil, например:

J := nil;

Это предопределенная константа типа Pointer, соответствующая адресу 0000:0000.

- 196 -

 

11.2. Операция разыменования

Основной операцией при работе со ссылочными переменными является операция разыменования. Суть ее состоит в переходе от ссылочной переменной к значению, на которое она указывает. Эта операция обозначается указанием символа «^» следом за ссылочной переменной. Результатом операции является значение объекта, на который указывала ссылочная переменная, или, что то же самое, динамическая переменная. Так, пусть мы имеем две ссылочные переменные I и J, указывающие на объекты целого типа, значения которых равны 2 (I^) и 4 (J^) соответственно. Для того чтобы скопировать содержимое переменной I^ в переменную J^, необходимо выполнить оператор

J^ := I^;

Следует отметить, что нужно писать именно I^ и J^, поскольку оператор вида

J := I;

приведет к копированию адреса значения, на которое указывает I, в ссылочную переменную J. В этом случае мы получим две ссылки на одно и то же значение. Значение, на которое раньше указывала переменная J, будет потеряно. На рис. 11.2 показан результат выполнения этих двух операторов (а — ситуация до (слева) и после выполнения оператора J^:=I^; б — ситуация до (слева) и после выполнения оператора J:=I). После выполнения оператора J:=I ссылка на значение 4 теряется (рис. 11.2, б, справа), и к нему больше нет доступа.

Рис. 11.2

- 197 -

Само значение теперь будет просто пассивно занимать память, т.е. превратится в «мусор».

Ссылочные переменные и указатели совместимы между собой по типу, т.е. нет ошибки в присваивании

DimPtr := RecPtr;

но после разыменования контроль типов становится строгим и

DimPtr^ := RecPtr^;

дает ошибку. Здесь речь идет уже не о значениях вполне совместимых адресов, а о разнотипных значениях по этим адресам.

Ссылки могут сравниваться между собой. Под этим понимается сравнение соответствующих сегментов и смещений адресов, хранимых в них. Имеют смысл лишь проверки на равенство и на неравенство ссылок или указателей:

if DimPtr = XXXPtr then ... ;

if DimPtr <> XXXPtr then ... ;

Сравнения ссылок не всегда работают корректно. Если две ссылки указывают на один и тот же адрес в памяти, но этот адрес записан в них различными значениями (что вполне возможно), то они считаются различными. Процедуры New и GetMem всегда возвращают ссылки, приведенные к такому виду, что смещения адреса имеют значения от 0 до 15 ($F), и они будут сравниваться корректно. А специальные функции типа Addr, Ptr этого не делают, и сравнивать их результаты с чем-либо надо с большой осторожностью.

Разыменованные ссылки на структуры индексируются (массивы) или разделяются на поля (записи, объекты) обычным образом. Для определенных выше ссылок это выглядит следующим образом:

DimPtr^ [i] — доступ к элементу i динамического массива,

RecPtr^.Поле — доступ к полю динамической записи,

ObjPtr^.Метод — доступ к методу динамического объекта.

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

 

11.3. Организация памяти области кучи

Для размещения динамических переменных используется область памяти, называемая «кучей». Место для данных в куче

- 198 -

отводится и освобождается только во время работы программы, и именно поэтому мы говорим о динамических данных. Место для прочих переменных отводится в специальном сегменте данных еще на этапе компиляции и не меняется впоследствии — это статические данные. Интересно, что сами ссылочные переменные являются статическими и располагаются в сегменте данных, но данные на которые они впоследствии ссылаются, как правило, организуются в куче.

На рис. 11.3 представлено распределение памяти области кучи при работе программ, написанных на Турбо Паскале. Куча первоначально всегда свободна и заполняется от нижних адресов в области кучи. Эта область характеризуется двумя предопределенными в языке указателями (переменными типа Pointer): HeapOrg и HeapPtr. Переменная HeapOrg указывает на начало кучи. Как видно из рис. 11.3, куча начинается сразу за оверлейным буфером. Если же программа не имеет оверлейных блоков, то куча начинается сразу за областью стека. Значение HeapOrg постоянно и, как правило, не меняется по ходу выполнения программы.

Переменная HeapPtr указывает на нижнюю границу свободного пространства в куче. Каждый раз, когда в куче размещается наверху новая динамическая переменная, этот указатель перемещается на размер переменной. При этом он нормализуется (приводится к виду СЕГМЕНТ:СМЕЩЕНИЕ) таким образом, что смещение находится в диапазоне от 0 до $F (15). Максимальный размер переменной, которая может быть размещена в куче равен 65520 байт, так как каждая переменная должна находится в одном сегменте и «оставлять» в нем 15 байтов.

Верхняя граница памяти MS-DOS

Рис. 11.3

- 199 -

Переменные HeapOrg и HeapPtr не стоит использовать в программах, пока не требуется распределять память кучи лучше, чем системные процедуры Турбо Паскаля. Но для опытных программистов, собирающихся производить «уборку мусора» и оптимизацию кучи, они могут быть полезны.

 

11.4. Управление размерами области кучи и стека

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

{$М Стек, МинимумКучи, МаксимумКучи }

при компиляции программы. Эта директива должна быть в первых строках основной программы (в модулях она игнорируется). При указании размеров кучи в директиве {$М...} помните, что программа не будет выполняться, если свободной памяти, оставшейся после загрузки выполнимого файла, будет меньше, чем задано минимальным (нижним) значением МинимумКучи. Всегда должно выполняться условие

МинимумКучи <= МаксимумКучи.

Диапазон значений области стека — от 1024 до 65535 байт (1К...64К), а обоих параметров кучи — от 0 до 655360 байт (0...640К). Максимальное значение объема кучи может быть больше, чем объем реально свободной памяти. В таком случае кучей будет использоваться вся свободная память.

Если директива {$М...} не указана, то значения минимального (нижнего) и максимального (верхнего) размеров кучи устанавливаются равными 0 и 655360 соответственно. Это означает, что под кучу будет использоваться вся оставшаяся в ПЭВМ свободная память.

Можно установить эти параметры в среде программирования, используя меню Options/Compiler/Memory.

Реальная необходимость в явном задании размеров стека и памяти возникает лишь при запуске субпроцессов и организации резидентных программ.

 

11.5. Процедуры управления кучей

Управление кучей осуществляет монитор кучи, являющийся частью системной библиотеки Турбо Паскаля. Он реализует следу-

- 200 -

ющие процедуры и функции (табл. 11.1), размещающие и удаляющие динамические переменные из кучи и анализирующие ее состояние.

Таблица 11.1

Размещение динамических переменных.

 

11.5.1. Процедуры New и GetMem

Размещение динамических переменных Турбо Паскалем выполняется процедурами New( VAR P : Pointer ) и GetMem ( VAR P : Pointer; Size : Word ) или функцией New( ИмяТипаСсылки ) : Pointer и происходит следующим образом. Пусть P описана как ссылочная

- 201 -

переменная, имеющая тип IntPtr, определяющий ссылку на целое число (Integer). Тогда при вызове

New(P);

или

Р := New(IntPtr);

в куче выделяется блок памяти размером SizeOf (Integer) — это 2 байта, и адрес первого байта этого блока запишется в P. Процедура New работает только с типизированными ссылочными переменными, но значение функции New может быть присвоено переменной-указателю. После выполнения New можно уже ссылаться на динамическую переменную P^.

Процедура GetMem требует указания двух параметров. В качестве первого из них должна быть указана ссылочная переменная любого типа. Второй параметр может быть любым выражением, определяющим значение типа Word. Эта процедура производит выделение в куче неразрывного блока памяти с размером, определяемым вторым параметром процедуры (Size), и помещает адрес первого байта этого блока в ссылочную переменную (P).

Можно вызов New(P) заменить на

GetMem(P, SizeOf(ИмяБазовогоТипа_P)),

но по сути своей процедура GetMem предназначена для выделения памяти указателям:

VAR

Р : Pointer; { объявлен указатель }

BEGIN

GetMem(P, 4*1024 );

{ Теперь P указывает на блок памяти размером 4K, }

{ и P^ не имеет типа, но содержит 4096 байт. }

...

END.

Забота о подстановке размера отводимого блока памяти при работе с GetMem перекладывается на программиста так же, как и ответственность за возможную организацию «бардака» в куче при неумелом использовании процедуры GetMem.

 

11.5.2. Процедуры Dispose и FreeMem

Процедура Dispose (VAR P : Pointer ) освобождает память, занимаемую динамической переменной P^, на которую указывает ее

- 202 -

аргумент P. Эта процедура работает только с типизированными ссылочными переменными. Во избежание проблем вызовы Dispose должны быть парны вызовам New с тем же аргументом и ни в коем случае не применяться к неразмещенным ссылкам.

После выполнения процедуры Dispose значение ссылки P не определено, как и значение разыменования P^.

Для освобождения непрерывных участков памяти заданного размера нужно использовать процедуру

FreeMem( VAR Р : Pointer; Size : Word ).

Она производит освобождение участка памяти, начиная с адреса, передаваемого ей в первом параметре (ссылке или указателе P) и имеющего размер, определяемый вторым параметром (Size). При использовании процедуры FreeMem нельзя забывать, что размер освобождаемого блока должен точно соответствовать размеру, заданному при его размещении посредством GetMem или New. В противном случае либо возникнут потерянные байты, если размер блока при освобождении оказался меньше (а это мусор в памяти), либо в дальнейшем возможна потеря части данных, непосредственно примыкавших к этой области, если размер освобождаемого блока больше ранее отведенного. Последнее чревато особо неприятными последствиями.

Вызовы FreeMem, как и Dispose, в идеале должны быть парны вызовам GetMem. Хотя на практике можно использовать FreeMem вместо Dispose.

Значение ссылочной переменной P после вызова FreeMem считается неопределенным, и ссылаться на P^ в этом случае не стоит.

Если сразу за операторами Dispose или FreeMem следуют конец всей программы или оператор Halt и ему подобные, то можно, в принципе, исключить из программы эти последние процедуры освобождения. Это не совсем по правилам, но может доставить немного радости тем, кто вечно воюет с размером собственных программ. Все сказанное в этом абзаце не относится к резидентным программам.

 

11.5.3. Процедуры Mark и Release

Механизм действия этих процедур следующий. Пусть переменная P имеет предопределенный тип Pointer, а P1, P2, P3 и P4 объявлены как ссылочные переменные. Пусть текст программы содержит фрагмент

- 203 -

...

New(P1);

New(P2);

Mark(P); { вызов Mark }

New(P3);

New(P4);

...

Release(P); { вызов Release }

...

Перед вызовом процедуры Release куча будет иметь вид, как на рис. 11.4.

Рис. 11. 4

При вызове процедуры Mark в переменную P записалось значение HeapPtr, которое было сразу после размещения P2. Далее были размещены P3 и P4, и указатель HeapPtr передвинулся туда, где он изображен на рис. 11.4.

Если теперь осуществить вызов Release (P), то указатель заполнения кучи HeapPtr переустановится в «позицию», которая была запомнена ранее в указателе P. Куча примет вид, показанный на рис. 11.5.

Рис. 11.5

- 204 -

Действие Release (P) проявилось в том, что куча вернулась в предыдущее состояние, «забыв» обо всех динамических переменных, созданных после выполнения процедуры Mark(P). Теперь уже не надо освобождать ссылки P3 и P4. Их нет, как будто они и не размещались.

Из механизма работы процедуры Release следует, что всю кучу можно освободить одним оператором Release ( HeapOrg ), который приводит ее к исходному пустому состоянию.

Очевидно, что пара процедур Mark/ Release — это очень мощное средство управления кучей. Они позволяют эффективно освобождать память с минимальными усилиями. Однако за это приходится платить гибкостью использования пространства кучи. При их применении освобождение памяти должно производится в порядке, обратном размещению динамических переменных. Так, например, нельзя удалить переменную P2^, не удалив при этом переменные P3^ и P4^. Для более гибкого использования кучи необходимо применять процедуры Dispose и FreeMem.

Вместе с тем не рекомендуется перемежать вызовы процедур Release с вызовами процедур Dispose и FreeMem. Две последние действуют избирательно и могут освобождать блоки памяти в используемой части кучи. Так, если после строки New(P4) в рассмотренном примере поставить вызов Dispose (P1), то перед выполнением Release (P) на месте динамической переменной P1^ будет пусто, и это пустое место могло бы быть потом использовано для размещения других данных. Координаты этого пустого (свободного) блока хранятся в специальном списке свободных блоков. Процедура Release (P) среди всего прочего стирает список свободных блоков, навсегда блокируя тем самым доступ к свободным блокам, находящимся ниже значения указателя P. Об этом надо помнить всегда, иначе можно легко и незаметно заблокировать всю кучу и потерять массу времени на нетривиальное решение вечного вопроса «почему программа не пошла?»

 

11.5.4. Функции MaxAvail и MemAvail

Обе эти функции анализируют количество свободной памяти, как еще не использованной, так и получившейся в результате освобождения динамических переменных процедурами Dispose и FreeMem. Возвращаемые значения этих функций имеют тип LongInt.

Функция MaxAvail возвращает длину в байтах самого длинного свободного блока. Она находится как максимальное значение из размера свободной части кучи и размеров освобожденных к данному

- 205 -

моменту блоков. Выдаваемое MaxAvail значение имеет смысл размера наибольшей сплошной структуры данных (как массив, запись, объект), которая могла бы уместиться в куче. Правда, такая сплошная структура данных сама ограничена размером в 65520 байт.

Полный объем свободного пространства (памяти) в куче можно опросить функцией MemAvail. Она вернет сумму длин всех свободных блоков в куче: и освобожденных, и еще ни разу не использованных.

Эти две функции полезны при анализе ресурсов памяти перед размещением динамических переменных, особенно процедурой GetMem. На рис. 11.6 показан пример их использования.

| PROGRAM TestHeap; {ПРОГРАММА, АНАЛИЗИРУЮЩАЯ МЕСТО В КУЧЕ}

| TYPE

| Dim = Array [1..5000] of LongInt; { базовый тип }

| VAR

| P : ^Dim; { ссылка на базовый тип — массив }

| Psize : LongInt; { переменная для анализа размера }

| CONST

| SL = SizeOf(LongInt); { размер элемента массива }

| BEGIN

| WriteLn( 'В куче свободно ', MemAvail, ' байт' );

| {Psize округляется до целого числа значений LongInt:}

| Psize := SL*(MaxAvail div SL);

| if SizeOf(Dim) > Psize

| then begin { мало места в куче }

| WriteLn('Массив P^ не может быть размещен целиком');

| GetMem( P. Psize ); { отводим Psize байт }

| WriteLn( ' Размещено ', Psize div SL, ' элементов' )

| end

| else begin { достаточно места }

| New( P ); { размещаем массив }

| Psize := SizeOf(Dim); { объем массива P^ }

| WriteLn( 'Динамический массив P размещен' )

| end ;

| { ... работа с динамическим массивом ... }

| FreeMem(P, Psize);{универсальное освобождение массива}

| END.

Рис. 11.6

 

11.5.5. Более детальный анализ состояния кучи

Этот подраздел посвящен детальному разбору механизма ведения учета свободных блоков в куче, и может быть опущен при ознакомительном чтении без потерь для целостности изложения.

- 206 -

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

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

Указатель на список свободных блоков хранится в предопределенной системной переменной FreePtr типа Pointer. Эта переменная фактически указывает на массив записей типа FreeList, т.е. соответствует типу FreeListP:

TYPE

FreeRec = RECORD { Указатели на }

OrgPtr, EndPtr : Pointer; { начало и конец }

END; { блока в куче }

FreeList = Array [0..8190] of FreeRec;

FreeListP = ^FreeList; { ссылка на массив записей }

Поля OrgPtr и EndPtr каждой записи определяют начало и конец каждого свободного блока (EndPtr, точнее говоря, указывает на первый байт после блока) и являются нормализованными указателями.

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

Число освобожденных пустых блоков (элементов в массиве FreeList) на текущий момент можно вычислить по формуле

FreeCount := (8192 - Ofs(FreePtr^) div 8) mod 8192;

Максимальное число свободных блоков, которые могут существовать одновременно, равно емкости массива FreeList (8191 блок). Число это достаточно велико, чтобы достичь его на практике. Если же это удастся, то возникнет фатальная ошибка и останов программы.

Ошибка может возникнуть также, когда куча заполнена и список свободных блоков почти смыкается с верхней границей заполнения кучи. При этом попытка освобождения блока, не лежащего на вершине кучи, будет приводить к расширению списка и возникновению ошибочной ситуации. Для решения этой проблемы монитор кучи использует системную переменную FreeMin типа Word, которую можно применять для управления минимальным размером

- 207 -

участка памяти между HeapPtr и списком свободных блоков (FreePtr). Для этого необходимо в FreeMin записать гарантированный размер этого участка в байтах. Чтобы при этом не происходило потерь памяти, значение размера должно быть вычислено как

ЧИСЛО_ЭЛЕМЕНТОВ_СПИСКА_В_ЗАЗОРЕ*8,

где 8 — размер записи FreeRec. Когда значение FreeMin не равно нулю, вызовы процедур New и GetMem будут неэффективными, если они пытаются сделать расстояние между HeapPtr и FreePtr меньше FreeMin. Кроме того, MaxAvail и MemAvail будут вычитать FreeMin из возвращаемых значений.

Иногда необходимо знать величину еще ни разу не использованного пространства кучи (между значениями указателей FreePtr сверху и HeapPtr снизу). Функция HeapAvail, анализирующая размер именно этого пространства (без учета освобожденных блоков в куче), приводится на рис. 11.7.

| { $М 1024, 4000, 4000} (*заданные параметры кучи для теста*)

| FUNCTION HeapAvail : LongInt;

| VAR

| LongSeg, LongFreePtr, LongHeapPtr : LongInt;

| BEGIN

| LongSeg := Seg(FreePtr^)+$1000*Byte(Ofs(FreePtr^)=0);

| LongFreePtr :=(LongSeg * 16 ) + Ofs(FreePtr^);

| LongSeg := Seg( HeapPtr^);

| LongHeapPtr := ( LongSeg*16 ) + Ofs( HeapPtr^);

| HeapAvail := LongFreePtr – LongHeapPtr

| END;

| procedure WriteAvail; { вспомогательная процедура }

| begin

| WriteLn( ' MemAvail=', MemAvail :6,

| ' MaxAvail=', MaxAvail :6,

| ' HeapAvail=', HeapAvail :6 )

| end ; {WriteAvail}

| VAR { ПРИМЕР АНАЛИЗА ПАМЯТИ КУЧИ }

| P1, P2 : Pointer;

| BEGIN

| WriteLn( 'Начало работы:' ); WriteAvail;

| GetMem ( P1, 1000 ); { отводится 1000 байт в куче }

| GetMem ( Р2, 10 ); { отводится 10 байт в куче }

| WriteLn('Размещены в куче 2 переменные(1000 и 10 б)');

| WriteAvail;

| FreeMem( P1, 1000 ); { освобождается первый блок }

- 208 -

{Сейчас в куче появилась дыра, а в списке свободных блоков появились ее координаты, уменьшив кучу на 8 байт.}

| WrfteLn( 'Освобождена ссылка на 1000 байт:' );

| WriteAvail;

| FreeMem( P2, 10 ); { освобожден второй блок }

| { Теперь вся куча пуста, и нет нужды в списке блоков. }

| WriteLn( 'Освобождена ссылка на 10 байт:' );

| WriteAvail;

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 11.7 (окончание)

Заметьте, что все локальные параметры в функции HeapAvail имеют тип LongInt, чтобы хранить десятичные значения ненормализованных (абсолютных) адресов. Чтобы избежать потери порядка из-за превышения диапазона типа Word, значения функций Seg(...) перед умножением переписываются в переменную более «длинного» типа LongInt.

Следующий вопрос, связанный со списком свободных блоков, — это потенциальная проблема дробности. Она связана с тем, что дробность в мониторе кучи равна одному байту. Это означает, что при размещении одного байта переменная будет занимать один байт. При размещении и удалении в произвольном порядке большого числа переменных или блоков различной длины могут появляться свободные блоки небольшого размера, причем число таких блоков может быть большим. Так, например, при освобождении блока размером 20 байт и размещении вслед за этим блока размером 19 байт, появится свободный блок длиной 1 байт, который может находиться в списке свободных блоков довольно долго. Для решения этой проблемы справочное руководство по Турбо Паскалю советует воспользоваться следующим приемом. Каждый раз выделять и впоследствии освобождать блок с размером, кратным какому-либо целому числу байтов. Для этого необходимо переопределить процедуры GetMem и FreeMem. Например, если мы хотим выделять память блоками с размером, кратным 16 байт, то переопределения GetMem и FreeMem будут выглядеть следующим образом:

PROCEDURE GetMem( VAR P : Pointer; Size : Word );

BEGIN

System.GetMem(P, (Size+15) and $FFF0);

END; { GetMem }

- 209 -

PROCEDURE FreeMem( VAR P : Pointer; Size : Word );

BEGIN

System.FreeMem( P, (Size+15) and $FFF0);

END; { FreeMem }

В этом случае минимальный размер свободного блока будет не меньше 16 байт. Однако это будет справедливо до тех пор, пока не будут применены процедуры New и Dispose. Процедура New, например, может для переменной, имеющей размер, не кратный 16 байт, использовать такой свободный блок, что останется пустой излишек с размером менее 16 байт. И уж он-то будет находиться в памяти очень долго. Ситуация осложняется еще тем, что мы теперь уже не можем так просто управлять размером выделяемого блока. Возможным средством улучшить ситуацию является приведение размера динамической переменой к величине, кратной 16 байт. Так, например, если необходимо размещать в куче переменные типа:

TYPE

Dot = RECORD x,y : Real END;

размером 12 байт (6+6), то его размер необходимо увеличить еще на 4 байта. Для этого вместо приведенного выше описания необходимо дать следующее:

TYPE

Dot = RECORD

х, у : Real;

foo : Array [1..4] of Byte

END;

Теперь при размещении переменной типа Dot память будет выделяться и, что самое главное, освобождаться блоками по 16 байт. Заметим, что в принципе можно было бы отказаться от использования процедур New и Dispose и управлять памятью с помощью одних лишь процедур GetMem и FreeMem, хотя это вызвало бы определенные трудности при работе с объектами.

 

11.5.6. Обработка ошибок распределения памяти

По умолчанию при возникновении ошибки монитора кучи происходит аварийный останов программы. Однако эту ситуацию можно изменить, если воспользоваться системной переменной HeapError типа Pointer, которая указывает на функцию со следующим заголовком:

FUNCTION ИмяФункции( Size : Word ) : Integer;

- 210 -

Обычно ее называют HeapFunc. Эта функция вызывается в случае, когда New или GetMem не может обработать запрос на распределение кучи. Параметр Size содержит размер блока, который не мог быть распределен, и функция обработки ошибки должна попытаться освободить блок размером не меньше Size. В качестве результата функция должна возвращать значения 0, 1 или 2. В случае 0 немедленно будет возникать фатальная ошибка и останов программы. В случае 1 вместо аварийного завершения процедуры New или GetMem будет возвращаться указатель, равный nil. Наконец, 2 означает как бы замалчивание ошибки, но вызывает повторение запроса на распределение, что, впрочем, может опять вызвать ошибку.

Необходимо, чтобы эта функция компилировалась в режиме {$F+}. Функция обработки ошибки (пусть в программе она названа UserHeapFunc) может быть подставлена в монитор кучи присваиванием ее адреса системной переменной HeapError:

HeapError := @UserHeapFunc;

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

{$F+}

FUNCTION HeapFunc(Size : Word) : Integer;

BEGIN

HeapFunc := 1

END;

{$F-}

и подставить эту функцию через переменную HeapError. Теперь можно анализировать последствия работы любой процедуры размещения динамических переменных:

...

New(P);

if P = nil then обработка ситуации нехватки памяти;

{иначе нормальная работа с P^}

...

Если пойти еще дальше, то можно написать функцию HeapFunc такой структуры:

- 211 -

($F+}

FUNCTION HeapFunc( Size : Word ) : Integer;

BEGIN

{ ОСВОБОЖДЕНИЕ КАКИМ-ЛИБО СПОСОБОМ Size БАЙТ В КУЧЕ }

HeapFunc := 2 {и повтор неудачного распределения }

END;

{$F-}

Начальное значение переменной HeapError при старте программы равно nil. Его же надо восстанавливать, если отпала необходимость в обработке ошибок кучи.

 

11.6. Ссылки, работающие не с кучей

Традиционно понятие «ссылка» всегда увязывается с динамическими переменными, кучей и т.п. У Турбо Паскаля тоже есть традиции. Одна из них — расширение общепринятых стандартов. В частности, ничто, кроме традиционных учебников стандартного Паскаля, не обязывает связывать ссылки или указатели именно с кучей. Ссылки могут указывать на что угодно: даже на выполнимый код программы (крайний и бесполезный случай). Обычно в разных трюках ссылки связываются со статическими данными или с системными областями памяти ПЭВМ (областью данных БСВВ, видеопамятью и др.).

Кроме способа связывания, такие ссылки ничем не отличаются от рассмотренных ранее (рис. 11.8).

| PROGRAM NoHeap;

| { ПРИМЕР ССЫЛОК БЕЗ ИСПОЛЬЗОВАНИЯ КУЧИ }

| TYPE { базовые типы: }

| VideoArray=Array[1..4000] of RECORD {структура экрана }

| Symbol : Char;

| Attrib : Byte

| END;

| Vector=Array[1..100] of Real; { одномерный массив }

| Matrix=Array[1..10,1..10] of Real;{ матрица 10 на 10 }

| VAR

| VideoPtr : ^VideoArray; { ссылка на структуру экрана }

| Vec : Vector; { ссылка на одномерный массив }

| MatPtr : ^Matrix; { ссылка на массив — матрицу }

| P : Pointer; { просто указатель }

| i : Word; { счетчик для циклов }

Рис. 11.8

- 212 -

| BEGIN

| VideoPtr := Ptr( $B800, 0 );

{Переменная VideoPtr теперь содержит адрес начала видеопамяти в цветных и черно-белых режимах. Для режима mono надо подставить в присваивании Ptr{$B000,0). После этого можно непосредственно обращаться к видеопамяти. }

| for i:=1 to 4000 do begin

| { Заполнение видеопамяти}

| VideoPtr^[i].Symbol:= '+'; { символом '+' в ярко- }

| VideoPtr^[i].Attrib:=15+128 { белом цвете с мерцанием}

| end { for };

| ReadLn; { пауза до нажатия клавиши ввода }

| { Заполнение статического массива Vec: }

| for i:=1 to 100 do Vec[i] := i*3.14;

| MatPtr := Addr(Vec); {передача его адреса ссылке MatPtr}

{Теперь к 100 элементам одномерного массива Vec можно обращаться и как к элементам матрицы 10x10, используя разыменование ссылочной переменной MatrPtr^. Здесь мы распечатаем диагональные элементы матрицы: }

| for i:=1 to 10 do WriteLn(' ':i, MatPtr^[i,i]:-9:2 );

| ReadLn; { пауза до нажатия клавиши ввода }

| { и т.п. }

| END.

Рис. 11.8 (окончание)

Советуем внимательно рассмотреть пример на рис. 11.8. В нем нет ни процедур New/Dispose, ни GetMem/FreeMem! Динамические переменные здесь не создаются и не освобождаются. Взамен этого в ссылки «ручным способом» записываются адреса тех блоков памяти, с которыми мы хотели бы работать. А далее мы обращаемся с ними, как будто они есть структурированные динамические переменные.

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

 

11.7. Как организовать структуры, большие чем 64К?

Цифра 64K постоянно преследует разработчика больших программ. Сумма размеров всех глобальных переменных и типизированных констант не может превышать 64K. Размер типа тоже не может превышать 64K:

- 213 -

TYPE { матрица 200x200 }

Dim200x200 = Array [1..200, 1..200] of Real;

В таком описании размер типа равен 200x200x6 байт, что составит более 234К. Компилятор этого ни за что не пропустит, и переменная типа Dim200x200, понятно, не может быть объявлена. С другой стороны, эти 240K вполне могли бы разместиться в средних размеров куче. И это можно сделать!

Нужно лишь реорганизовать этот массив так, чтобы он распался на части, не превышающие по отдельности 64K каждая:

TYPE

Dim200 = Array [1..200] of Real;

Dim200Ptr = ^Dim200;

Dim200x200 = Array [1..200] of Dim200Ptr;

VAR

D : Dim200x200;

Здесь мы определяем тип Dim200 (тип строки матрицы) и тип ссылки на строку Dim200Ptr. После этого определяется тип матрицы 200x200 как статический массив из 200 ссылок на динамические массивы по 200 элементов. Последние вполне могут поместиться в куче. Тем более, что для каждого массива понадобится блок длиной 200x6 байт, а сами эти блоки могут размещаться в разных частях кучи. Размещение такой структуры немного усложнилось:

for i:=1 to 200 do New( D[i] );

как и освобождение:

for i:=1 to 200 do Dispose( D[i] );

Обращение к элементу массива D (разыменование) имеет вид D[i]^[j], где i — номер строки, a j — номер столбца.

Описанный прием достаточно эффективен для многомерных массивов и записей. Таким образом, можно заменять части структуры ссылками на них и забыть про предел в 64K. Но с одномерным массивом так поступить уже нельзя. Придется искать какие-либо обходные пути.

Существует несколько способов хранения данных и их структур, которые ограничены лишь свободным объемом памяти (ОЗУ). К ним относятся списочные структуры, деревья (графы). Отдельно можно выделить структуры типа «стек».

Список — это набор записей, каждая из которых имеет поле данных и указатель (ссылку) на следующую запись в списке. Та, в свою очередь, тоже содержит поле данных и ссылку на продолжение списка. Последний элемент списка (хвост) содержит значение

- 214 -

ки* nil, т.е. уже ни на что не ссылается. Списки легко создаются, добавляются с любого конца; их можно размыкать для вставки нового элемента, исключать элементы и т.д.

* Так напечатано. Видимо при печати пропущена часть текста.— Ю. Ш.

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

Вместо этого мы предлагаем пример модуля, реализующего процедуры работы со стеком. Стек, или магазин, иногда называется списком LIFO (последним вошел — первым вышел). Это структура данных, при которой элемент, первым помещенный в стек, будет извлечен оттуда последним. И наоборот, доступнее всех последний положенный в стек элемент. Аналог стека — детская разборная пирамидка из дисков на штырьках. Надеть диск сверху — значит поместить в стек очередное значение. Снять диск (а снять можно только верхний диск) — значит вытолкнуть значение из стека. Доступ к содержимому стека всегда последователен, причем порядок выгрузки элементов из стека обратен порядку их загрузки в стек.

 

11.8. Практический пример построения стека

Организация стека основана на связном списке, и поэтому стек занимает в памяти только необходимый на данный момент объем. Наглядно структура стека представлена на рис. 11.9.

Рис. 11.9

- 215 -

Сумма размеров всех хранимых в стеке данных ограничена только размером свободной памяти в куче, хотя элемент данных по-прежнему не должен превышать 64K. Стек оптимален для случаев, когда требуется просчитать и запомнить большое число структур данных, а потом обработать их в обратном порядке (в других случаях он мало полезен). К недостатку стека и списков, вообще, надо отнести расход памяти под узлы (здесь — 2x4 байта на каждый узел). Но если элемент хранимых данных имеет размер, например, 16K, с восемью байтами можно примириться.

Ниже приведен текст модуля StackManager (рис. 11.10), реализующего операции со стеком и пример программы, использующей его (рис. 11.11). Все тексты написаны и любезно предоставлены Г.П. Шушпановым.

| UNIT StackManager; {БИБЛИОТЕКА СРЕДСТВ РАБОТЫ СО СТЕКОМ }

| INTERFACE

| CONST { коды ошибок, возникающих при работе со стеком }

| StackOk =0; { успешное завершение }

| StackOverflow =1; { переполнение стека }

| StackUnderflow =2; { стек был пуст }

| VAR

| StackError : Byte; { результат операции со стеком }

| TYPE

| NodePtr = ^Node; { ссылка на узел }

| Node = RECORD { Узел, состоящий из }

| Info : Pointer; { ссылки на значение и }

| Next : NodePtr; { ссылки на следующий }

| END ; { узел. }

| Stack = RECORD { тип стека - запись }

| Head : NodePtr; { ссылка на голову списка }

| Size : Word; { размер элемента данных в }

| END ; { стеке }

| PROCEDURE InitStack( VAR S : Stack; Size : Word );

| { формирует стек с элементами размера Size }

| PROCEDURE ReInitStack(VAR S : Stack; Size : Word);

| { переопределяет стек для элементов другого размера }

| PROCEDURE ClearStack( VAR S : Stack );

| { очищает стек }

| PROCEDURE Push( VAR S : Stack; VAR E );

| { помещает значение переменной E в стек S }

Рис. 11.10

- 216 -

| PROCEDURE Pop( VAR S : Stack; VAR E );

| { выталкивает значение из стека в переменную E }

| PROCEDURE Top( VAR S : Stack; VAR Е );

| { копирует значение на вершине стека в переменную E }

| FUNCTION Empty( VAR S : Stack ) : Boolean;

| { возвращает True, если стек пуст }

| IMPLEMENTATION

| VAR { переменная для хранения }

| SaveHeapError : Pointer; { адреса старой функции }

| { обработки ошибок кучи }

| {$F+}

| FUNCTION HeapFunc( Size : Word ) : Integer;

| BEGIN

| HeapFunc := 1;

| {вернуть nil, если нельзя разместить переменную в куче}

| END;

| {$F-}

| PROCEDURE InitStack( VAR S : Stack; Size : Word );

| BEGIN { сохранение стандартного }

| SaveHeapError := HeapError; { обработчика ошибок кучи }

| S.Head := nil; { установка вершины }

| S.Size := Size; { размер значения }

| StackError := StackOk; { все в порядке }

| END;

| PROCEDURE ReInitStack(VAR S : Stack; Size : Word );

| BEGIN

| if S.Head <> nil then

| ClearStack(S); { очистка стека }

| S.Size := Size; { установка нового размера значения }

| StackError := StackOk; { все в порядке }

| END;

| PROCEDURE СlearStack(VAR S : Stack);

| VAR Deleted : NodePtr; { удаляемый элемент }

| BEGIN

| StackError := StackOk;

| while S.Head <> nil do

| begin { Цикл по всем элементам:}

| Deleted := S.Head; { удаляемый узел }

| S.Head := Deleted^.Next; { продвижение вершины }

| FreeMem(Deleted^.Info,S.Size); { удаление значения }

| Dispose(Deleted); { удаление узла }

| end { while }

| END;

Рис. 11.10 (продолжение)

- 217 -

| PROCEDURE Push( VAR S : Stack; VAR E );

| LABEL Quit;

| VAR

| NewNode : NodePtr; { новый узел }

| BEGIN { Подстановка функции }

| HeapError := @HeapFunc; { обработки ошибок. }

| StackError := StackOverflow; { возможно переполнение }

| NewNode := New(NodePtr); { размещение узла }

| if NewNode = nil

| then goto Quit; { Негде! Выход. }

| NewNode^.Next := S.Head; { установление связи }

| S.Head := NewNode; { продвижение вершины }

| GetMem(NewNode^.Info,S.Size); { размещение значения }

| if NewNode^.Info = nil

| then goto Quit; { Негде! Выйти. }

| Move(E, NewNode^.Info^,S.Size); { перенос значения }

| StackError := StackOk; { Все в порядке. Выход }

| Quit:

| HeapError := SaveHeapError; { вернем старую функцию }

| END;

| PROCEDURE Pop( VAR S : Stack; VAR E );

| VAR Deleted : NodePtr; { выталкиваемый узел }

| BEGIN

| StackError := StackUnderflow; { возможна неудача }

| if S.Head = nil then Exit; { Стек пуст! Выход. }

| Deleted := S.Head; { удаляемый узел }

| S.Head := Deleted^.Next; { продвижение вершины }

| Move(Deleted^.Info^,E,S.Size); { перенос значения }

| FreeMem(Deleted^.Info,S.Size); { удаление значения }

| Dispose(Deleted); { удаление узла }

| StackError := StackOk; { все в порядке }

| END;

| PROCEDURE Top( VAR S : Stack; VAR E );

| BEGIN

| StackError := StackUnderflow; { возможна неудача }

| if S.Head = nil then Exit; { Стек пуст! Выход. }

| Move(S.Head^.Info^,E.S.Size); { перенос значения }

| StackError := StackOk; { все в порядке }

| END;

| FUNCTION Empty( VAR S : Stack ) : Boolean;

| BEGIN

| Empty := S.Head = nil { пусто, если список пуст }

| END;

| END . { unit StackManager }

Рис. 11.10 (окончание)

- 218 -

| PROGRAM UsesStack;{ПРОГРАММА, ХРАНЯЩАЯ ЗНАЧЕНИЯ В СТЕКЕ}

| USES StackManager; VAR

| St : Stack; { переменная структуры типа Stack (стек) }

| I : Integer;

| R : Real;

| В : Byte;

| BEGIN

| InitStack( St, SizeOf( Integer ) ); { стек целых }

| { Поместить в стек 100 целых значений: }

| for I:=1 to 100 do Push( St, I );

| WriteLn( ' ':20, 'Первые 100 чисел' );

| WriteLn( ' ': 20, '(целые значения)' );

| WriteLn;

| while not Empty(St) do begin { Пока стек не пуст: }

| for В := 1 to 10 do begin {порциями по 10 элементов}

| Pop( St, I ); { вытолкнуть очередное зна- }

| Write( I:5 ) { чение и напечатать его }

| end ; { for В }

| WriteLn { закрытие строки 10 чисел }

| end ; { while }

| ReadLn; { пауза до нажатия ввода }

| ReInitStack(St,SizeOf(Real)); {изменяется тип данных }

| { Поместить в стек 100 вещественных значений: }

| for I := 1 to 100 do begin

| R := I; { перевод в тип Real }

| Push( St, R ); {и поместить его в стек }

| end ; { for I }

| WriteLn( ' ':20, 'Первые 100 чисел' );

| WriteLn( ' ': 17, '(вещественные значения)' );

| WriteLn;

| while not Empty(St) do begin { Пока стек не пуст: }

| for B:=1 to 10 do begin { порциями по 10 элементов: }

| Pop( St,R ); { вытолкнуть следующее зна- }

| Write( R : 5 : 1 ) { чение и напечатать его }

| end ; { for В }

| WriteLn { закрытие строки 10 чисел }

| end ; { while }

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 11.11

Обращаем внимание на рекурсивность в определении списка (вернее, его узла типа Node на рис. 11.10). В самом деле, тип ссылки на узел (NodePtr) определен, до того как задан сам тип узла Node.

- 219 -

Но в то же время поле Next узла имеет тот же тип NodePtr. Этот парадокс типов Паскаля разрешается самим компилятором. Можно определять ссылки на данные, содержащие элементы того же типа ссылки. Рекомендуется именно такой способ их задания, как в примере. Однако можно было бы перенести описание типа NodePtr за описание типа Node — ничего страшного не произошло бы.

- 220 -

 

12.1. Понятие логического файла

Логический файл описывается как переменная одного из файловых типов, определенных в Турбо Паскале. После того как в программе в разделе описания переменных объявлена файловая переменная, она может быть использована как средство общения с любым физическим файлом, независимо от природы последнего. Само имя физического файла может появиться в программе только один раз, когда специальной процедурой устанавливается, что объявленный логический файл будет служить средством доступа именно к этому физическому файлу (данным на диске, портам, печати и т.п.) Если, например, мы хотим работать с текстовым файлом 'A:\TEXT.DOC', то в программе должны быть такие строки:

- 221 -

VAR

f : Text; { объявляем файловую переменную f (вводим

логический файл типа текст) }

BEGIN

Assign( f, 'A:\TEXT.DOC' ); { связываем физический файл 'a:\text.doc'

на диске А: с логическим файлом f }

...

END.

После этого все обращения к файлу на диске будут производиться через файловую переменную f.

Введение логического файла позволяет программисту не задумываться о технических проблемах организации обмена данными, а заняться программированием самого потока данных. Различные физические файлы имеют различные механизмы ввода и вывода информации. Все особенности физических файлов «спрятаны» в механизме логических файлов, которые сами определяют, как наладить обмен данными со связанными физическими файлами. Иными словами, логические файлы унифицируют работу с файлами, позволяя работать не непосредственно с устройствами ПЭВМ, а с их логическими обозначениями.

 

12.2. Физические файлы в MS-DOS

Что такое физические файлы? Ответ на этот вопрос лучше искать не в руководствах по Турбо Паскалю, а в описаниях MS-DOS. Все, что является файлом в MS-DOS, является физическим файлом в Турбо Паскале. Банальный пример — файл с данными на диске (гибком, жестком, виртуальном — все равно). Определяется физический файл строкой с его названием (именем). В Турбо Паскале имена могут быть строковыми константами или храниться в строковых переменных. Имя файла на диске может иметь адресную часть, оформленную в соответствии с правилами MS-DOS:

'C:\PAS\TESTFILE.PAS' ,

'A:TEST.TXT'

'..\PRIMER.BAS'

Другая разновидность физических файлов — это устройства MS-DOS. MS-DOS не делает особого различия между «традиционными» файлами и устройствами (портами коммуникаций). Устройства имеют свои фиксированные имена и во многом схожи с файлами: имя устройства, например, может встать на место имени файла на диске при копировании. Имена устройств

- 222 -

MS-DOS и необходимые замечания по ним сведены в табл. 12.1.

Таблица 12.1

Физические файлы-устройства организуются как текстовые файлы, и для нормальной работы их надо связывать с текстовыми логическими файлами. Хотя, если понадобится, можно устанавливать связь и с бестиповымн файлами (например, при работе с 'COM1' или 'COM2').

Как видно из табл. 12.1, у устройства есть свои особенности. Например, 'CON' — одно имя двух устройств. Если логический файл, которому назначено устройство 'CON', открывается для чтения, то в действительности он связывается с клавиатурой, но если для записи, то — с экраном! В то же время 'LPT1'...'LPT3', 'PRN', а с ним и 'NUL', могут быть открыты только для записи в них, а если все же они открыты для чтения, то сразу же возвращают признак конца файла. Никакого сбоя при этом не будет. Серийные порты — двусторонние. Позволяют считывать из себя и принимать данные. «Файл-пустышка» 'NUL' нужен для отладки программ, использующих другие порты.

Имена физических файлов-устройств должны быть записаны так же, как и в таблице: без точек и прочих знаков после них. Регистр букв роли не играет: 'CON', 'con' — консоль, 'PRN' — принтер, но

- 223 -

'CON.' — это файл на текущем диске, с именем CON и пустым расширением. Можно приписывать после имени устройства двоеточие, но лучше обходится без этого. Так, 'PRN' и 'PRN:' — это одно и то же.

Не определена такая структура данных, как файл в памяти ПЭВМ. Любой объявленный логический файл имеет смысл только после связи с внешним физическим файлом.

Турбо Паскаль позволяет программировать собственные механизмы для работы с периферией ПЭВМ или виртуальными устройствами — так называемые драйверы текстовых устройств. Но для этого надо вручную переписать почти всю библиотеку процедур работы с файлами. Заинтересованные читатели могут найти нужную им информацию в справочном руководстве по Турбо Паскалю [2].

 

12.3. Понятие буфера ввода-вывода

С файловой системой Турбо Паскаль связано понятие буфера ввода-вывода. Может показаться странным, но если выполнилась команда записи данных в файл на диске, то это вовсе не означает, что на диске действительно появились новые данные. Вывода данных (как впрочем, и ввод), осуществляется через буфер. Буфер – это область в памяти, отводимая при открытии файла. При записи в файл вся информация сначала направляется в буфер и там накапливается до тех пор, пока весь объем буфера не будет заполнен. Только после этого или после специальной команды сброса буфера происходит передача данных по предназначению: на диск, порт. Аналогично при чтении из файла считывает не столько, сколько запрашивается, с сколько уместится в буфер. И если, например, считывается 4 числа, а буфер вмещает 64, то следующие 60 чисел будут считаны уже из буфера.

Механизм буферизации позволяет более быстро и эффективно обмениваться информацией с различными устройствами. Для текстовых и бестиповых файлов можно устанавливать размер буфера по своему усмотрению.

Вывод текстовой информации на экран реализован так, что эффект буферизации исчезает автоматически, иначе компьютер постоянно «недоговаривал» бы свои ответы.

 

12.4. Файловые типы Турбо Паскаля

Турбо Паскаль поддерживает три файловых типа:

— текстовые файлы (типа Text);

- 224 -

— компонентные файлы (типа File Of ... );

— бестиповые файлы (типа File).

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

Текстовые файлы — это файлы, состоящие из кодов ASCII, включая расширенные и управляющие коды. Текстовые файлы организуются по строкам и обязательно содержат специальный код, называемый концом файла. Любую информацию (числовую, символьную или строчную) текстовый файл хранит в виде символов, ее изображающих. Например, текст программы на Паскале — это текстовый файл. Его можно вывести на экран командой MS-DOS TYPE или на печать командой PRINT и прочитать. Но выполняемый ЕХЕ-файл, полученный после компиляции, уже не будет текстовым. И, если удается увидеть или распечатать его содержимое, то прочитать, например, как эту страницу точно не удается. Пример текстового файла — бегущие строки на экране дисплея, когда он работает в текстовом режиме. При наборе букв и цифр на клавиатуре, создается текстовый файл.

Компонентные файлы в отличие от текстовых состоят из машинных представлений чисел, символов и структур, из них построенных. Они хранят данные в том же виде, что и память ПЭВМ. Поэтому посредством компонентных файлов можно осуществлять обмен данными только между дисками и рабочей памятью программы, но нельзя, например, напрямую вывести данные на экран.

Бестиповые файлы также состоят из машинных представлений данных. Отличие их от компонентных файлов в том, что последние имеют дело только с данными заранее объявленного типа, а бестиповые — с произвольными наборами байтов независимо от их структуры и природы. Описание языка определяет бестиповый файл как низкоуровневый канал ввода-вывода для доступа к любым файлам с любым типом.

Для всех типов файлов минимальной единицей хранения информации в них является байт. Принципы работы с файлами едины, хотя и имеются различия в наборах команд для работы с разными файловыми типами. Для всех без исключения файлов необходимо предварительное связывание их логических обозначений (файловых переменных) с физическими файлами.

Файловые переменные, описанные в программе, не могут участвовать в операторах присваивания.

При использовании файловых переменных любого типа в качестве формальных параметров заголовков процедур и функций они всегда должны быть описаны как VAR-параметры.

- 225 -

 

12.5. Общие процедуры для работы с файлами

Турбо Паскаль вводит ряд стандартных процедур, применимых к файлам любых типов (табл. 12.2). Кроме этого, существует ряд их расширений и специальных процедур для работы с различными типами файлов. Такие процедуры будут рассматриваться в разделах, посвященных различным типам файлов. Описания процедур ввода и вывода данных Write, WriteLn, Read и ReadLn не включены в этот раздел, так как они достаточно сильно различаются при работе с разными типами файлов, а иногда (при работе с бестиповыми файлами) и вовсе теряют смысл.

В Турбо Паскале не определены процедуры ввода и вывода в файлы Get(f) и Put(f), и их функции выполняют другие процедуры ввода-вывода. Не определено также обращение к буферной переменной f^.

Таблица 12.2

- 226 -

Файловая переменная f может иметь любой файловый тип.

 

12.5.1. Связывание файлов

Процедура Assign (VAR f; FileName: String) устанавливает связь между логическим файлом, описываемым файловой переменной f любого файлового типа, и конкретным файлом MS-DOS, название которого содержится в строковом параметре FileName. Иными словами, логический файл f связывается с физическим файлом FileName. Строка FileName может содержать имя файла на диске (в том числе полное имя файла), имя стандартного устройства MS-DOS ('CON', PRN' и т.п.) или пустую строку '':

Assign( f, 'file.dat' ); {связь с файлом текущего каталога }

Assign( f, 'a:\x.pas' ); {связь с файлом x.pas на диске А: }

Assign(' f, 'LPT2' ); {связь со вторым принтером ПЭВМ }

Assign( f, ' ' ); {связь со стандартным файлом, как правило файлом 'CON' }

Имя физического файла должно быть корректным и уникальным. Нельзя вставлять символы шаблонов '*' и '?' в имя файла, но можно связывать файловые переменные с еще не существующими файлами на диске (для дальнейшего их создания).

Процедура Assign не занимается анализом корректности имени файла и безоговорочно связывает заданное имя с логическим файлом f. Логический файл при этом считается закрытым, а размер буфера файла — неопределенным. Если файл f связан с некорректным именем, то это вызовет ошибку ввода-вывода лишь при попытке произвести любое действие над ним (будь то открытие файла, удаление его или что-либо другое).

Будучи однажды установленной, связь между файловой переменной f и физическим файлом сохраняется до следующего вызова Assign с той же переменной f. Это означает, что можно проделывать различные операции с файлом f, лишь единожды связав его с физическим файлом:

- 227 -

Assign( f, 'TEST.TMP' ); { установлена связь }

Rewrite( f ); { открытие файла для перезаписи }

Write( f, ...); { запись в файл f }

Close( f ); { закрытие файла (вызов необязателен) }

Reset( f ); { открытие файла для чтения }

Read( f, ...); { чтение из файла f }

Close( f ); { закрытие файла (вызов обязателен) }

Erase( f ); { удаление файла с диска }

После того как логический файл связан с физическим, его можно открыть для чтения или записи.

 

12.5.2. Открытие файлов

Процедуры открытия файлов Reset(VAR f) и Rewrite(VAR f) открывают логический файл f для чтения данных (Reset) или записи (Rewrite). Если процедуры выполняются успешн6о (открытие файла происходит без ошибки), то файл становится открытым и готов к чтению или записи первого элемента в нем. Эти же процедуры фиксируют размер буфера файла (он устанавливается автоматически, если только не был переопределен вызовом SetTextBuf для файлов типа Text или расширенной записью Reset/Rewrite для бестиповых файлов).

После открытия файла (и только после него!) становится возможным чтение или запись данных. Процедуры открытия могут применяться многократно к одном и тому же файлу. Если файл был до этого открыт, то он автоматически предварительно закрывается. Повторный вызов Reset переустановит последовательность чтения вновь на самый первый элемент файла, при этом потеря данных исключена. Но повторное обращение к Rewrite сотрет текущее содержимое файла и подготовит файл к заполнению с первого элемента. Между повторными вызовами процедур открытия не обязательно вставлять оператор закрытия файла Close. Советуем также внимательно просмотреть разд. 12.11 «Обработка ошибок ввода-вывода».

 

12.5.3. Закрытие файлов

Процедура Close(VAR f) закрывает открытый до этого логический файл f. Попытка закрыть уже закрытый (или еще не открытый) файл вызовет сбой программы. Процедура не изменяет связь между файловой переменной f и физическим файлом, но назначает им текущее состояние «закрыт». Это особенно важно для файлов, открытых для записи. Закрытие файла гарантирует сохранность и полноту заполнения. Так, фатальная ошибка в программе

- 228 -

уже не сможет повлиять на содержимое файла после его закрытия.

Заметим, что если программа прервалась из-за ошибки и до  закрытия файла, то он все же будет создан на носителе, но содержимое последнего буфера не будет перенесено в файл. То же самое может случиться и в том случае, если вообще забыть поставить в программу вызовы Close.

Вызовы процедуры Close необходимы при завершении работы с файлами. Также необходимо закрывать открытые файлы перед их удалением (Erase) или переименованием (Rename).

 

12.5.4. Переименование файлов

Процедура Rename( VAR f; NewName : String ) позволяет переименовать физический файл на диске, связанный с логическим файлом f. Процедура выполнима только с закрытым файлом, в противном случае возникнет сбой.

Предполагается, что файловая переменная f была предварительно связана вызовом процедуры Assign с неким физическим файлом, например FileName. Вызов Rename ( f, NewName ) сменит имя физического файла с FileName на NewName. В принципе, процедура Rename выполняет ту же работу, что и команда REN в MS-DOS. Правда, в отличие от последней Rename не может содержать в строковом параметре символы '*' и '?'.

Рассмотрим фрагмент программы (рис. 12.1).

| VAR

| f : File of Real;

| BEGIN

| Assign(f, 'A:\REAL.DAT'); { установлена связь }

| Rewrite( f ); { открытие файла для записи }

| Write( f, ... ); { запись в файл f }

| Close( f ); { обязательно закрытие файла}

| {Пусть теперь надо сменить имя файла 'REAL' на 'FLOAT'}

| Rename( f, 'A:\FLOAT.DAT' ); { Готово! }

Рис. 12.1

Переименование происходит при закрытом файле f. После него можно снова открывать файл, но f будет связана уже с новым именем. Старый файл не резервируется (его имя 'A:\REAL.DAT' замещено на 'A:\FLOAT.DAT').

Будет ошибкой так переименовывать имя, что изменится имя диска и путь к файлу. Например, заведомо ошибочен второй оператор:

- 229 -

Assign( f, 'A:\FILE.AAA');

Rename( f, 'C:\FILE.BBB');

поскольку, кроме имени файла, изменяется содержащий его диск. Ведь таким образом мы задаем перенос файла с А: на С:, а лишь затем его переименование. Перенос же, как и копирование, не определен в языке, и его надо конструировать средствами Турбо Паскаля или использовать внешний вызов командного процессора MS-DOS (см. процедуру Exec модуля DOS).

 

12.5.5. Удаление файлов

Процедура Erase(VAR f) уничтожает (стирает) физический файл на носителе (диске). Файловая переменная f должна быть предварительно связана с существующим физическим файлом. Сам файл к моменту вызова Erase должен быть закрыт.

Чтобы уничтожить файл с именем FileName, достаточно конструкции:

Assign(f, FileName); Erase(f);

где f — файловая переменная любого типа.

Если файл с именем FileName не существует, возникнет сбой при попытке уничтожить его.

 

12.5.6. Анализ состояния файлов

Логическая функция EOF(VAR f ) : Boolean возвращает значение True, когда при чтении достигнут конец файла f. Это означает, что уже прочитан последний элемент в файле или файл f после открытия оказался пуст. Во всех остальных случаях функция возвращает значение False. Состояние EOF обновляется автоматически при каждом обращении к процедуре ввода данных. Файл f должен быть открыт.

Обращение к EOF без указания файла соответствует анализу конца стандартного файла Input (как правило, связанного с клавиатурой). Стандартный файл считается текстовым, и конец файла в нем обозначен символом #26 (в прочих, нетекстовых файлах, явного обозначения конца файла не существует).

Назначение функции EOF — указывать на возникновение конца файла. Наиболее часто EOF используется в цикле while, читающем файл до конца:

while not EOF(f) do { пока не достигнут конец файла f,}

Read( f, ... ); { читать данные из этого файла}

- 230 -

Эта конструкция гарантирует, что чтение прекратится только после считывания последнего элемента в файле с логическим именем f. Обратите внимание, что используется именно цикл while...do, а не repeat...until. Функция EOF постоянно следит за статусом чтения и позволяет опознать конец файла до того, как мы его непосредственно прочитаем.

 

12.6. Текстовые файлы

Определение «текстовые файлы — это те, которые выдают или принимают текстовую информацию» в целом правильно, но не слишком развернуто. Дадим другое определение: текстовые файлы — это файлы, в которых:

1) информация представляется в текстовом виде посредством символов в коде ASCII;

2) порции информации могут разделяться на строки. Признаком конца строки служит символ #13 (код 13 — CR). Он может быть объединен с символом перевода строки #10 (код 10 — LF);

3) конец файла обозначается явно символом ^Z (код 26);

4) при записи чисел, строк и логических значений они преобразуются в символьный (текстовый) вид;

5) при чтении чисел и строк они автоматически преобразуются из текстового представления в машинное.

Бытовые примеры текстовых файлов просты. Если файл можно вывести на экран в текстовом режиме и прочитать его, то это — текст. Клавиатура посылает в компьютер «сплошной» текст-файл. Компьютер посылает на принтер текст-файл, даже если принтер рисует в графическом режиме. Рассмотрим коротенький текст-файл:

| Текст-файл

| [13][10]

| Вы читаете текстовый файл, который [13][10]

| может храниться на диске или печататься [13][10]

| на принтере.[13][10]

| В нем можно хранить цифровые записи чисел:[13][10]

| 123 456 789 0[13][10]

| 234 567 890 1[13][10]

| 1.2 3.4 5.60 4[13][10]

| -100.254 [13][10]

| Конец файла[13][10]

| [26]

Цифры в квадратных скобках — управляющие коды с тем же номером, т.е. [13]=#13. в файле они занимают по одному символу и в текстовых режимах, как правило, на экран и принтер не выводятся (но управляют выводом).

Заметьте, что каждая строка заканчивается признаком конца строки, даже пустая (1-ая сверху). Самый последний символ в файле — признак его конца. Реально файл хранится как сплошная последовательность символов и разбивается на строки лишь при его выводе на экран или печать. Пустой текстовый файл содержит один символ #26.

Для работы с текстовым файлом необходимо определить файловую переменную (переменную логического файла):

VAR

f : Text;

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

В системной библиотеке Турбо Паскаля определены две текст-файловые переменные: Input и Output. Они связаны с устройством 'CON' (или фиктивным устройством CRT, если подключен модуль CRT) автоматически. И если в процедурах ввода опущено имя файла, то считается, что ввод идет из системного файла Input (это клавиатура) , а если имя файла опущено в операторе вывода, то в файл Output (вывод идет на экран).

Текстовые файлы в Турбо Паскале — это вовсе не аналоги файлов типа File of Char. Знак равенства между этими типами можно поставить лишь со значительными оговорками.

 

12.6.1. Текст-ориентированные процедуры и функции

Кроме общих для всех файлов процедур и функций, определены еще несколько, работающих только с текстовыми файлами (табл. 12.3).

Таблица 12.3

Процедуры и функции	Действие
SetTextBuf( VAR f : Text; VAR Buf [; BufSize : Word]	Устанавливает размер буфера файла f равным BufSize байт. Должна выполняться перед открытием файла f. Буфер размещается в переменной Buf.
Append( VAR f : Text)	Открывает текстовый файл f для дозаписи в конец файла

- 232 -

Flush( VAR f : Text)	Выводит текущее содержимое буфера f в физический файл, не дожидаясь заполнения буфера до конца. Имеет смысл только при записи в файл
EOLn( VAR f : Text) : Boolean	Функция возвращает True, если текущая позиция в файле — конец строки или конец файла, и False, если нет
SeekEOLn( VAR f : Text) : Boolean	Функция возвращает True, если достигнут конец строки или конец файла, или перед ними стоят лишь пробелы и (или) символы табуляции (#9)
SeekEOF( VAR f : Text) : Boolean	Функция возвращает True, если достигнут конец файла или перед ними стоят лишь пробелы, признаки концов строк и (или) символы табуляции

12.6.1.1. Процедура SetTextBuf( VAR I: Text; VAR Buf [;BufSize: Word]). Эта процедура служит для увеличения или уменьшения буфера ввода-вывода текстового файла f. Автоматическое значение размера буфера для текстовых файлов равно 128 байт. При интенсивном обращении к физическим файлам на диске мы рекомендуем увеличить это число до нескольких килобайт, что существенно ускорит процесс. При этом не так жестоко будут эксплуатироваться головки дисковода. Увеличение буфера должно произойти после связывания логического файла с физическим, но до первой операции ввода или вывода. Советуем взять за правило менять буфер до открытия файла. Это дает гарантию безопасности данных.

Задавая новый буфер, мы должны передать процедуре SetTextBuf не только логический файл f, но и переменную Buf, в которой этот буфер расположится. Это означает, что если под рукой нет пока незанятой переменной, то придется ввести еще одну, соответствующего размера. Тип переменной Buf не имеет значения. Важен ее размер. Буфер файла начнется с первого байта, отведенного Buf, и займет столько байт, сколько задано в необязательном параметре BufSize. Если в вызове процедуры число BufSize не указано, то

- 233 -

считается, что оно равно размеру переменной Buf. Задание BufSize больше, чем размер самой Buf, приведет к потере данных, «соседних» по памяти с Buf.

Рассмотрим вариант использования SetTextBuf (рис. 12.2).

| VAR

| ft : Text; { текстовый логический файл }

| Buf : Array [1..4*1024] of Byte; { его новый буфер }

| BEGIN

| Assign(ft,'TEXTFILE.DOC'); {файл связывается с диском }

| SetTextBuf( ft, Buf ); {меняется буфер (теперь он }

| {в переменной размером 4K) }

| Reset( ft ); {открытие файла }

| Read( ft,...) {операции ввода - все как обычно }

| Reset( ft ); { возврат в самое начало файла }

| { буфер no-прежнему в Buf, 4K }

| Прочие действия с файлом ft

| ...

| END.

Рис. 12.2

Будучи однажды установленным для файла ft, буфер не меняет своего места и (или) размера до следующего вызова SetTextBuf или Assign с той же файловой переменной ft.

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

| PROCEDURE GetFileAndOpenIt( VAR f : Text );

| VAR

| Buffer : Array [1..16*1024] of Byte; { буфер }

| FileName : String; { имя файла }

| BEGIN

| ReadLn( FileName ); { считывается имя файла }

| Assign( f, FileName );

| SetTextBuf( f, Buffer ); { назначение буфера }

| Rewrite( f ) { открытие файла f }

| END;

Рис. 12.3

- 234 -

| VAR

| ff : Text;

| BEGIN { основная часть примера }

| GetFileAndOpenIt( ff );

| Write{ ff, ... ); { попытка записи в файл ff }

| { Дальше неважно, что будет. Все равно результат уже }

| { будет неверный. }

| END.

Рис. 12.3 (окончание)

Дело в том, что локальная переменная Buffer (а именно в ней мы размещаем буфер открываемого файла) существует лишь во время выполнения процедуры. После окончания она исчезает, область буфера становится общедоступной и наверняка очень быстро заполнится совершенно «посторонними» значениями, а переданный в вызывающий блок файл f (ff) будет вести себя непредсказуемо. При всем этом не возникнет ни ошибки компиляции, ни ошибки во время счета.

Если размещать буфер в статической переменной, то он «съедает» часть области данных или стека. А они ограничены размером 64K, что вовсе, не так много. Выгоднее было бы размещать буфер в динамической памяти (куче). Для этого надо объявить указатель на место буфера в куче (рис. 12.4).

| VAR

| ft : Text; { файл типа текст }

| PBuf : Pointer; { ссылка на буфер }

| CONST

| BufSize=1024; { размер буфера }

| BEGIN

| Assign( ft, 'TEXTFILE.DOC' );

| GetMem( PBuf, BufSize); { в памяти отводится }

| { блок размером с буфер }

| SetTextBuf( ft, PBuf^,BufSize ); { Задается буфер в }

| { динамической памяти. }

| Reset( ft ); { открытие файла }

| { . . . } { работа с файлом ft }

| Close( ft };

| FreeMem(Pbuf, BufSize); { Буфер удаляется из }

| { памяти (кучи). }

| END.

Рис. 12.4

- 235 -

В этом случае нужно отводить и освобождать память под буфер, а в SetTextBuf обязательно указывать его размер, так как блок памяти с началом в PBuf^ «не знает» своего размера.

В заключение посоветуем выбирать размер буфера кратным 512 байт. Диск читается по секторам и дорожкам, и длина считываемой в одном месте порции информации колеблется от 512 до 4096 байт для гибких и жестких дисков.

12.6.1.2.Процедура Append(VAR f : Text). Эта процедура служит для специального открытия файлов для записи. Она применима только к уже существующим физическим файлам и открывает их для дозаписи, т.е. файл не стирается, как при вызове Rewrite, а подготавливается к записи элемента в конец файла. Если Append применяется к несуществующему файлу, то возникнет ошибка времени счета. Новый файл может быть создан только процедурой Rewrite. Как автоматически выбрать соответствующую процедуру открытия файла — Append или Rewrite, описано в разд. 12.11.

После открытия файла процедурой Append запись в него будет происходить с того места, где находился признак конца файла (код 26). При необходимости поменять текстовый буфер надо сделать это до открытия файла процедурой Append. Вообще говоря, процедура Append, кроме способа открытия файла (с конца), ничем не отличается от процедуры Rewrite.

12.6.1.3. Процедура Flush( VAR f: Text). Эта процедура применяется к файлам, открытым для записи (процедурами Rewrite или Append). Данные для записи накапливаются в буфере файла и только после полного его заполнения записываются в физический файл. Процедура Flush принудительно записывает данные из буфера в файл независимо от степени его заполнения. Когда буфер имеет большую емкость, его содержимое может не попасть в физический файл, если программа внезапно прервется в процессе счета. Этого можно избежать, если перед «аварийными» частями программы ставить вызовы Flush.

Процедура Flush не закрывает файл и не влияет на последовательность вывода. Flush может найти применение при работе со стандартными файлами MS-DOS: устройствами AUX, или COM1, COM2,...,PRN, или LPT1 LPT3. При работе с ними данным незачем «отстаиваться » в буфере, и процедура Flush, поставленная после Write, снимет эффект задержки буфера файла.

12.6.1.4. Функция EOLn( VAR f: Text) : Boolean. Эта функция анализирует текущее положение в текстовом файле f, открытом для чтения. Расшифровка этой функции говорит сама за себя:

- 236 -

«End-Of-Line» — конец строки. EOLn возвращает значение True, если следующей операцией будет прочитан признак конца строки (символ #13) или конца файла (символ #26) и False во всех прочих случаях. Функция как бы предчувствует результат предстоящего чтения и анализирует его. Необходимость в EOLn( f ) возникает всякий раз, когда заранее не известно, где встретится конец строки. Пусть у нас имеется файл со столбцами цифр (рис. 12.5).

DIGITS.DAT

12.3 13.2 14.4 5.7 126.0[13][10]

17.8 -7.6 100 456 987.6[13][10]

55.5 6.06 7.8 0.00 10.11[13][10]

[26]

Рис. 12.5

Как автоматически определить число столбцов в нем и наладить чтение? С помощью EOLn (рис. 12.6).

| VAR

| f :Text; { логический текстовый файл }

| NCol :Byte; { счетчик числа столбцов }

| R :Real; { число для чтения из файла }

| BEGIN

| Assign( f, 'DIGITS.DAT' ); { связывание файлов }

| Reset ( f ); { открытие f для чтения }

| Ncol := 0; { стартовое значение Ncol}

| while NOT EOLn(f) do

| begin { Цикл до конца строки: }

| Read( f, R ); { чтение вправо по строке}

| Inc( Ncol ) { увеличение счетчика столбцов }

| end ; {while} { конец цикла счета столбцов }

| Reset( f ); { возврат на 1-ю позицию в файле }

| { ... и повторение чтения, уже зная число столбцов }

| END.

Рис. 12.6

Существует разновидность функции EOLn без параметров. В этом случае считается, что действие ее относится к стандартному файлу Input, т.е. вводу с клавиатуры. Здесь функция EOLn возвращает True не перед, а после прохождения признака конца строки: сразу после нажатия клавиши ввода. Более того, от EOLn без параметра не дождетесь значения False. Она «подвешивает» программу и возвра-

- 237 -

щает управление следующему оператору только после нажатия ввода. В руководстве языка приводится способ организовать паузу до нажатия ввода:

WriteLn(EOLn);

12.6.1.5. Функция SeekEOLn( VAR f: Text): Boolean. Эта функция является «ближайшей родственницей» функции EOLn (f). Файл f должен быть текстовым и открытым для чтения. Функция возвращает значение True, если до конца строки (символ #13) или конца файла (символ #26) могут быть считаны только пробелы и (или) символы табуляции (символ #9). Значение True также вернется, если текущее положение в файле непосредственно предшествует символам #13 или #26. Другими словами, SeekEOLn всегда вернет True, если EOLn на ее месте вернет True. Но в отличие от EOLn функция SeekEOLn как бы «видит» конец строки (или файла) через пробелы и знаки табуляции.

SeekEOLn ориентирована, главным образом, на работу с текстовыми файлами чисел. Последний пример из описания EOLn можно было бы переписать, заменив EOLn на SeekEOLn. От этого он заработал бы только лучше. Действительно, чтобы EOLn вернула True, нужно «упереться» в признак конца. А для этого надо убедиться, что «пустопорожние» пробелы после последнего числа в строке не являются числами: съедается время. SeekEoLn же игнорирует все пробелы и табуляции и «видит» конец издалека, ускоряя обработку.

12.6.1.6. Функция SeekEOF( VAR : Text) : Boolean. Эта функция замыкает ряд функций, начатый EOLn и SeekEOLn. Если отнять у SeekEOLn способность реагировать на признак конца строки, то получится функция SeekEOF, которая возвращает True, если только следующий за текущим положением символ — конец файла (#26), или если перед концом файла имеются только пробелы и (или) символы табуляции (#9), и (или) признаки конца строки (#13). Короче говоря, символы #9, #13, #32(пробел) для SeekEOF являются «прозрачными», и если сквозь них «виден» конец файла #26, то функция возвращает значение True. Во всех прочих случаях вернется значение False.

Функция позволяет найти смысловой конец файла, а не физический. Это полезно при работе с числами (реже с символами). Так, цикл чтения из файла f

while not EOF( f ) do Read( f, ... );

остановится только после полного истощения файла, даже если

- 238 -

последние 1024 строк его были пустыми. Если переписать цикл в виде

while not SeekEOF( f ) do Read( f, ... );

он станет работать более эффективно.

Как и SeekEOLn, функция SeekEOF применима только к открытым для чтения текстовым файлам.

 

12.6.2. Операции ввода-вывода в текстовые файлы

Ввод и вывод числовой и текстовой информации в Турбо Паскале осуществляется операторами:

ввод – Read( f, X ) или Read( f, X1,X2,...,Xn ) и

ReadLn( f, X ) или ReadLn( f, X1,X2,…,Xn );

вывод – Write( f, X ) или Write( f, X1,X2,…Xn ) и

WriteLn( f, X ) или WriteLn( f, X1, X2,…,Xn ).

Если в операторе ввода-вывода первым параметром стоит логическое имя файла, то это означает, что поток данных будет приниматься (Read) или направляться (Write) на конкретное физическое устройство компьютера, связанное в данный момент с логическим именем этого файла.

Если операторы содержат один лишь список ввода-вывода, то считается, что ввод сопряжен со стандартным логическим файлом Input (под ним подразумевается клавиатура с «эхом» ввода на экране), а вывод — с логическим файлом Output (что соответствует выводу на экран дисплея).

Имена Input и Output являются предопределенными в системной библиотеке (модуле System). Напомним, что в стандартном Паскале любая программа, использующая ввод-вывод, должна начинаться со слов

PROGRAM имя( Input, Output);

что, по сути, открывает каналы ввода-вывода. В Турбо Паскале можно смело опускать описание PROGRAM и не надо описывать имена Input и Output.

Таким образом, оператор Read( x1, x2) полностью эквивалентен оператору Read( Input, x1, x2 ), а оператор Write( х3, х4) — оператору Write( Output, х3, х4 ).

12.6.2.1. Операторы Read/ReadLn. Рассмотрим сначала операторы ввода информации — Read и ReadLn. Их аргументами должен быть список переменных, значения которых будут считаны (введены). Тип переменных при вводе из текстового файла (в том числе и

- 239 -

с клавиатуры) может быть только целым, вещественным, символьным (Char), строковым или совместимым с ними. Сложные структурированные типы (такие, как массивы, множества, записи и др.) могут быть введены только по элементам (по полям для записей). Например:

| VAR

| i : Word

| l : Longint;

| r : Real;

| Rec RECORD { запись }

| x, у : Real

| ch : Char

| END;

| Dim : Array [0...99] of Byte; { массив }

| S : String;

| BEGIN

{ . . . ЧИТАЮТСЯ С КЛАВИАТУРЫ: . . . }

| Read( i, l); { два целых числа,}

| Read( l, r, s); { целое, вещественное число и строка,}

| Read( Rec.x, Rec.у, Rec.ch ); { запись по полям,}

| for i:=0 to 99 do

| Read( Dim[i] ); { ввод массива }

| END.

Всякие попытки вставить «сокращения» типа Read (Rec) или Read (Dim) вызовут понятное возмущение компилятора. Такое возможно лишь при вводе из типизированного файла (см. разд. 12.7).

При вводе из текстового файла, будь то файл на диске или клавиатура, необходимо помнить правила чтения значений переменных. Когда вводятся числовые значения, два числа считаются разделенными, если между ними есть хотя бы один пробел, или символ(ы) табуляции (#9), или символ(ы) конца строки (#13). Так, при выполнении оператора Read( i, r ) можно ввести значения с клавиатуры несколькими способами:

123 1.23 [Клавиша ввода]

или

123 [Клавиша ввода] 1.23 [Клавиша ввода]

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

- 240 -

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

VAR

ch1, ch2 : Char;

...

Read( ch1, ch2 );

В этом случае надо не спешить нажать клавишу ввода на клавиатуре:

аб[ВВОД] --> ch1 = 'а', ch2 = 'б'

а[ВВОД]б[ВВОД] --> ch1 = 'а', ch2 = #13

[ВВОД][ВВОД] --> ch1 = #13, ch2 = #13

И, наконец, ввод строк. Начало строки идет сразу за последним введенным до этого символом (с первой позиции, если соответствующая строчная переменная стоит первой в списке ввода). Считывается количество символов, равное объявленной длине строки. Но если во время считывания попался символ #13, то чтение строки прекращается. Сам символ #13 (конец строки) служит разделителем строк и в переменную никогда не считывается.

Рассмотрим пример комплексного списка ввода:

Read( realVar, intVar, Ch, String11, String88).

При вводе последовательность символов будет разбита на разнотипные части следующим образом ([#13] обозначает один символ с кодом 13):

Обратите внимание, что символьная переменная Ch здесь может заполучить себе только пробел (или #13 и #9), иначе, если следом сразу начнется строка, произойдет сбой при чтении целого значения! Строка StringSS будет заполнена не целиком, а на ту часть, которая успела считаться до символа #13 (нажатия клавиши ввода или конца строки в файле).

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

- 241 -

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

При вводе с клавиатуры («с экрана») особой разницы между Read и ReadLn нет. Процедура ReadLn (Read Line) считывает значения в текущей строке и переводит позицию на начало следующей строки, даже если в текущей строке остались непрочитанные данные. Так, при чтении в текстовом файле f строки:

12.3 13.4 14.5 15.6

оператором ReadLn( f, r1, r2) вещественные переменные r1 и r2 получат значения 12.3 и 13.4, после чего произойдет переход на другую строку, и следующие два числа (14.5 и 15.6) будут проигнорированы. Вызов ReadLn ( f ) вообще пропустит строку в файле f. Вызов ReadLn без указания файла сделает паузу до нажатия клавиши ввода.

Символ-признак конца текста #26 также является разделителем и ограничивает строку, но за ним чтение уже невозможно. Файл на нем кончается! Конец файла может быть считан в символьную переменную, в строчную он не войдет (как не входит символ #13), а чтение #26 вместо ожидаемых числовых значений эквивалентно прочтению 0.

12.6.2.2. Операторы Write/WriteLn. Операторы Write и WriteLn выводят значение X или список значений X1, Х2,..., Хn в текстовый файл f. Если файл не указан, то считается, что вывод направлен в файл Output (на дисплей). Значения, как и при вводе, могут иметь лишь целые, вещественные, символьные и строковые типы, а также производные от них. Всевозможные структуры (записи, массивы) должны выводится по их полям или элементам. Множества, указатели (Pointer), файловые переменные также не могут быть выведены без предварительного их преобразования в выводимые составляющие. Исключение составляет лишь тип Boolean:

CONST

tr : Boolean = True;

fa : Boolean = False;

...

Write( tr, ' ... ' , fa );

Оператор Write напечатает на экране: 'TRUE ... FALSE'. Предостерегаем от попыток прочитать эти значения из файла в том же виде. Из этого ничего не выйдет. Чтобы получить из файла логическое значение, закодируйте его байтом:

0 = False

1 = True

- 242 -

и считайте в байтовую переменную, а затем преобразуйте в логическое значение:

VAR

by : Byte; { байтовое значение }

boo : Boolean absolute by; { логическое значение }

...

Read( by ); { вводится значение-байт 0 или 1 }

if boo then ... ; {и считается логическим значением }

Вернемся, однако, к выводу данных. Процедура Write выводит данные в текущую строку и не закрывает ее, т.е. следующие данные запишутся в ту же строку. Формально во внешнем файле размер строки не ограничен. Исключение составляет вывод на дисплей. Если выводимый текст «уперся» в правую границу окна экрана, то он на этом месте разрывается и продолжается с начала следующей строки. Кроме того, вывод символа в нижний правый угол окна автоматически сдвинет изображение вверх на строку, т.е. все-таки совершит переход на следующую строку.

Процедура WriteLn (Write Line) выводит именно строку данных и закрывает ее: приписывает символ #13 в ее конец (точнее, символы #13 и #10, но последний как бы «сливается» с основным кодом). Это автоматически открывает следующую строку, а на экране возвращает курсор в крайнюю левую позицию и опускает его на строку вниз.

Оператор WriteLn или WriteLn( f ), где f — имя логического файла, данный без списка вывода, создает пустую строку, содержащую один только признак конца.

Список вывода Write и WriteLn может содержать константы, переменные, выражения, вызовы функций — лишь бы они имели соответствующие типы и были разделены запятыми:

Write( RealVar, ' номер ', intVar, #10#10'сумма=' );

WriteLn( RealVar+IntVar, '+', Cos(5*5) );

Все, что стоит в кавычках или является строковыми (символьными) константами и переменными, выведется в том виде, в каком подставлено, и лишнего места не займет. Но числовые значения будут выводится по-разному. Целые — как пробел или знак '-', а затем число, вещественные — как пробел или знак и затем экспоненциальная запись числа. Имеется возможность управлять форматом вывода данных.

12.6.2.3. Форматы вывода данных. При выводе значений в текстовые файлы или на экран можно указывать формат, т.е. отводить поле для размещения этих значений. Для строчных и символьных значений формат задается одним числом, отделенным от значения двоеточием:

- 243 -

Write( Ch : 2, St : 20 );

Это число показывает, сколько позиций отводится под значение. Так, значение Ch (символ) будет размещено в двух позициях, хотя реально займет лишь одну, а строка St — в 20 позициях. Если реальное значение «короче» формата, излишек будет заполнен пробелами. Но если наоборот (формат «мал»), то значение будет выводиться, игнорируя спецификацию. Ошибки при этом не возникает. Выравнивание значения в поле формата здесь происходит по правому краю. На этом можно сыграть следующим образом. Часто надо выводить значения с середины строки. При выводе на экран можно использовать специальную процедуру из модуля CRT для установки курсора, но при выводе в файл на диске это работать не будет. А как передвинуть значение? Решение очевидно:

Write( ' ', ChapterNameStr );

Но так же очевидно, что это неэффективно (в программе будет попусту «болтаться» столько пробелов!). Разумное решение таково:

Write( ' ' : 25, ChapterNameStr );

Один пробел, но в поле из 25 символов. Эффект будет тот же. Можно даже выкинуть пробел и поставить пустую строку .

Логические значения False и True выводятся как строковые константы и могут быть помещены в заданном поле.

Формат целочисленных значений задается почти так же, как и для строковых — размером поля за значением:

Write( intVar:5, 123:4, (6*8):10 );

Целое число, включая знак минус, если нужен, будет размещено в заданном числе позиций и выровнено по правому краю. Излишки заполнятся пробелами, а если формата не хватит, то он проигнорируется. Формат удобно использовать для вывода таблиц. Пусть надо красиво вывести 10 столбцов целых значений в 80 колонок экрана. Для этого можно задать формат

WriteLn( х1:7, х2:7, х3:7,...х10:7 );

Сложнее формат для вещественных значений. Для записи числа в дробной форме используется удвоенное описание формата: сначала, как обычно, указывается общий размер поля под значение, а затем, снова через двоеточие, число знаков после запятой:

Write( RealVar : 12 : 3, 123.456 : 8 : 1 );

- 244 -

Реальная длина числа равна сумме одной позиции под знак, числа знаков до десятичной точки, одной позиции под точку и значения второго параметра формата. Поэтому бессмысленны форматы типа ':4:3'. В примере переменная RealVar на экране будет иметь три знака после точки, и если полная ее длина не превысит двенадцать позиций, то она будет выровнена по правому краю. Оставшееся место будет пусто. При некорректном задании формата игнорируется только первый его параметр, а число знаков после точки устанавливается всегда корректно, но не превышает точности типа.

В том же примере второе значение будет выведено как 123.5, потому что при форматировании дробная часть округляется до заданного числа знаков. Само значение переменной при этом, конечно, не изменяется.

Можно выводить вещественные числа без дробной части. Для этого следует задать второй параметр равным 0:

Write( 123.456 : 6 : 0 ); { ' 123' }

При необходимости вывода вещественных значений в экспоненциальном формате надо задавать вновь только одно поле. Это поле указывает число позиций, в которых надо разместить число. Само число будет иметь вид -5.5678Е+00 или 0.0012Е-20. При задании подобного формата надо учесть место под знак числа, одну цифру до точки, саму точку, хотя бы одну цифру после точки, и четыре знака под степень — всего восемь позиций.

При формате, меньшем чем восемь позиций, он устанавливается автоматически равным восьми:

Write( 123.456 : 8, ' ', 123.456 : 6 ); { одно и то же }

Увеличивая формат, мы тем самым увеличиваем число значащих цифр после запятой. Максимальное их число определяется типом вещественного числа, и дальнейшее увеличение формата эффекта не даст.

Ряд проблем вызывает использование сопроцессора. В этом случае все вещественные типы при выводе в экспоненциальном формате показывают степень в виде Е+0000, т.е. минимальный формат становится равным ':10', и чтобы сохранить равное число знаков в самом числе при разных режимах работы с сопроцессором, надо менять форматы. Этот момент подробно рассмотрен при описании строковой процедуры Str (разд. 8.3.2.1).

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

- 245 -

VAR

F, n : ShortInt;

BEGIN

F:=8; n:=3;

WriteLn( 123.456 : F : n );

END.

До сих пор мы рассматриваем форматы, размещающие и форматирующие одновременно. Но когда длина значения заранее неизвестна, размещение-выравнивание по правому краю может дать некрасивые форматы:

Короткое число в формате 10 = 12

Длинное число в формате 10 = 12345678

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

Короткое число в формате -10 = 12

Длинное число в формате -10 = 12345678

Для задания такого режима надо ближнюю к значению спецификацию формата задавать отрицательной:

Write( 123.456 : 6 : 1, 22 : 4 ); { ' 123.5' и ' 22' }

Write( 123.456 :-6 : 1, 22 :-4 ); { '123.5' и '22' }

Несмотря на некоторое отсутствие гибкости в способе задания формата (нельзя задавать форматы-шаблоны — как в Фортране, Бейсике, а надо описывать каждое значение), механизм форматированного вывода текстовой информации Турбо Паскаля достаточно мощный. Помните только, что форматы имеют смысл лишь при работе с текстовыми файлами. Во всех остальных случаях они неприменимы.

 

12.7. Типизированные файлы и операции ввода-вывода

Типизированный, или компонентный, файл — это файл с объявленным типом его компонентов, т.е. файл с наборами данных одной и той же структуры. Как и в стандарте Паскаля, объявление такого файлового типа имеет структуру

File of ТипКомпонента,

- 246 -

где компонент может иметь любой ординарный или структурированный тип, предопределенный или построенный программистом. Запрещено лишь объявлять файлы файлов и файлы объектов, а также файлы структурированных компонентов (массивов, записей и др.), содержащих те же файлы или объекты. Так, допустимы следующие объявления:

TYPE

DimComp = Array [1..100,1..2] of Real;

RecComp = RECORD

X,Y : Byte;

A : DimComp

END;

DimFile = File of DimComp;

RecFile = File of RecComp;

IntFile = File of Integer;

Но компилятор не пропустит такие типы:

TYPE

FileFilel = File of File of Real; { неверно: файл файлов }

FileFile2 = File of DimFile; { неверно: файл файлов }

FRecComp = RECORD

X,Y : Byte;

F : File of Char

END;

FRecFile = File of FRecComp; { нельзя: файл в компоненте!}

ObjComp = OBJECT

...

END;

ObjFile = File of ObjComp; { неверно: файл объектов }

При написании программ необязательно определять специальные файловые типы. Это можно сделать «на ходу» при описании переменных:

VAR

FR : File of Real;

FD : File of DimComp;

Для работы с объявленным файлом необходимы обычные предварительные действия: связывание файловой переменной с физическим файлом и открытие файла для чтения или записи, например:

Assign( FR, 'RFILE.DAT' ); Reset( FR );

Assign( FD, 'DFILE.DAT' ); Rewrite( FD );

- 247 -

Для типизированных файлов обе процедуры Reset и Rewrite устанавливают режим «чтение/запись» в соответствии со значением предопределенной системной переменной FileMode (оно по умолчанию равно 2), т.е. независимо от выбора процедуры открытия, файл открывается и для чтения, и для записи. Это верно только для типизированных и бестиповых файлов, но ни в коем случае, не для текстовых. Этот порядок нарушится только в том случае, когда значение FileMode соответствует режиму «только запись» (1) или «только чтение» (0). Сменить режим можно простым присваиванием нужного значения переменной FileMode перед открытием файла. После этого вызов Reset будет открывать файл в заданном режиме, даже если он будет «только запись»! Процедура Rewrite также должна «слушаться» указаний FileMode, но только в том случае, когда файл уже существует. Для новых файлов Rewrite всегда включает режим «чтение/запись».

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

После открытия файла ввод и вывод данных осуществляется стандартными операторами

Read( f, х ) и Write( f, x )

или

Read( f, х1, х2, хЗ,...,xn) и Write(f, х1, х2, хЗ,..., xn).

Первым аргументом должно быть имя логического файла f, с которым связан конкретный физический файл. А далее должна стоять переменная (или их список) того же типа, что и объявленный тип компонента файла f, в которую запишется очередное значение из файла при чтении (Read) или, наоборот, которая запишется в файл (Write).

В отличие от файлов типа Text типизированные файлы имеют более строгую внутреннюю структуру. При записи в них записывается машинное представление очередного компонента, будь то число, массив, запись или строка. Внутри файла компоненты не отделяются ничем друг от друга (тем не менее найти любой компонент несложно: каждый из них занимает в файле одинаковый объем, равный размеру его типа). Поэтому не имеет смысла применять к типизированным файлам операторы ReadLn и WriteLn. В них просто не существует такого понятия, как строка и ее конец, и нет признака конца файла (конец определяется длиной файла). Даже если объявить файл как

- 248 -

VAR

f : File of String[80];

он не будет похож на текстовый файл из строк. В нем по-прежнему не будет символов конца строки, а будет (после записи) сплошная последовательность символов, кратная 81 (80 символов в строке и байт длины строки). Хуже того, если реальные значения строк короче 80 символов, то все равно в файле окажется по 81 символу на строку, и «излишки» будут забиты «мусором»,

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

Для специальных целей (например, написания программ перекодировки текстов) можно трактовать текстовые файлы как File of Char. Это, разумеется, не оживит работу процедур ReadLn/WriteLn и функции EOLn, работающей с текстами, но при соблюдении неприкосновенности и неизменности кодов конца строки и конца файла (символ #26), даст возможность побуквенного чтения, изменения и последующей записи в другой File of Char исходного текста. Каркас такой программы показан на рис. 12.7.

| PROGRAM Decode_Text;

| VAR

| fIn, fOut : File of Char; {файлы для чтения и записи}

| Ch : Char; {обрабатываемый символ }

| FUNCTION DecodeChar( С : Char ) : Char;

| { Функция должна возвращать символ,

| получающийся перекодировкой из C. }

| BEGIN { . . . } END;

| BEGIN

| Assign( fIn, 'C:\DOC\DOCUM.A' ); Reset( fIn );

| Assign( fOut, 'C:\DOC\DOCUM.B' ); Rewrite( fOut );

| Ch := ' '; { очистка Ch }

| while Ch <> #26 do

{цикл до конца ТЕКСТОВОГО файла:}

| begin

| Read ( fIn, Ch ); { читается символ }

| Write( fOut, DecodeChar(Ch) ) { запись замены }

| end ; {while} { конец цикла }

| Close( fIn ); Close( fOut ) { закрытие файлов }

| END.

Рис. 12.7

- 249 -

(Чтобы не закладывать имена текстовых файлов в текст самой программы, следовало бы использовать функцию ParamStr или организовать более или менее «дружелюбный» диалог с пользователем, что советуем сделать.)

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

TYPE

dim100x20 = Array [1..100, 1..20] of Real;

VAR

XX, YY : dim100x20;

fIn, Fout : File of dim100x20;

BEGIN

... { открытие файлов fin и fOut... }

Read( fIn, XX ); { считывается сразу весь массив }

... { обрабатываются массивы }

Write( fOut, YY ); { записывается весь массив сразу }

... { среди прочего — закрытие файлов}

END.

В то же время эти файлы неоптимальны для хранения строк (лучше использовать Text-файлы) и имеют сложное внутреннее представление. Последнее означает, что если забыть, что именно содержится в подобном файле, то его просмотр вряд ли поможет.

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

 

12.8. Бестиповые файлы и операции ввода-вывода

Стандарт Турбо Паскаля вводит особый файловый тип, являющийся, по сути, обобщенным файловым типом. Мы будем называть его в дальнейшем бестиповым файлом, поскольку его обозначение состоит только из слова File без указания типа компонент.

Бестиповый файл — это очень мощное средство работы с файлами, так как он позволяет манипулировать с данными, не задумываясь об их типе. С его помощью можно записывать на диск произвольные участки рабочей памяти ПЭВМ и считывать их в память диска. Можно также преобразовывать считываемые из бестипового файла данные в любой формат посредством приведения типов. В этом разделе будут рассмотрены некоторые примеры использования бестиповых файлов.

- 250 -

Ввод-вывод в бестиповые файлы осуществляется специальными процедурами BlockRead и BlockWrite. Кроме того, расширяется синтаксис процедур Reset и Rewrite. В остальном принципы работы остаются такими же, как и с типизированными файлами. Перед использованием файловая переменная f (логический файл)

VAR

f : File;

должна быть связана с конкретным физическим файлом через вызов оператора Assign. Далее файл должен быть открыт для чтения или записи с помощью вызова процедуры Reset (f) или Rewrite (f) соответственно. После окончания работы файл должен быть закрыт процедурой Close (f).

Открывая бсстиповый файл для работы, мы неявно устанавливаем размер буфера передачи данных равным 128 байт. Однако можно явным способом указать иной размер буфера (чем он больше, тем быстрее происходит ввод-вывод), исходя из ресурсов памяти и удобства работы с данными. Для задания буфера надо после оператора Assign открывать файл расширенной записью процедур:

Reset( VAR f : File; BufSize : Word )

и

Rewrite( VAR f : File; BufSize : Word ).

Параметр BufSize задает число байтов, считываемых из файла за одно обращение к нему или записываемых в него. Чем больше значение BufSize, тем быстрее происходит обмен данными между носителем файла (как правило, диском) и оперативной памятью ПЭВМ. Но тем больше и расход памяти. Ведь именно в ней располагается буфер файла.

Минимальный блок, который может быть записан или прочитан из файла, это 1 байт. Чтобы задать его, надо установить именно такую величину буфера при открытии файла. Максимальный размер блока не может превышать 64K.

Во время отладки программ в среде Турбо Паскаль можно проверить размер буфера, поместив в окно просмотра (Watch) или анализа (Evaluate) файловую переменную f, приведенную к типу FileRec (для этого может понадобиться подключение модуля DOS):

{ FileRec(f), R

или, конкретнее,

FileRec( f ).BufSize

Для чтения или записи данных в бестиповый файл стандартные процедуры Read и Write не годятся. Их заменяют здесь процедуры:

BlockRead(VAR f : File; VAR Destin; Count : Word [; VAR ReadIn : Word])

и

BlockWrite(VAR f : File; VAR Source; Count : Word [; VAR WriteOut : Word]).

Эти процедуры осуществляют чтение в переменную Destin и запись из переменной Source не компонентов файла или его строк, а блоков, состоящих из того количества байтов, которое определено для буфера файла f. Если Count больше 1, то за одно обращение будет считано Count емкостей буфера. Значение Count, меньшее единицы, не имеет смысла. Всегда должно выполняться условие:

Count*Размер_буфера < 64K.

Необязательный параметр ReadIn возвращает число блоков (буферов), считанное текущей операцией BlockRead. Аналогичный параметр WriteOut процедуры BlockWrite после каждой операции записи показывает число блоков (буферов), записанное в данный файл этой операцией.

Если операции записи или чтения прошли успешно, то значения ReadIn и WriteOut будут равны соответствующим значениям параметров Count. Но если произошел сбой при вводе-выводе, и заказанное число блоков не перенеслось, то параметры ReadIn и WriteOut будут содержать целое число удачно перенесенных блоков (неудача посередине блока практически равносильна отмене его чтения или записи).

Таким образом, эти параметры могут использоваться для контроля выполнения операций BlockRead и BlockWrite:

VAR

Fr,Fw : File; { файловые переменные }

ReadIn, WriteOut : Word; { переменные контроля }

Destin : ....... ; { приемник при чтении }

Source : ………; { источник при записи }

- 252 -

BEGIN

...

BlockRead( Fr, Destin, 3, ReadIn );

if ReadIn <> 3 then обработка ошибки чтения ;

BlockWrite( Fw, Source, 4, WriteOut );

if WriteOut <> 4 then обработка ошибки записи ;

...

END.

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

Процедуры BlockRead и BlockWrite не имеют списков ввода и вывода, поскольку не определен тип компонента файла. Взамен их в вызовах присутствуют бестиповые переменные. Адрес начала переменной в памяти соответствует адресу области памяти, начиная с которого заданное количество байт будет выведено в файл при записи или помещено в память из файла при чтении. Передавая переменную процедуре, мы всегда тем самым передаем адрес ее содержимого, точнее, первого байта ее значения. Если переменная X — массив

VAR

X : Array [1..10] of ... ;

то вызов BlockWrite или BlockRead с ней будет принимать за точку начала отсчета блока первый элемент массива. Можно более явно указать в вызове начало блока как X [1]. Но если подставить X[5], то отсчет блока будет вестись уже сразу с пятого элемента массива. Особенно осторожно надо будет обращаться со ссылками при подстановке их в BlockWrite и BlockRead. Ссылки должны быть разыменованы, с тем чтобы показывать на данные, а не на место в памяти, где хранится сама ссылка. Так, если определена ссылочная переменная P:

TYPE

Dim = Array [0..999] of Real; { массив }

VAR

P : ^Dim; { ссылка на массив }

f : File; { бестиповый файл }

то после создания динамического массива P^ вызовом процедуры New(Р) и его заполнения, он может быть записан в файл f следующим образом:

- 253 -

Assign( f, 'DIMFILE.DAT' ); { связывание f с диском }

Rewrite( f, SizeOf( Dim ) ); { открытие f для записи }

BlockWrite( f, Р^, 1 ); { запись массива в файл }

{ Ссылка P разыменована! }

Close( f ); { закрытие файла f }

Если ошибочно написать P вместо P^, то процедура сработает, но сохранит в файле кусок памяти, начиная с Addr(P), который вовсе не равен адресу динамического массива Addr(P^)!

Чтобы прочитать впоследствии записанный массив из файла, нужно «развернуть» направление вывода данных:

{ Место под массив P^ должно быть зарезервировано! }

New( Р );

Assign( f, 'DIMFILE.DAT' ); { связывание f с диском }

Reset( f, SizeOf( Dim ) ); { открытие f для чтения }

BlockRead( f, P^, 1 ); { чтение массива из файла}

{ Ссылка Р разыменована! }

Close( f ); { закрытие файла f }

Перед чтением блока в динамическую переменную (здесь: P^) она должна быть корректным образом создана (через вызов New либо GetMem или присвоением значения адреса), иначе последствия будут непредсказуемыми.

Блочный способ работы с файлами весьма эффективен по времени, и если программа использует крупные массивы предварительно вычисляемых констант, то может оказаться более выгодным вынести их вычисления в отдельную программу, которая затем сохранит их на диске, а в расчетной программе просто вставить операторы блочного чтения уже рассчитанных значений. В таких случаях можно даже сыграть на особенностях компилятора Турбо Паскаля. Обычно при компиляции программ память под статические массивы (но не под динамические) отводится в порядке их следования в описании. Так, если описаны

VAR

A, B, C : Array [1..2000] of Real;

то их элементы выстраиваются в одну сплошную цепочку. Иными словами:

Addr(B) = Addr(A) + SizeOf(A),

Addr(C) = Addr(B) + SizeOf(B).

(Это верно не только для массивов, но и для любых статических структур, кроме объектов: память в пределах блока описания переменных отводится последовательно по мере их следования.)

- 254 -

Используя этот факт, можно записать или считать блоком сразу несколько структур данных, приняв за начало блока первую из них:

Assign( f, 'ABC.DAT' );

Rewrite( f, SizeOf(A) ); { открыть f и записать в }

BlockWrite( f, A, 3); { него три блока сразу }

Close( f );

или

Reset( f, SizeOf(A) ); { открыть f и считать из }

BlockRead( f, A, 3); { него три блока сразу } Close( f );

Другой, более специфичной областью применения бестиповых файлов является работа с системными областями памяти ПЭВМ, в том числе с видеопамятью. Одной из иллюстраций этого является, например, запись текстовых и графических изображений, рассматриваемая в разд. 20.4 и 22.3.

 

12.9. Последовательный и прямой доступ к файлам

Файл — это последовательная структура данных. И естественным способом доступа к компонентам файла является последовательный доступ. После открытия файла он «ждет» чтения или записи первого компонента. После каждого очередного обращения к файлу он готов выдать или принять очередной по счету компонент. В данном случае возможно только косвенно управлять последовательностью чтения или записи.

Пусть нужно прочитать из файла f пятый элемент и записать его в переменную V соответствующего типа. Это можно сделать, считав «впустую» четыре первых значения:

Reset( f ); { файл открыт для чтения первого компонента }

for i:=1 to 5 do Read ( f, v );

Reset(f); { переустановка снова на первый компонент }

В V останется лишь последнее, пятое, значение из файла. Это, конечно, не самое удачное решение проблемы прямого доступа, т.е. доступа сразу к тому компоненту, который нас интересует. Гораздо лучше будет использовать встроенные процедуры и функции Турбо Паскаля для прямого доступа к компонентам файла (табл. 12.4).

- 255 -

Внимание! Процедуры и функции прямого доступа применимы только к типизированным и бестиповым файлам, но не к текстовым.

В эту же таблицу можно было бы включить и функцию EOF(VAR f), описанную ранее в этой главе как общую для всех файлов.

Прямой доступ означает возможность позиционировать внутри файла указатель на интересующую нас запись. В случае типизированных файлов запись в файле — это компонент файла, а в случае бестиповых — блок, равный по размеру буферу файла. Далее в этом разделе мы будем использовать термин «запись» именно в этом смысле (ранее мы избегали его из-за двусмысленности: запись компонента в файле сама может быть записью (record) в смысле типа данных).

Файл заполняется последовательно от начала. Его структура всегда линейна: запись следует за записью. В нем не может быть «дыр». Добавить запись можно лишь в конец, удлинив тем самым сплошную их цепочку в файле. Правда, можно заместить любую

- 256 -

существующую в файле запись, но это не изменит его структуры и длины.

Для индексации структуры файла достаточно просто пронумеровать его записи, что и делается в Турбо Паскале. Но эта нумерация достаточно своеобразна. Можно считать, что нумеруются не записи, а как бы границы между ними (рис. 12.8). Эти границы — чистая условность, и в реальном файле записи не разделяются, а идут подряд. Просто они позволяют наглядно изобразить принцип нумерации записей. Самая первая граница (в начале файла) имеет номер 0.

Рис. 12.8

Если пронумеровать записи нормальным способом (первая, за ней вторая и т.д.), то получится, что реальный номер записи всегда на единицу больше номера границы перед ней. Рассмотрим работу функций прямого доступа в терминах нашего рисунка.

 

12.9.1. Опрос размеров файлов и позиции в них

12.9.1.1.Функция FileSize( VAR f) : LongInt. Эта функция возвращает реальное число записей в открытом файле f. Применительно к рис. 12.8, эта функция вернула бы значение n. Для пустого файла возвращаемое значение равно 0.

12.9.1.2.Функция FilePos( VAR f ) : LongInt Эта функция возвращает нашу текущую позицию в файле f. Файл должен быть открытым. Позиция в файле — это номер условной границы (см. рис. 12.8). Если файл только что открылся, то текущей позицией будет граница с номером 0. Это значит, что можно прочитать (или записать) запись с реальным номером (0+1)=1. После, например, ее прочтения позиция переместится на границу 1, и следующей можно будет прочитать запись (1+1)=2 и т.д. После прочтения последней записи в файле с реальным номером n позиция совпадает с границей с таким же номером n. Дальше записей нет. Поэтому, если FilePos

- 257 -

возвратила значение, равное FileSize, то мы находимся в конце файла за последней записью:

if FilePos( f ) = FileSize( f ) then { Все! Конец файла }

Все сказанное можно теперь сформулировать следующим образом:

1. В самом начале файла функция FilePos возвращает значение 0.

2. В самом конце файла функция FilePos возвращает число, равное реальному количеству записей в файле (FileSize).

3. В остальных случаях функция FilePos возвращает значение, на единицу меньшее реального номера записи, которая готова к прочтению или созданию.

 

12.9.2. Позиционирование в файлах

Операция назначения текущей позиции в файле (позиционирование) производится процедурой Seek. Процедура Seek( VAR f; N : Longint ) непосредственно реализует прямой доступ в файл f. Файл должен быть открыт. Разберем механизм работы процедуры, используя рис. 12.8. В параметре N должен быть задан номер условной границы между записями. Чтобы работать с записью, имеющей реальный номер 3, мы должны задать позицию на границе перед ней, т.е. на границе с номером N=(3-1)=2. Чтобы прочитать или записать первую запись, должны задать N=0:

Seek( f, 0 );

где 0 — номер границы перед первой записью. А в случае, когда необходимо, чтобы позиция имела номер последней границы (а он совпадает с числом записей на последний момент времени), следует воспользоваться вызовом:

Seek( f, FileSize( f ) ).

Доступ к последней записи в файле:

Seek( f, FileSize( f ) - 1 ).

В принципе, правила назначения позиции процедурой Seek такие же, как и правила вычисления FilePos, только направлены на изменение позиции, а не на ее анализ.

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

- 258 -

| { ПРИМЕР ТОГО, КАК ПОМЕНЯТЬ МЕСТАМИ ЗАПИСИ В ФАЙЛЕ }

| TYPE

| Dim = Array [1..3] of Char; { тип компонента файла }

| VAR

| f : File of Dim; { компонентный файл }

| ff : File; { бестиповый файл }

| Dfirst, Dlast : Dim; { массивы типа Dim }

| FS : LongInt; { длина файла f }

| CONST

| St: String[11*3]= 'AAA—BBB—CCC—DDD—EEE—FFF';

| {Две процедуры для создания файла из 11 массивов типа }

| {Dim и его загрузки после модификации прямым доступом. }

| {Содержимое массивов представлено строкой длины 11*3=33 }

PROCEDURE Save.St;

| BEGIN

| Assign( ff, 'DIMFILE.DAT' ); Rewrite( ff, 3 );

| BlockWrite( ff, St[1], 11 ); Close( ff )

| END;

PROCEDURE Load.St;

| BEGIN

| Assign( ff, 'DIMFILE.DAT' ); Reset(ff, 3);

| BlockRead( ff, St[1], 11 ); Close( ff )

| END;

| BEGIN

| WriteLn( 'Стартовое содержимое файла: ', St );

| Save St;

| Assign( f, 'DIMFILE.DAT' ); { связывание f с диском }

| Reset( f ); { открытие файла f }

| FS := FileSize( f ); { запоминание длины файла }

| if FS < 2 then

| begin

| WriteLn('Маловато записей в файле для примера!');

| Halt { выход из программы }

| end ; { if }

| Read( f, Dfirst ); { считывается первый массив в файле }

| Seek( f, FS-1 ); { переход к последней записи }

| Read( f, Dlast ); {считывается последний массив }

| Seek( f, FilePos(f)-1 ); { назад на одну запись }

| Write( f, Dfirst ); { первый массив замещает последний }

| Seek{ f, 0 ); { переход в самое начало файла }

| Write( f, Dlast ); { последний массив замещает первый }

| Close( f ); { закрытие модифицированного файла }

| Load St; WriteLn { 'Итоговое содержимое файла: ', St );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 12.9

- 259 -

Напомним, что процедуры Write/Read и BlockWrite/BlockRead при каждом вызове перемещают границу на число прочитанных или записанных записей (компонентов или блоков).

Вызов Seek со значением N, большим чем FileSize, вызовет ошибку ввода-вывода.

 

12.9.3. Усечение файлов

Процедура Truncate(VAR f) связана с прямым доступом в файлы, но с натяжкой. Просто она увязана с процедурой позиционирования Seek.

Назначение процедуры Truncate - «отсекать хвосты» открытого файла f. Вернемся к рис. 12.8. Если текущая позиция соответствует, например, границе 2, то вызовом  Truncate(f) будут удалены все идущие за ней записи с реальными номерами 3, 4, ... , FileSize(f), а сама граница 2 станет концевой.

Комбинация

Seek(f,0);  {установить в начало файла}

Truncate(f); {отсечь все за границей 0}

сделает файл f совершенно пустым. Граница 0 станет первой и последней.

После отсечения нельзя восстановить прежнюю длину (если только не создать все заново). Можно трактовать  Truncate как частичное стирание (Erase). С текстовыми файлами процедура  Truncate не работает.

Несколько слов о работе EOF(f) — функция анализа конца файла f. Как только текущая позиция совпадает с концевой границей (см. рис. 12.5), функция EOF(f) начинает возвращать при опросе значение True. Все остальное время она возвращает значение False.

 

12.10. Процедуры для работы с каталогами

Поскольку Турбо Паскаль ориентирован на работу в среде MS-DOS, естественно, что он содержит средства, специфичные именно для этой ОС. В частности, в системной библиотеке имеются процедуры для работы с каталогами на дисках. Эти процедуры (табл. 12.5 ) практически повторяют набор средств самой MS-DOS.

- 260 -

Таблица 12.5

Для работы с каталогами Турбо Паскаль использует вызовы функций MS-DOS, а они очень чувствительны ко входным значениям имен каталогов и (или) дисков. Поэтому при невозможности выполнения процедуры возникает ошибка времени счета, и программа аварийно останавливается. Этого, однако, не случится, если вызов процедуры будет откомпилирован в режиме {$I-} — программа не будет обрываться. Подробнее об этом см. в разд. 12.11 «Обработка ошибок ввода-вывода» (команды управления каталогами определены как часть библиотеки ввода-вывода).

Процедура GetDir( drive : Byte; VAR S : String ) может определить имя текущего каталога заданного диска. Диск задается его индексом или номером:

0 — текущий диск

1 — диск А:

2 — диск В:

3 — диск С:

и т.д.

Если задать номер диска, отсутствующего в конфигурации ПЭВМ, то возникнет ошибка. После выполнения процедуры переменная S будет содержать полное имя каталога (с указанием буквы диска). Можно использовать GetDir для получения текущей буквы диска:

GetDir( 0, S );

WriteLn( 'Текущий диск-> ', S[1], S[2] );

Возвращаемое в S значение можно потом без изменений использовать в вызовах ChDir и MkDir. Но если надо приписать к нему имя файла, то не забудьте вставить между ними разделитель '\':

GetDir( 1, S );

FullFileName := S + '\' + FileName;

Однако это не лучшее решение задачи, ибо как быть в случае, если

- 261 -

S содержит корневой каталог 'А:\'? Решение может дать процедура FExpand модуля DOS.

Процедура ChDir( S : String ) используется для перехода в какой-либо существующий на диске каталог. Она делает текущим каталог, содержащийся в строке S (точнее, пытается сделать — все зависит от корректности содержимого S). Параметр S может содержать все те же значения, что может принять команда MS-DOS CD (CHDIR). Вот некоторые примеры вызовов:

ChDir('C:\PASCAL\EXE') — задан весь путь;

ChDir('\PASCAL\DOS') — дан путь от корневого каталога;

ChDir('WORK') — переход в подкаталог Work текущего каталога;

ChDir('..') — выход из подкаталога;

ChDir('..\TOOLS') — то же, но с переходом;

ChDir('\') — возврат в корневой каталог;

ChDir('A:') — переход в текущий каталог диска A:

Программа может сама создавать каталоги и подкаталоги, используя процедуру MkDir( S : String ). Параметр S должен содержать корректное имя нового подкаталога и при необходимости путь к нему (маршрут). Если возможно по правилам MS-DOS создать такой каталог, то он будет создан. Перехода в новый каталог при этом не происходит. Примеры обращений к процедуре:

MkDir( 'C:\PASCAL\NEW');

MkDir( 'HOBBY');

MkDir( '..\NEWDIR');

Каталоги можно удалять. Удалить можно любой каталог, если:

1) он совершенно пуст;

2) он не является текущим.

Удаление производится процедурой RmDir( S : String ), где S содержит имя удаляемого каталога. Удаление — процедура, симметричная созданию каталога. Примеры будут аналогичны примерам для процедуры MkDir.

Описанными выше процедурами вовсе не исчерпывается набор средств для работы со структурой дисков. Большое число специальных функций реализовано в модуле DOS и рассматривается в гл. 16.

 

12.11. Обработка ошибок ввода-вывода

Компилятор Турбо Паскаля позволяет генерировать выполнимый код в двух режимах: с проверкой корректности ввода-вывода и без нее. В среде программирования этот режим включается в меню

- 262 -

Options/Compiler/IO-checking. При включении в программу ключ режима компиляции обозначается как

{$I+} — режим проверки включен;

{$I-} — режим отключен.

По умолчанию, как правило, действует режим $I+. Этот ключ компиляции имеет локальную сферу влияния. Можно многократно включать и выключать режим, вставляя в текст программы конструкции {$I+} и {SI-}, тем самым создавая области с контролем ввода-вывода и без него.

При включенном режиме проверки любая ошибка ввода-вывода будет фатальной: программа прервется, выдав номер ошибки. Возможные номера ошибок ввода-вывода находятся в диапазоне от 2 до 200 ( от 2 до 99 — это коды ошибок DOS, от 100 до 149 — ошибки, диагностируемые самой программой, и от 150 до 200 — критические аппаратные ошибки). Расшифровка кодов ошибок с краткими комментариями приведена в табл. 12.6 в конце этого раздела.

Если отключить режим проверки, то при возникновении ошибки ввода-вывода программа уже не будет прерываться, а продолжит работу со следующего оператора. Результат операции ввода-вывода, вызвавшей ошибку, будет неопределен. При этом код ошибки будет сохранен в предопределенной системной переменной InOutRes. Однако для опроса этого кода лучше пользоваться специальной функцией Турбо Паскаля.

 

12.11.1. Функция IOResult

Функция IOResult : Integer возвращает целое число, соответствующее коду последней ошибки ввода-вывода (см. табл. 12.6). Если же операция ввода-вывода прошла без сбоев, то функция вернет значение 0.

Опросить функцию IOResult можно только один раз после каждой операции ввода или вывода, ибо она обнуляет свое значение при каждом вызове. Обычно это обходится запоминанием значения функции в какой-либо переменной. При режиме компиляции операций ввода и (или) вывода {$I+} функция не имеет смысла.

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

 

12.11.2. Примеры обработки ошибок ввода-вывода

Рассмотрим несколько практических примеров (везде далее f — файловая переменная).

- 263 -

1. Обработка отсутствия файла с данными. Если файл отсутствует, то действие процедуры открытия Reset вызовет ошибку (рис. 12.10 ).

| Assign( f, 'NoFile.TXT' );

| {$I-} { выключение проверки ввода-вывода }

| Reset( f ); { попытка открыть файл f }

| {$I+} { восстановление проверки }

| if IOResult<>0 { Если файл не может быть открыт, }

| then { то дать сообщение: }

| WriteLn( 'Файл не найден или не читается' )

| else begin { Иначе (код равен 0) все хорошо }

| Read( f, ... ); { и можно нормально работать с }

| ... { файлом f... }

| Close(f)

| end ; { else и if }

Рис. 12.10

В случае неудачи при открытии файла к нему не надо применять процедуру закрытия Close.

По тому же принципу можно построить функцию анализа существования файла (рис. 12.11).

| FUNCTION FileExists( FileName : String ) : Boolean;

| VAR

| f : File; { тип файла не важен }

| BEGIN

| Assign( f, FileName ); { связывание файла f }

| {$I-} Reset( f ); {$I+} { открытие без контроля }

| if IOResult=0 { Если файл существует, }

| then begin { то его надо закрыть }

| Close{ f );

| FileExists := True end { then }

| else { иначе просто дать знать}

| FileExists := False;

| END;

Рис. 12.11

2. Выбор режима дозаписи в текстовый файл или его создания. Механизм остается тот же (рис. 12.12). Здесь f — текст-файловая переменная.

- 264 -

| Assign(f,'XFile.TXT'); {связывание файла f }

| {$I-} Append( f ); {$I+} {попытка открыть его для дозаписи}

| if IOResult<>0 {Если файл не может быть открыт, }

| then Rewrite( f ); {то создать его. }

| ...

| Write( f, ...); { нормальная работа с файлом }

| ...

| Close( f );

Рис. 12.12

3. Переход в заданный каталог или его создание, если переход возможен (рис. 12.13, S — строковая переменная).

| S := 'C:\NEWDIR'; { задано имя каталога }

| {$I-} ChDir( S ); {$I+} { попытка перейти в него }

| if IOResult<>0 { Если не получается, }

| then begin

| MkDir( S ); {то сначала создать его, }

| ChDir( S ) { а уж потом перейти. }

| end ; { if }

| { Подразумевается, что каталог S в принципе создаваем. }

Рис. 12.13

4. Построение «умных» ждущих процедур чтения данных с клавиатуры. Такие процедуры не будут реагировать на данные не своего формата (рис. 12.14).

| { Здесь используется ряд процедур из библиотеки }

| CRT; { модуля CRT. Они отмечены * в комментариях. }

{Процедура считывает с клавиатуры значение типа Integer, помещая его в переменную V. При этом игнорируется любой ввод, не соответствующий этому типу. X и Y — координаты текста запроса Comment. Проверка корректности значений X и Y не производится. }

PROCEDURE ReadInteger( X,Y : Byte; Comment : String;

| VAR V : Integer );

Рис. 12.14

- 265 -

| CONST

| zone =12; { ширина окна зоны ввода числа }

| VAR

| WN.WX : Word; {переменные для хранения размеров окна }

| BEGIN

| WN:=WindMin; WX:=WindMax; {Сохранение текущего окна }

| {$I-} { отключение режима проверки }

| GotoXY( X,Y ); {*перевод курсора в X,Y }

| Write( Comment ); { печать комментария ввода }

| Inc(X, Length(Comment)); { увеличение координаты X }

| Window( X,Y, X+zone,Y ); {*определение окна на экране }

| Repeat { Главный цикл ввода числа: }

| ClrScr; {* очистка окна ввода, }

| ReadLn( V ); { считывание значения при $I- }

| until (IOResult=0); { пока не введено целое }

| {$I+} { включение режима проверки }

| {*восстановление окна: }

| Window( Lo(WN)+1, Hi(WN)+1, Lo(WX)+1, Hi(WX)+1 )

| END ; {proc}

| VAR i : Integer; { === ПРИМЕР ВЫЗОВА ПРОЦЕДУРЫ === }

| BEGIN

| ClrScr; {* очистка экрана }

| ReadInteger(10,10,'Введите целое число: ',i); { вызов }

| WriteLn; WriteLn( 'Введено i=', i ); { контроль }

| ReadLn { пауза до нажатия ввода}

| END.

Рис 12.14 (окончание)

В примере можно попутно устроить проверку диапазона значений V, переписав условие окончания цикла в виде

until (IOResult=0) and (VVmin);

где Vmax и Vmin — границы воспринимаемых значений V. Аналогичным способом, меняя лишь типы переменной V, можно определить процедуры ReadByte, ReadWord, ReadReal и т.п. Справедливости ради надо отметить, что хотя описанная процедура ReadInteger спокойно относится к попыткам впихнуть в нее буквы, дроби и прочие неподходящие символы, она чувствительна к превышению диапазона значений типа Integer во входном числе и не обрабатывает его.

5. Работа с текстовыми файлами данных произвольного формата. Пусть существует файл из N столбцов цифр, содержащий в некоторых строках словесные комментарии вме-

- 266 -

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

| CONST N=3; { пусть в файле данные даны в трех столбцах }

| VAR

| f : Text; { текст-файловая переменная }

| i : Byte; { счетчик }

| D : Array [1..N] of Real; { значения одной строки }

| { данных в формате Real }

| BEGIN

| Assign(f,'EXAMPLE.DAT'); { связывание файла f }

| Reset( f ); { открытие файла для чтения }

| {$I-} { отключение режима проверки }

| while not SeekEOF(f) do { Цикл до конца файла: }

| begin

| Read( f, D[1] ); { попытка считать 1-е число }

| if IOResult=0 { Если это удалось,то затем }

| then begin { читаются остальные числа: }

| for i:=2 to N do Read( f, D[i] );

| { и как-либо обрабатываются: }

| WriteLn( D[1]:9:2, D[2]:9:2, D[3]:9:2 )

| end ; { if 10...}

| ReadLn( f ) { переход на следующую строку }

| end ; {while} { конец основного цикла }

| {$I+} { включение режима проверки }

| Close( f ); { закрытие файла f }

| ReadLn { пауза до нажатия ввода }

| END.

Рис. 12.15

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

Обращаем внимание на то, что во всех примерах подразумевается общий режим компиляции {$I+}, который в них всегда восстанавливается после завершения операции ввода-вывода. Советуем компилировать программы и модули в режиме {$I+}, используя его отключение только там, где действительно нужно обработать ошибку.

 

12.11.3. Сводка номеров ошибок ввода-вывода

Все ошибки, которые могут быть проанализированы функцией IOResult, подразделяются на три группы: ошибки, диагностируемые

- 267 -

MS-DOS (их номера не превышают 99), затем файловой системой Турбо Паскаля (номера от 100 до 159), и критические ошибки, диагностируемые аппаратно. Сводка всех номеров ошибок, относящихся к работе с файлами приводится в табл. 12.6.

Таблица 12.6

Описание ошибок

I. ОШИБКИ УРОВНЯ DOS

2	File not found (файл не найден) ИСТОЧНИК: Reset, Append, Rename, Erase. Физический файл, связанный с файловой переменной, не найден или не существует.
3	Path not found (каталог/маршрут/ не найден) ИСТОЧНИК: Reset, Rewrite, Append, Rename, Erase. Имя файла на диске, связанное с файловой переменной, является неправильным или указывает на несуществующий подкаталог. ИСТОЧНИК: ChDir, MkDir, RmDir. Заданный маршрут является недействительным или содержит несуществующий подкаталог.
4	Too many open files (слишком много открытых файлов) ИСТОЧНИК: Reset, Rewrite, Append, Rename, Erase. Программа имеет слишком много открытых файлов. Увеличьте число в параметре FILES= файла CONFIG.SYS и перезагрузите систему.
5	File access denied (отказано в доступе к файлу) ИСТОЧНИК: Reset, Append, Rewrite. Открытие файла допускает запись (согласно значение переменной FileMode), но физический файл является каталогом или файлом, доступным только для чтения, а в случае Rewrite — эта ошибка возникает еще, когда в каталоге нет свободного места. ИСТОЧНИК: Rename. Имя физического файла совпадает с именем каталога, или новое имя указывает уже существующий файл. ИСТОЧНИК: Erase. Попытка стереть каталог или файл, доступный только для чтения. ИСТОЧНИК: MkDir. Имя уже использовано в этом каталоге, или в каталоге нет места, или имя есть имя устройства DOS. ИСТОЧНИК: RmDir. Заданное имя определяет непустой либо несуществующий каталог, или оно задает корневой каталог. ИСТОЧНИК: Read/Write и BlockRead/BlockWrite. Попытка считывать (записывать) данные в еще не открытый файл.

- 268 -

6	Invalid file handle (недопустимый файловый канал) Эта ошибка появляется только при нарушении внутренней работы файловой системы, и ее возникновение является свидетельством того, что файловая переменная испорчена каким-либо образом.
12	Invalid file access code (неверный код доступа к файлам) ИСТОЧНИК: Reset, Append. Значение переменной FileMode в момент открытия файла было несоответствующим команде открытия.
15	Invalid drive number (неверный номер дисковода) ИСТОЧНИК: GetDir. Заданный номер диска при текущей конфигурации ПЭВМ не имеет смысла.
16	Cannot remove current directory (нельзя удалить текущий каталог). ИСТОЧНИК: RmDir. Справедливое замечание на попытку срубить под собой сук
17	Cannot rename across drives (нельзя при переименовании указывать разные дисководы) ИСТОЧНИК: Rename.

II. ОШИБКА УРОВНЯ ФАЙЛОВОЙ СИСТЕМЫ

100	Disk read error (ошибка чтения с диска) ИСТОЧНИК: Read. Возникает в типизированном файле при попытке осуществить считывание после конца файла.
101	Disk write error (ошибка записи на диск) ИСТОЧНИК: Close, Flush, Write/WriteLn, BlockWrite. Диск заполнен до отказа.
102	File not assigned (файл не связан) ИСТОЧНИК: Reset, Rewrite, Append, Rename, Erase. С переменной логического файла (файловой переменной) не было связано имя физического файла через вызов процедуры Assign.
103	File not open (файл не открыт) ИСТОЧНИК: Close, Flush, Read/Write, Seek, EOF, FilePos, FileSize, BlockRead/BlockWrite. Попытка операции ввода-вывода с еще не открытым файлом.
104	File not open for input (файл не открыт для ввода) ИСТОЧНИК: Read, ReadLn, EOF, EOLn, SeekEOF, SeekEOLn. Попытка прочитать информацию из текстового файла, не открытого для чтения.

- 269 -

105	File not open for output (файл не открыт для вывода) ИСТОЧНИК: Write, WriteLn. Попытка записать информацию в текстовый файл, не открытый для записи.
106	Invalid numeric format (неверный числовой формат) ИСТОЧНИК: Read, ReadLn. Числовое значение, считанное из текстового файла, не соответствует числовому формату соответствующего типа данных.

III. КРИТИЧЕСКИЕ ОШИБКИ

150	Disk is write-protected (диск защищен от записи)
151	Unknown unit (неизвестный аппаратный модуль)
152	Drive not ready (дисковод не готов )
153	Unknown comnand (неопознанная команда)
154	CRC error in data (ошибка контроля данных в ОС)
155	Bad drive request structure length (при запросе к диску указана неверная длина структуры)
156	Disk seek error (ошибка при операции позиционирования головок на диске)
157	Unknown media type (неизвестный тип носителя)
158	Sector not found (сектор на диске не найден)
159	Printer out of paper (кончилась бумага на принтере)
160	Device write fault (ошибка при записи на устройство)
161	Device read fault (ошибка при чтении с устройства)
162	Hardware failure (сбой аппаратуры)

- 270 -

 

13.1. Определения объектов

Объект — это такая структура, компонентами которой являются взаимосвязанные данные различных типов и использующие эти данные процедуры и функции. Компоненты-данные называются полями объекта, а компоненты-процедуры и функции называются

- 271 -

методами. Для обозначения типа «объект» в языке имеется служебное слово OBJECT. Тип объекта описывается способом, похожим на задание типа «запись»:

TYPE

ИмяОбъекта = OBJECT

ПоляДанных;

ЗаголовкиМетодов;

END;

Конкретную переменную, объявленную типом ИмяОбъекта, принято называть экземпляром этого типа.

Рассмотрим в качестве примера основные типы объектов для работы с символьной и текстовой информацией. При построении объектов всегда следует начинать с определения самого нижнего (элементарного) уровня данных и действий. Так, при работе с текстовой информацией на дисплее за нижний уровень представления данных можно принять позицию курсора (назовем ее ObjPos), определяемую двумя параметрами: номером строки (Line) и номером позиции в ней, т.е. столбцом (Col). Для задания позиции и символа объявляем процедуру Init, которая должна присваивать значения полям Line и Col, а для определения позиции вводим две функции: GetLine и GetCol (рис. 13.1). Метод Print не выполняет здесь никаких действий, но понадобится в дальнейших примерах.

TYPE

ObjPos = OBJECT

Line : Word; { номер строки }

Col : Word; { номер столбца }

PROCEDURE Init(init_line, init_col : Word);

FUNCTION GetLine : Word; { опрос Line }

FUNCTION GetCol : Word; { опрос Col }

PROCEDURE Print { зарезервировано }

END;

PROCEDURE ObjPos.Init( init_line, init_col : Word );

BEGIN

Line := init_line; { метод задания номера строки }

Col := init_col; { метод задания номера столбца }

END;

Рис. 13.1

- 272 -

FUNCTION ObjPos.GetLine : Word;

BEGIN

GetLine := Line { метод опроса номера строки }

END ;

FUNCTION ObjPos.GetCol : Word;

BEGIN GetCol := Col { метод опроса номера столбца }

END ;

PROCEDURE ObjPos.Print;

{ пустая процедура вывода }

BEGIN

Write( #7 ); { это вызовет звуковой сигнал }

END ;

VAR ObjPosVar : ObjPos;

{ объявление экземпляра объекта }

(*Прочие описания типов, переменных, процедур, функций*)

BEGIN

{ Пример вызова метода назначения позиции: }

ObjPosVar.Init( 5, 15 );

...

END .

Рис. 13.1 (окончание)

В описании объекта фиксируется только название метода, в то время как его реализация в виде процедуры или функции может находиться в каком-либо из блоков описания процедур и функций. При реализации метода перед его именем обязательно указывается имя типа объекта, которому принадлежит метод. Разделителем имен служит точка «.». Обращаем внимание на то, что после объявления конкретного экземпляра объекта (на рис. 13.1 это переменная ObjPosVar) вызов метода предваряется уже не именем типа, а именем конкретного экземпляра.

Задание заголовка метода в описании типа объекта можно считать опережающим описанием (FORWARD), и поэтому при реализации метода можно не включать в его заголовок список формальных параметров.

Объектный подход подразумевает, что объявляемый в программе объект содержит исчерпывающие данные о соответствующем «физическом» объекте, поэтому методы, объявляемые в объекте, должны по возможности обращаться только к друг другу и к полям

- 273 -

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

ObjPosVar.Line := 5;

ObjPosVar.Col := 15;

Но в таком случае мы, во-первых, как бы «выносим» метод за границы объекта, а во-вторых, метод назначения позиции может быть гораздо более сложным (и мы это покажем позже), и в случае его изменения придется переделывать все присваивания вместо одного единственного метода. В ООП должно выполняться «джентльменское» соглашение: доступ к полям-данным объекта должны иметь только методы этого объекта. Нарушение этого правила может свести на нет все преимущества объектного подхода.

При объявлении объектов должны выполняться следующие требования:

— описание типа «объект» может производиться только в блоке определения типов TYPE основной программы или в разделах модулей; нельзя описывать локальные объекты в подпрограммах;

— при описании типа объекта все поля данных должны находиться перед описаниями методов;

– компоненты объекта не могут быть файлами, а файлы, в свою очередь, не могут содержать компоненты типа «объект».

Данные типа «объект» не могут быть записаны в файл на диске. Тем не менее в демонстрационном архиве OOP.ARC пакета Турбо Паскаль приведены две программы: OBJECTS.PAS и ODEMO.PAS, которые совместно с находящимися там же ассемблерными вставками реализуют механизм хранения объектов на диске.

 

13.2. Область действия полей объекта и параметр Self

Область действия (domain) полей данных объекта неявно распространяется на тела процедур и функций, реализующих методы этого объекта. В примере на рис. 13.1 метод Init (процедура) работает с полями Line и Col объекта типа ObjPos, обращение к которым не требует указания имени объекта. Можно сказать, что внутри методов объекта действует неявный оператор WITH. Следствием этого является то, что формальные параметры метода (если присутствуют) не могут совпадать по имени ни с одним из полей данных соответствующего объекта.

- 274 -

Мы не раз подчеркивали, что внешне объекты очень похожи на записи. Так же, как и записи, они могут явно записываться в теле оператора WITH :

VAR

ObjPosVar : ObjPos; { экземпляр объекта }

...

with ObjPosVar do { оператор присоединения }

BEGIN

Init( 1,1); { имя экземпляра опущено }

...

Init( GetLine+1, GetCol+1 );

...

end; { with }

Всякий раз, когда вызывается метод какого-либо объекта, в него, кроме фактических параметров, передается невидимый параметр Self («свой», «внутренний»). Он указывает, какому объекту принадлежит метод. Так, метод Init из примера на рис. 13.1 воспринимается компилятором так, как если бы он был описан следующим образом:

PROCEDURE ObjPos.Init( init_line, init_col : Word );

BEGIN

Self.Line := init_line; { метод задания номера строки }

Self.Col := init_col { метод задания номера столбца }

END;

Компилятор автоматически обрабатывает параметр Self, поэтому не стоит использовать его явно. Исключением является случай, когда идентификаторы начинают «конфликтовать» в пределах методов. На рис. 13.2 показано, как, используя в методе объекта параметр Self, разрешить конфликт между полями самого объекта и формального параметра (записи).

| TYPE

| PosRec = RECORD { запись }

| Line, Col : Word; { номера строки и столбца }

| END;

| ObjPos = OBJECT { объект }

| Line, Col : Word; { номера строки и столбца }

| PROCEDURE Init2( Pos : PosRec ); { метод }

| END;

Рис. 13.2

- 275 -

PROCEDURE ObjPos.Init2( Pos : PosRec );

| BEGIN

| with Pos do begin

{ присоединение для записи Pos }

| Self.Line:= Line; { Self развязывает одинаковые имена}

| Self.Col := Col

| end {with}

| END;

Рис. 13.2 (окончание)

 

13.3. Наследование

При помощи объекта типа ObjPos (см. рис. 13.1) определяется положение какого-либо символа в тексте на дисплее, но сам символ в нем не определен. Объявим объект с именем ObjSym, добавляющий символ и выполняющий определенные действия с ним (рис. 13.3).

| USES CRT; { в примере используется системный модуль CRT }

| TYPE

| ObjSym = OBJECT

| Line : Word; { номер строки с Sym }

| Col : Word; { номер столбца с Sym }

| Sym : Char; { поле-значение символа }

| PROCEDURE Init(init_line,init_col : Word;

| init_sym : Char);

| FUNCTION GetLine : Word; { опрос Line }

| FUNCTION GetCol : Word { опрос Col }

| PROCEDURE Print { вывод Sym }

| END;

| PROCEDURE ObjSym.Init; { инициализация полей объекта }

| BEGIN

| Line := init_line; { метод задания номера строки }

| Col := init_col; { метод задания номера столбца }

| Sym := init_sym { задание значения символа } END ;

| FUNCTION ObjSym.GetLine : Word;

| BEGIN

| GetLine := Line { метод опроса номера строки }

| END;

Рис. 13.3

- 276 -

| FUNCTION ObjSym.GetCol : Word;

| BEGIN

| GetCol := Col

| { метод опроса номера столбца }

| END ;

| PROCEDURE ObjSym.Print;

| BEGIN

| CRT.GotoXY(Col,Line);

| { процедура из библиотеки CRT }

| Write( Sym ) { вывод символа в позиции }

| END ;

Рис. 13.3 (окончание)

Обратите внимание на то, что в задании нового объекта использовались поля данных и два метода GetLine и GetCol, идентичные полям и методам ранее описанного объекта ObjPos. Метод Init переписан заново, а поле Sym и, по сути, метод Print просто добавлены. Можно сказать, что более сложный объект, описывающий символ в тексте, унаследовал свойства и методы объекта-позиции. Методология ООП строится как раз на построении такого ряда объектов, в котором можно было бы проследить развитие и наследование свойств от простых структур к сложным.

Синтаксически наследование выражается следующим образом. В случае определения типа объекта, как производного от уже существующего, имя прародительского объекта заключается в круглые скобки после служебного слова OBJECT:

TYPE

ИмяОбъектаНаследника = OBJECT( ИмяОбъектаПрародителя )

НовыеПоляОбъектаНаследника;

НовыеМетодыОбъектаНаследника;

END;

Пример на рис. 13.3 по правилам ООП и Турбо Паскаля должен выглядеть, как показано на рис. 13.4 (на нем не показаны, но используются определения, введенные ранее на рис. 13.1).

Тип «наследник» иногда называется производным типом, а тип, от которого производится наследование («прародитель») — прародительским типом. Таким образом, отличие объекта от записи состоит не только в объединении полей и методов «под одной крышей», но и в способности объектов к наследованию. Поля и методы прародителя могут появляться в телах методов наследника, как если бы они были объявлены явно. На рис. 13.4 это иллюстрируется методом Init, который для инициализации полей

- 277 -

| USES CRT; { в примере используется системный модуль CRT }

| {*3десь должны быть определения, введенные на рис.13.1*}

| TYPE

| ObjSym = OBJECT ( ObjPos ) { объявление наследования }

| Sym : Char; { поле-значение символа }

| PROCEDURE Init(init_line, init_col : Word;

| init_sym : Char );

| PROCEDURE Print { метод вывода символа }

| END;

| PROCEDURE ObjSym.Init;

| BEGIN

| ObjPos.Init( init_line, init_col ); {задание позиции }

| Sym := init_sym { задание значения символа }

| END;

| PROCEDURE ObjSym.Print;

| BEGIN

| CRT.GotoXY(Col, Line); {процедура из библиотеки CRT}

| Write( Sym ) { вывод символа в позиции }

| END;

Рис. 13.4

Line и Col, «по наследству» перешедших к объекту ObjSym, пользуется наследуемой процедурой ObjPos.Init.

Продолжая ряд наследования, можно ввести объект, описывающий символ совместно с его цветовым атрибутом. Для этого достаточно описать объект, производный от ObjSym и добавляющий поле данных для атрибута и методы его назначения или опроса. Такой объект будет третьим уровнем наследования, если считать от базового объекта ObjPos. Но можно объявить и объект того же уровня наследования по отношению к ObjPos, что и ObjSym. Определим, к примеру, объект «подстрока» (он пригодится в последующих примерах). Для задания подстроки надо указать координаты ее начала номер строки и столбца) и само содержимое подстроки, которое содержит в себе указание на ее длину. Можно создать объект типа ObjString, описывающий подстроку, как производный от объекта-позиции (рис. 13.5).

Процесс наследования является транзитивным: если тип объекта TypeB наследуется от типа объекта TypeA, а тип TypeC наследуется от TypeB, то тип объекта TypeC также считается наследником типа TypeA. Таким образом, можно получить иерархию объектов, связан-

- 278 -

| TYPE

| ObjString = OBJECT ( ObjPos )

| SubSt : String; { поле-значение подстроки }

| PROCEDURE Init( init_line, init_col:Word;

| init_ss:String );

| PROCEDURE Print { вывод SubSt в позиции }

| END;

| PROCEDURE ObjString.Init; { инициализация полей объекта }

| BEGIN

| ObjPos.Init( init_tine, init_col ); {задание позиции }

| SubSt := init_ss { задание значения подстроки }

| END;

| PROCEDURE ObjString.Print;

| BEGIN

| CRT.GotoXY(Col, Line); { процедура из библиотеки CRT }

| Write( SubSt ) { печать подстроки в позиции }

| END;

Рис. 13.5

ных «родственными» отношениями. Как правило, основная часть работы по написанию объектно-ориентированных программ состоит в построении именно иерархий объектов.

При наследовании полей в производных типах уже нельзя объявлять их идентификаторы, определенные в одном из прародительских типов. Однако на методы это ограничение не распространяется. Производный объект может переопределять любой из методов, наследуемый от своих прародителей. Если описание метода в производном типе вводит тот же идентификатор для метода, что и описание метода в прародительском типе, то в этом случае ко всем последующим потомкам переходит переопределенный метод (пока он не будет заново переопределен). Следует отметить, что во всех прародительских типах действуют те методы, которые были определены изначально именно для них.

Несколько слов о «хорошем тоне» ООП. В случае, если в производном типе описывается новая процедура инициализации, в ней обычно вначале вызывается процедура инициализации непосредственного прародителя. Так удобно поступать еще и потому, что это самый естественный способ проинициализировать наследуемые поля предназначенным для этого методом.

- 279 -

 

13.4. Присваивание объектов

Из «умения» объектов наследовать вытекают новые правила присваивания для переменных типа «объект» (экземпляров). Им можно присваивать не только значения этого же типа, но и любого производного от него. Аналогичное правило совместимости типов действует при передаче в процедуру или функцию параметров типа «объект». Например, если в программе объявлены переменные типа «объект»:

VAR

ObjPosVar : ObjPos; { переменная - позиция в тексте }

ObjSymVar : ObjSym; { переменная - символ в позиции }

то для копирования позиции, записанной в ObjSymVar, в переменную ObjPosVar достаточно выполнить присваивание

ObjPosVar := ObjSymVar;

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

Прародитель <-- Наследник.

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

Переменные типа «объект» могут быть динамическими, т.е. объявляться как ссылки:

VAR

ObjPosVarPtr : ^ObjPos; { ссылка на позицию в тексте }

ObjSymVarPtr : ^ObjSym; { ссылка на символ в позиции }

После создания динамических объектов процедурой или функцией New ссылки (как разыменованные, так и сами по себе) могут присваиваться друг другу. Правила совместимости останутся теми же: корректными будут только присваивания ссылок на наследников ссылкам на прародителей:

- 280 -

ObjPosVarPtr := ObjSymVarPtr; { передача ссылки }

ObjPosVarPtr^ := ObjSymVarPtr^; { передача полей }

 

13.5. Полиморфизм

Подобно расширенным правилам присваивания, совместимость типов при передаче в процедуру или функцию параметров типа «объект» также понимается полнее. Формальному параметру типа «объект» может соответствовать фактический параметр не только этого же типа, но и типа, производного от него. Такое свойство совместимости объектов носит название полиморфизма. Практическим примером его использования могла бы стать процедура, выводящая либо строку, либо символ на экран. Несмотря на различие входных параметров (строка или символ), процедура будет одна — но она должна работать с объектами. В самом деле, ранее мы ввели объект-позицию ObjPos и производные от него типы ObjSym и ObjString. Если описать в процедуре формальный параметр как имеющий тип ObjPos, то по правилу совместимости в процедуру можно будет передавать фактические параметры других, производных от него типов, т.е. типов ObjSym и ObjString, и даже производных от них! Такая процедура приведена на рис. 13.6.

{ Считаются описанными типы ObjPos, ObjSym и ObjStr

(см. рис. 13.1, 13.4 и 13.5)

Процедура выводит полиморфный объект (строку или символ)}

| PROCEDURE PrintObj( VAR Obj : ObjPos );

| BEGIN

| Obj.Print

| END;

| VAR

| ObjSymVar : ObjSym; { экземпляр типа ObjSym }

| ObjStringVar : ObjString; { экземпляр типа ObjString }

| BEGIN { пример инициализации и вывода }

| ObjSymVar.Init( 10, 10, '*' );

| ObjStringVar.Init( 20, 20, '...ПОДСТРОКА...' );

| PrintObj( ObjStringVar );

| PrintObj( ObjSymVar );

| END.

Рис. 13.6

- 281 -

Обращаем внимание на легкость реализации процедуры. Она не зависит от процессов внутри объектов, а только вызывает нужный нам метод обработки полей данных (разнотипных). Поскольку мы предварительно сами позаботились о том, чтобы у всех наших объектов был одинаковый по написанию метод Print, его запись в процедуре встречается один раз. Но здесь необходимо сделать оговорку. Несмотря на внешнюю правильность примера, он будет работать не совсем корректно: всегда будет срабатывать метод Print для типа объекта ObjPos, независимо от типа фактического параметра. Это происходит потому, что во всех объявленных выше объектах используются статические методы.

 

13.5.1. Статические методы

Такое название методов связано с тем, что размещение соответствующих ссылок на них осуществляется еще на этапе компиляции.

Обработка компилятором статических методов похожа на обработку статических переменных. Действия компилятора при обработке методов объектов, составляющих некую иерархию, таковы:

1. При вызове метода компилятор устанавливает тип объекта, вызывающего метод.

2. Установив тип, компилятор ищет метод в пределах типа объекта. Найдя его, компилятор назначает вызов этого метода.

3. Если указанный метод не найден, то компилятор начинает рассматривать тип непосредственного прародителя и ищет метод, имя которого вызвано, в пределах этого прародительского типа. В случае, если метод с таким именем найден, вызов заменяется на вызов метода прародителя.

4. Если же искомый метод отсутствует в типе ближайшего прародителя, то компилятор переходит к типу следующего прародителя («дедушке») нашего типа, где и осуществляет дальнейший поиск. Процесс продолжается до тех пор, пока вызванный метод не будет найден, иначе компилятор, дойдя до самого последнего типа («родоначальника») и не найдя метод, имя которого вызывается, выдаст сообщение об ошибке компиляции номер 44 Field identifier expected («Ожидается идентификатор поля»). Это говорит о том, что метод с таким именем не определен.

Из всего этого следует одна важная особенность. Если метод прародителя вызывает другие методы, то последние также будут методами прародителя, даже если потомки имеют свои собственные методы.

- 282 -

Применительно к примеру на рис. 13.6 сработают правила 1 и 2, и будет выполнен метод, объявленный в типе формального параметра (т.е. ObjPos.Print). Для того чтобы процедура заработала правильно, необходимо объявить метод Print виртуальным.

 

13.5.2. Виртуальные методы

13.5.2.1. Виртуализация методов. Из правил совместимости фактических и формальных параметров типа «объект» следует, что в качестве фактического параметра может выступать объект любого производного типа от типа формального параметра. Таким образом, во время компиляции процедуры неизвестно, объект какого типа будет ей передан в качестве фактического параметра (такой параметр называется полиморфным объектом). В полной мере полиморфизм объектов и методов реализуется при помощи виртуальных методов.

Метод становится виртуальным, когда за его определением в типе объекта ставится служебное слово VIRTUAL:

PROCEDURE ИмяМетода( параметры ); VIRTUAL;

или

FUNCTION ИмяМетода( параметры ) : ТипЗначения; VIRTUAL;

При виртуализации методов должны выполняться следующие условия:

1. Если прародительский тип объекта описывает метод как виртуальный, то все его производные типы, которые реализуют метод с тем же именем, должны описать этот метод тоже как виртуальный. Другими словами, нельзя заменять виртуальный метод статическим. Если же это произойдет, компилятор сообщит об ошибке номер 149 VIRTUAL expected («Ожидается служебное слою VIRTUAL»).

2. Если переопределяется реализация виртуального метода, то заголовок заново определяемого виртуального метода в производном типе не может быть изменен. Иначе говоря, должны остаться неизменными порядок расположения, количество и типы формальных параметров в одноименных виртуальных методах. Если этот метод реализуется функцией, то не должен изменяться и тип результата. При изменении заголовка метода компилятор выдаст сообщение об ошибке номер 131 Header does not match previous definition («Заголовок не соответствует предыдущему определению»).

- 283 -

3. В описании объекта должен обязательно описываться специальный метод, инициализирующий объект (обычно ему дают название Init). В этом методе служебное слово PROCEDURE в объявлении и реализации должно быть заменено на слово CONSTRUCTOR. Это служебное слово обозначает особый вид процедуры — конструктор, который выполняет установочную работу для механизма виртуальных методов. Все типы объектов, которые имеют хотя бы один виртуальный метод, должны иметь конструктор. Конструктор всегда вызывается до первого вызова виртуального метода. Вызов виртуального метода без предварительного вызова конструктора может привести систему к тупиковому состоянию, а компилятор не проверяет порядок вызовов методов. Помните об этом!

13.5.2.2. Конструкторы и таблица виртуальных методов. Каждый экземпляр (переменная) типа «объект», содержащий виртуальные методы, должен инициализироваться отдельным вызовом конструктора. Если переменная А инициализирована вызовом конструктора, а переменная В того же типа не инициализирована, то присваивание В:=А не инициализирует переменную В и при вызове ее виртуальных методов программа может «зависнуть».

Чтобы понять, что делает конструктор, разберемся в механизме реализации виртуальных методов. Каждый объектный тип (именно тип, а не экземпляр) имеет «таблицу виртуальных методов» (VMT), которая содержит размер типа объекта и адреса кодов процедур или функций, реализующих каждый из его виртуальных методов. При вызове виртуального метода каким-либо экземпляром местонахождение кода реализации этого метода определяется по таблице VMT для типа этого экземпляра. Конструктор же устанавливает связь между экземпляром, который вызывает конструктор, и таблицей виртуальных методов данного объектного типа. Если же конструктор не будет вызван до обращения к виртуальному методу, то перед компьютером станет вопрос, где же искать этот метод. Это и приведет к тупиковой ситуации.

Важно помнить, что таблица виртуальных методов — одна для каждого типа, а не у каждой переменной типа «объект». Переменная лишь держит связь с таблицей своего типа, и эта связь устанавливается конструктором. В объекте может быть определено несколько конструкторов. Сами конструкторы могут быть только статическими, хотя внутри конструктора могут вызываться и виртуальные методы.

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

- 284 -

через соответствующую объекту таблицу VMT. Это гарантирует, что сработают именно те методы, которые подразумевались при объявлении типа объекта. Кроме того, если объект Z наследует от объекта Y виртуальный метод, вызывающий другие методы, то последние вызовы будут относиться к методам объекта Z, а не Y. В случае статических методов все было бы наоборот (вызовы не «вернулись» бы в Z).

Мы начали этот раздел с примера полиморфной процедуры (см. рис. 13.6). Чтобы она заработала, надо сделать некоторые методы виртуальными и объявить конструкторы в объектах. Это проделано на рис. 13.7.

| USES CRT; { в примере используется системный модуль CRT }

| TYPE

| ObjPos = OBJECT

| Line : Word; { номер строки }

| Col : Word; { номер столбца }

| { ! } CONSTRUCTOR Init(init_line,init_col: Word);

| { ! } PROCEDURE Print; VIRTUAL { зарезервировано }

| END;

| CONSTRUCTOR ObjPos.Init( init_line, init_col : Word );

| BEGIN

| Line := init_line; { метод задания номера строки }

| Col := init_col; { метод задания номера столбца }

| END;

| PROCEDURE ObjPos.Print; { пустая процедура вывода }

| BEGIN

| Write( #7 ); { это вызовет звуковой сигнал }

| END;

| TYPE

| ObjSym = OBJECT ( ObjPos ) { объявление наследования }

| Sym : Char; { поле-значение символа }

| { ! } CONSTRUCTOR Init(init_line,init_col : Word;

| init_sym : Char);

| {!} PROCEDURE Print; VIRTUAL {метод вывода Sym }

| END;

| CONSTRUCTOR ObjSym.Init;

| BEGIN

| ObjPos.Init( init_line, init_col ); { задание позиции }

| Sym := init_sym { задание значения символа }

| END;

Рис. 13.7

- 285 -

| PROCEDURE ObjSym.Print;

| BEGIN CRT.GotoXY( Col, Line );

| { процедура из модуля CRT }

| Write( Sym )

| { вывод символа в позиции }

| END;

| TYPE

| ObjString= OBJECT ( ObjPos )

| SubSt : String; { поле-значение подстроки }

| { ! }

| CONSTRUCTOR Init(init_line,init_col: Word;

| init_ss : String);

| { ! }

| PROCEDURE Print; VIRTUAL

| {метод вывода SubSt }

| END ; CONSTRUCTOR ObjString.Init;

| {инициализация полей объекта }

| BEGIN

| ObjPos.Init( init_line, init_col );

| {задание позиции }

| SubSt := init_ss { задание значения подстроки }

| END;

| PROCEDURE ObjString.Print;

| BEGIN CRT.GotoXY( Col, Line };

| {процедура из библиотеки CRT }

| Write( SubSt ) {печать подстроки в позиции }

| END ;

| {Вывод полиморфного объекта (строки или символа) }

| PROCEDURE PrintObj( VAR Obj : ObjPos );

| BEGIN Obj.Print END;

| { =========== ТЕЛО ОСНОВНОЙ ПРОГРАММ ================ }

| VAR ObjSymVar : ObjSym;

| { экземпляр типа ObjSym }

| ObjStringVar : ObjString; { экземпляр типа ObjString }

| BEGIN { Инициализация и вывод: }

| ClrScr; { очистка экрана }

| ObjSymVar.Init( 10, 10, '*' );

| ObjStringVar.Init( 20, 20, '...ПОДСТРОКА...' );

| PrintObj( ObjStringVar ); { вывод строки }

| PrintObj( ObjSymVar ); { вывод символа }

| END.

Рис. 13.7 (окончание)

- 286 -

Весьма важным является наличие слова VAR перед формальным параметром в процедуре PrintObj. В этом случае мы передаем сам объект. Если бы в процедуре PrintObj формальный параметр был описан как параметр-значение (без слова VAR), то процедура работала бы с копией объекта, приведенной к типу формального параметра. В примере на рис. 13.7 это выразилось бы в том, что несмотря на виртуальность методов, вызывался бы метод ObjPos.Print из типа формального параметра.

 

13.5.3. Выбор вида метода

При объектно-ориентированном программировании на Турбо Паскале приходится все время решать дилемму: «Каким быть методу, статическим или виртуальным?» При решении этого вопроса пользуйтесь следующим критерием: делайте метод виртуальным, если есть хотя бы малейшая вероятность того, что понадобится переопределение этого метода. Это обеспечит расширяемость программ.

Другим критерием выбора может быть скорость выполнения программы. Если объект имеет хотя бы один виртуальный метод, то для него создается таблица виртуальных методов, и каждая переменная этого типа будет иметь связь с этой таблицей. Каждый вызов виртуального метода проходит через обращение к таблице VMT. С другой стороны, статические методы вызываются «напрямую», поэтому вызов статического метода происходит быстрее, чем виртуального. А если объект вообще не содержит виртуальных методов, то таблица виртуальных методов не будет создана и, как следствие этого, каждая переменная такого типа не будет поддерживать связь с таблицей VMT.

Так что выбор надо делать между некоторым (малозаметным) увеличением скорости вычислений при эффективном использовании памяти, которое дают статические методы, и гибкостью, предоставляемой виртуальными методами.

 

13.6. Динамические объекты

 

13.6.1. Создание динамических объектов

Объекты могут быть размещены в динамической области памяти («куче»). Для этого они должны объявляться как ссылки, подобно любым другим динамическим структурам данных:

VAR

ИмяСсылкиНаОбъект : ^ТипОбъекта;

- 287 -

Дальнейшее обращение к объектам и полям тоже будет обычным:

ИмяСсылкиНаОбъект — ссылка на объект,

ИмяСсылкиНаОбъект^ — объект в целом,

ИмяСсылкиНаОбъект^.ИмяПоля— поле данных объекта, ИмяСсылкиНаОбъект^.ИмяМетода — вызов метода объекта.

Динамические объекты могут создаваться стандартной процедурой New:

New( ИмяСсылкиНаОбъект );

Как и обычно, процедура New выделяет в динамической памяти область для хранения данных базового типа ссылки. Турбо Паскаль вводит некоторые расширения для динамического распределения и освобождения объектов. Если динамический объект содержит виртуальные методы, то он должен быть инициализирован с помощью вызова конструктора до вызова всех остальных его методов:

ИмяСсылкиНаОбъект^. ИмяКонструктора( параметры );

В Турбо Паскале процедура New расширена. Она позволяет в одной операции выделить память под объект и вызвать конструктор:

New( ИмяСсылкиНаОбъект, ИмяКонструктора( параметры ) );

Порядок действия такого вызова следующий. Сначала как бы выполняется операция New( ИмяСсылкиНаОбъект ). Если она завершилась успешно, то вызывается конструктор объекта. Иногда удобно описывать поля данных объекта тоже как динамические. В этом случае выделение памяти кучи для них должно происходить в конструкторе. И, конечно, в конструкторе должна происходить необходимая инициализация полей данных (в том числе и вызовы конструкторов для унаследованных полей). Связь экземпляра с таблицей VMT устанавливается самим фактом вызова конструктора. Разместить объект в куче можно также функцией New, возвращающей ссылку на объект. В этом случае параметр, передаваемый New — это тип ссылки на объект, а не сама переменная-ссылка:

TYPE

ТипСсылкиНаОбъект = ^ТипОбъекта;

VAR

ИмяСсылкиНаОбъект : ТипСсылкиНаОбъект;

BEGIN

ИмяСсылкиНаОбъект := New( ТипСсылкиНаОбъект );

...

END.

Точно так же, как и в процедурной форме, в функциональном

- 288 -

варианте New можно использовать второй параметр — имя конструктора типа объекта.

 

13.6.2. Освобождение объектов. Деструкторы

Для освобождения кучи от динамических объектов применяется стандартная процедура

Dispose( ИмяСсылкиНаОбъект ).

Подобный вызов уничтожит объект в целом. Но если поля данных объекта были динамическими и под них выделялась дополнительная память при выполнении конструктора или иной процедуры инициализации, то их надо освободить до уничтожения самого объекта. Для этих целей (или других завершающих действий) вводится специальный вид метода — деструктор. Он объявляется среди прочих методов служебным словом DESTRUCTOR вместо PROCEDURE (пример реализации деструктора приведен в разд. 13.6.3). По сути, деструктор — это метод, противоположный конструктору. Обычно, если конструктор рекомендуется называть Init, то деструктору дается имя Done («завершено»). Для одного типа объекта могут быть определены несколько деструкторов. Деструкторы могут наследоваться. Они могут быть статическими или виртуальными, но лучше использовать виртуальные, так как это гарантирует, что будет выполнен именно тот деструктор, который соответствует данному типу объекта. Объект может иметь деструктор даже в том случае, когда все его методы — статические. Смысл и необходимость введения деструктора заключаются в том, что его можно использовать в расширенной процедуре Dispose так же, как используется конструктор в New.

Расширенный синтаксис процедуры Dispose позволяет в качестве второго параметра передавать имя деструктора данного типа объекта:

Dispose( ИмяСсылкиНаОбъект, ИмяДеструктора );

Действует этот вызов следующим образом. Сначала выполняется вызов деструктора (описанные в нем завершающие действия) как обычного метода. Далее, если объект содержит виртуальные методы, то деструктор осуществляет поиск размера объекта в таблице виртуальных методов и передает размер процедуре Dispose, которая освобождает правильное количество байтов памяти. Поэтому для динамических объектов всегда имеет смысл объявлять виртуальный деструктор, хотя бы и пустой:

DESTRUCTOR ИмяТипаОбъекта.Done; VIRTUAL;

BEGIN END;

который нужен для нормальной работы процедуры Dispose.

- 289 -

 

13.6.3. Обработка ошибок при работе с динамическими объектами

Если при попытке разместить динамический экземпляр типа «объект» свободной памяти окажется недостаточно, то вызов расширенной процедуры New сгенерирует код ошибки выполнения 203. Но если переписать системную функцию HeapFunc (см. разд. 11.5.6) таким образом, чтобы она возвращала значение 1 вместо 0, то в размещаемую ссылочную переменную в случае ошибки вернется значение nil и программа не прервется. Если при запросе памяти для объекта процедурой

New( ИмяСсылкиНаОбъект, ИмяКонструктора )

функция HeapFunc выдаст значение 1, то конструктор не будет выполняться, а в ИмяСсылкиНаОбъект запишется nil.

Когда начинает выполняться тело конструктора, экземпляр объекта уже будет гарантированно и успешно распределен. Однако сам конструктор может выполнять действия по распределению динамических полей данных экземпляра, и при распределении таких полей может произойти сбой, если не хватит памяти. Будет разумно, если в подобной ситуации конструктор отменит все уже проделанные распределения и в завершение освободит экземпляр типа объекта так, чтобы в результате ссылка получила бы значение nil. Для этого введена стандартная процедура Fail, не имеющая параметров. Она может быть вызвана только из конструктора. Вызов этой процедуры освобождает динамический экземпляр, который был размещен в памяти до входа в конструктор, и возвращает в ссылке значение nil. Получение nil обозначает неудачу распределения памяти.

Нехватка памяти возможна и в случае статических объектов с динамическими полями. Так, при размещении конструктором динамических полей в куче может возникнуть нехватка памяти. Но, поскольку объект статический, нельзя передать сигнальное значение nil в ссылку — ее попросту нет. Вместо этого предлагается использовать имя конструктора как логическую функцию. Если внутри конструктора была вызвана процедура Fail, то в имени конструктора вернется значение False. В остальных случаях будет возвращаться значение True. Подобным способом анализа можно пользоваться и для проверки работы унаследованных конструкторов.

На рис. 13.8 приводится пример объектов (динамических и с динамическими полями) и их инициализация с обработкой возможных ошибок.

| TYPE

| VectorType = Array [ 1..1000 ] of Real; { вектор }

| MatrixType = Array [1..20,1..20 ] of Real; { матрица }

| VectorTypePtr = ^VectorType; { ссылка на вектор }

| MatrixTypePtr = ^MatrixType; { ссылка на матрицу }

| Vector = OBJECT {статический объект с динамическим полем }

| V : VectorTypePtr;

| CONSTRUCTOR Init( FillVect : Real );

| DESTRUCTOR Done; VIRTUAL;

| PROCEDURE Work; VIRTUAL;

| END;

| ComplexPtr = ^Complex; { Динамический объект с }

| Complex = OBJECT (Vector) { динамическими полями данных }

| M : MatrixTypePtr,

| CONSTRUCTOR Init(FillVect, FillMat : Real);

| DESTRUCTOR Done;

| VIRTUAL;

| PROCEDURE Work; VIRTUAL;

| END;

| { Реализация методов объектов }

| CONSTRUCTOR Vector.Init( FillVect : Real );

| VAR i : Word; { параметр цикла заполнения }

| BEGIN

| New( V ); { попытка разместить V в куче }

| if V=nil then begin

{ при неудаче сделать откат }

| Vector.Done; { завершение работы объекта }

| Fail { объявить сбой конструктора }

| end ; { if }

| for i:=1 to 1000 do

|{ поле V создано и заполняется }

| V^[i] := FillVect;

| END;

| DESTRUCTOR Vector.Done;

| BEGIN

| if V<>nil then Dispose( V )

|{ освобождение поля V }

| END;

| PROCEDURE Vector.Work; { метод обработки поля V }

| BEGIN

| { Какие-либо действия над вектором V^ }

| END;

- 291 -

| CONSTRUCTOR Convex.Init( FillVect, FillMat : Real );

| VAR i,j : Word; { параметры циклов заполнения}

| BEGIN

| if not Vector.Init(FillVect) {инициализация прародителя }

| then Fail; {при неудаче сделать откат }

| New( M ); { попытка разместить M в куче }

| if M=nil then begin

{ при неудаче сделать откат }

| Complex.Done; { завершение работы объекта }

| Fail { объявить сбой конструктора }

| end ; { if }

| for i:=1 to 20 do

| {поле М создано и заполняется }

| for j:=1 to 20 do

| M^[i,j] := FillMat;

| END;

| DESTRUCTOR Complex.Done;

| BEGIN

| if M<>nil then Dispose( M );

|{ освобождение поля M }

| Vector.Done { освобождение поля V }

| END;

| PROCEDURE Complex.Work; { метод обработки поля М }

| BEGIN

| { Какие-либо действия над матрицей M^ }

| END;

| {$F+} { новая функция анализа распределения памяти}

| FUNCTION HeapFunc(Size: Word) : Integer;

| BEGIN

| HeapFunc := 1

| END;

| {$F-}

| VAR

| Vec : Vector; { экземпляр статического объекта}

| ComPtr : ComplexPtr; { ссылка на динамический объект }

| BEGIN

| HeapError := @HeapFunc; { подстановка функции анализа }

| if not Vec.Init( 1.0 ) { инициализация поля Vec.V }

| then Halt( 1 ); { реакция на неудачу операции }

| New(ComPtr, Init(2,3)); { размещение объекта ComPtr^ }

| if ComPtr=nil { реакция на неудачу операции }

| then Halt( 2 );

| (* Применение методов Vec.Work и ComPtr^.Work *)

| Vec.Done; { освобождение поля Vec.V }

| Dispose(ComPtr, Done); { освобождение объекта ComPtr^ }

| END.

Рис. 13.8

- 292 -

Обращаем внимание на вызовы деструкторов в Vector.Init и Complex.Init перед вызовом процедуры Fail. Они нужны для отмены всех успешных размещений полей. Также важно то, что в Complex.Init вызов Vector.Init записан в выражении таким образом, что можно проверить успешность выполнения конструктора прародителя.

 

13.7. Функции TypeOf и SizeOf

Турбо Паскаль версии 5.5 вводит стандартную функцию

TypeOf( ИмяЭкзОбъекта_или_ИмяТипа ) : Pointer

которая возвращает указатель на таблицу виртуальных методов для конкретного экземпляра или самого типа объекта. Функция TypeOf имеет один параметр, который может быть либо идентификатором типа объекта, либо идентификатором экземпляра этого типа. Функция TypeOf применима только к объектам, имеющим таблицу VMT. Применение ее к другим типам объектов вызовет ошибку.

Функция TypeOf может быть использована для проверки фактического типа экземпляра, например:

if TypeOf( Self ) = TypeOf( ObjVar ) then ... ;

Стандартная функция Турбо Паскаля SizeOf при применении к экземпляру типа «объект», который имеет связь с таблицей VMT, возвращает размер, хранящийся в таблице VMT. Таким образом, для типов объектов, которые имеют таблицу виртуальных методов, функция SizeOf всегда возвращает фактический размер экземпляра, который может отличаться от декларированного в описании типа.

Следует сказать, что из-за сложного внутреннего представления объектов становятся опасными операции приведения типов объектов или совмещения экземпляров директивой absolute.

Программа может сама проверять корректность объектов, анализируя их размеры. Для этого программа должна компилироваться в режиме {$R+}, который распространен на виртуальные методы. При этом генерируется вызов подпрограммы проверки правильности VMT перед каждым вызовом виртуального метода. Если контрольные значения размеров в VMT указывают на сбой, происходит фатальная ошибка 210.

Включение механизма проверки вызовов виртуальных методов замедляет работу программы и несколько увеличивает ее размер. Поэтому имеет смысл включать режим {$R+} только во время отладки программы, а для рабочей версии устанавливать режим {$R-}.

- 293 -

 

13.8. Задание стартовых значений объектам

Можно объявлять статические объекты со стартовыми значениями полей. Для этого используется тот же синтаксис, что и для задания констант типа «запись». Для методов стартовых величин просто не существует, и они не задаются:

CONST

CObjPos : ObjPos = (Line: 1; Col: 1);

CObjString : ObgString = (Line: 1; Col:2; SubSt: 'ПЭВМ');

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

Используя подобные введенным выше типизированные константы, можно инициализировать поля других объектов. Для этого достаточно ввести дополнительный метод, например Copy:

| TYPE

|  Obj = OBJECT

|               Поля данных;

|               CONSTRUCTOR Copy(X : Obj);

|               Другие конструкторы и(или) методы;

|            END ;

| CONSTRUCTOR Obj.Copy(X : Obj);

| BEGIN

|    Self := X

| END;

| CONST

|    CObj : Obj = (значения полей данных);

После этого можно вызывать этот конструктор, передавая ему в качестве параметра константу CObj типа Obj.

 

13.9. Модули, экспортирующие объекты

Сама реализация типа «объект» наводит на мысль об использовании модулей для определения объектов. Типы объектов можно описывать в интерфейсном разделе модуля, а тела процедур и функций, реализующих методы объектов, определяются в разделе реализации модуля. Если необходимо экспортировать переменные типа «объект», причем содержащие виртуальные методы, то для таких переменных в разделе инициализации можно разместить вызовы конструкторов. Модули могут иметь свои собственные опре-

- 294 -

деления типов объектов в разделе реализации: такие типы подчиняются тем же ограничениям, что и любые другие типы, определенные в разделе реализаций модуля. Тип объекта, определенный в интерфейсном разделе модуля, может иметь производные типы в разделе реализации модуля. В случае, когда модуль B использует модуль A, модуль В может определять производные типы от любого типа объекта, экспортируемого модулем A.

Из виртуализации объектов следует важное свойство объектно-ориентированных программ — это расширяемость или открытость. С чем оно связано? Модули, содержащие программные инструментальные средства (например, программы работы с меню, с окнами, с графикой и т.д.), могут поставляться конечным пользователям в виде подключаемых TPU-файлов с распечаткой типов объектов и методов, определенных в интерфейсном разделе модуля. Пользователи такого модуля могут, используя полиморфизм и наследование, добавлять к модулю новые свойства. Таким образом, программа наследует все, что было в исходном модуле, и создает на основе этого новые объекты.

- 295 -

 

14.1. Работа с командной строкой. Функции ParamCount и ParamStr

Функции ParamCount и ParamStr необходимы для работы самостоятельных программ (ЕХЕ-файлов) с параметрами командной строки. Под последними понимается набор параметров, разделенных пробелами (реже знаками табуляции), который стоит после имени запускаемого файла в строке MS-DOS, например:

C:\> format a: /S

Сам по себе параметр может содержать все что угодно, кроме пробелов и табуляций. Правда, можно видеть, что некоторые утилиты требуют разделять параметры знаками типа «/» или «-». Они не являются разделителями по правилам MS-DOS, и программа сама должна разбираться, сколько параметров заложено в конструкциях типа /a/c/e/z/x или -a-g-c.

Если после имени файла в командной строке MS-DOS пусто, то ParamCount возвращает значение 0, в противном случае — число параметров в строке, разделенных пробелами или табуляцией. Это можно использовать для остановки программ, которым при запуске не были переданы параметры-аргументы (рис. 14.1).

- 296 -

| PROGRAM Uses_Parameters; { программа MyProg.pas }

| ...

| BEGIN { начало основного блока }

| if ParamCount=0 then

| begin { параметры отсутствуют }

| WriteLn;

| Write ( 'Запуск программы: '#10 );

| WriteLn( 'MyProg Параметр1 [ Параметр2 ]' );

| WriteLn; Halt

| end ;

| { . . . выполнение программы . . . }

| END.

Рис. 14.1

После того как определено количество параметров, можно выбрать любой из них, используя функцию ParamStr( N ), возвращающую в виде строки параметр номер N. Пусть запуск программы имеет вид

В этом примере ParamCount вернула бы значение 4, a ParamStr имела бы такие значения типа String:

| N -- ParamStr(N)

| 0 -- 'C:\TURBO\PAS\MYPROG.EXE'

| 1 -- 'abc'

| 2 -- 'z'

| 3 -- '/c/d'

| 4 -- '123'

| 5 и более -- ' '

Отметим два момента: во-первых, имеет смысл (всегда!) вызов ParamStr (0), возвращающий полное имя запущенной программы; во-вторых, цифры в строке параметров будут трактоваться как строка, а не как число, и их надо будет преобразовывать процедурой Val.

- 297 -

При запуске из среды программирования ParamStr(0) вернет полное имя файла TURBO.EXE (с указанием пути к нему).

Чтобы обеспечить удобство пользования и «дружелюбность» программы, надо делать так, чтобы при отсутствии параметров при запуске программа начинала спрашивать их с экрана. Это легко сделать с помощью рассмотренных функций. Пусть, например, программа запрашивает имя файла данных, и если пользователь не вводит его, принимает некое значение имени по умолчанию. Тогда алгоритм может выглядеть так, как показано на рис 14.2.

| { Пример программы, принимающей имя файла }

| VAR

| s : String;

| BEGIN { начало основного блока }

| if ParamCount>0 { есть ли параметры? }

| then s:=ParamStr(1) {да }

| else begin {нет }

| Write( 'Введите имя файла [DEFAULT.DAT] ' );

| ReadLn( s );

| if s=' ' then s:='DEFAULT.DAT'

| end ;

| { ... ВЫПОЛНЕНИЕ ПРОГРАММЫ — обработка файла s ... }

| END.

Рис. 14.2

При отладке программ в среде Турбо Паскаль, где нет командной строки MS-DOS, можно передать программе параметры через команду Parameters в меню системных команд Options.

 

14.2. Доступ к памяти ПЭВМ. Массивы Mem, MemW, MemL

Для простого доступа к любой физической ячейке памяти Турбо Паскаль вводит три предопределенных массива: Mem, MemW, MemL. Они как бы наложены на всю память ПЭВМ. Можно условно считать, что эти массивы известны по системному определению:

VAR

Mem : Array of Byte absolute 0:0;

MemW : Array of Word absolute 0:0;

MemL : Array of Longlnt absolute 0:0;

- 298 -

Но отличие их от обычных массивов — в задании индексов. Они должны задаваться не номером, а адресом интересующей нас ячейки памяти в формате СЕГМЕНТ:СМЕЩЕНИЕ. Так,

Mem [$B000:$0000] — значение байта (Byte) по данному адресу;

MemW[$B000:$0000] — значение слова (Word) по данному адресу;

MemL[$B000:$0000] — значение двойного слова (LongInt).

Во всем остальном массивы Mem очень похожи на обычные массивы. Если Mem [] стоит справа в операторе присваивания, то это — значение байта (слова, двойного слова), начинающегося с данного индекса-адреса. Но Mem[] может стоять и слева. Это будет означать модификацию байта (слова или двойного слова) по данному адресу, например:

Mem[ $50 : 0 ] := Mem [ $50: 0 ] xor 1;

{ вкл/выкл реакции на Shift+PrtScr }

Элементы массивов Mem могут подставляться как фактические параметры при вызовах процедур и функций. Наиболее часто массивы Mem, MemW и MemL используются для доступа к системным областям памяти, как в примере на рис. 14.3.

| PROGRAM Devices; { Анализ байта конфигурации }

| VAR

| CFG : Word; { сюда запишется значение ячейки памяти }

| BEGIN

| CFG := MemW[ $0000:$0410 ];

| WriteLn( #10, 'Текущая конфигурация:', #10 );

| WriteLn('Макс. число принтеров -->', CFG shr 14 );

| WriteLn('Число серийных портов -->', (CFG shr 9) and 7);

| WriteLn('Число НГМД --> ',

| ( CFG and 1 )*( 1 + ( CFG shr 6 ) and 3 ) );

| WriteLn('Наличие игрового порта-—>',(CFG and 4096)=1);

| WriteLn;

| ReadLn

| END.

Рис. 14.3

 

14.3. Доступ к портам ввода-вывода. Массивы Port и PortW

Массивы Port и PortW аналогичны массивам Mem, с той лишь разницей, что проиндексированы они не адресами, а номерами портов ввода-вывода. С помощью предопределенного массива Port можно обмениваться данными с 8-битовыми портами, а с помощью PortW — с 16-битовыми. Под поротом понимается нумерованный канал ввода-вывода, подсоединенный к процессору. Все взаимодействие с периферией ПЭВМ осуществляется через порты (в том числе работа дисплея, серийных портов, динамика, клавиатуры и т.п.). Если  ссылка на Port или PortW стоит справа в присваивании, например:

PostStatusVar := PortW[$61]; {чтение из порта}

то это означает чтение из порта с данным номером. Но если Port или PortW стоит слева, то это имеет смысл записи (посылки) в порт значения:

Num := $64;

Port[ Num ] := ByteVar {запись в порт}

Имена Port и PortW могут стоять только в операторах присваивания. Будет ошибкой обращение к Port или PortW без указания индекса. Не имеет смысла взятие адреса массивов Port или их отдельных элементов. Максимальное значение номера порта равно $3FFF.

 

14.4. Процедура заполнения FillChar

Эта процедура уже использовалась в предыдущих главах. Здесь мы обсудим ее подробно. Вызов процедуры содержит три параметра:

FillChar( VAR V; NBytes : Word; В : Byte )

или

FillChar( VAR V; NBytes : Word; С : Char )

Первый — переменная V любого типа, второй — число байтов переменной V, которые будут заполнены значением B или C. Процедура FillChar служит для заполнения участков памяти (ОЗУ) одним и тем же однобайтовым значением. Например, обнулить числовой массив A любой сложности можно одним вызовом:

FillChar( A, SizeOf( А ), 0 );

Если заполнение происходит числом, то третьим параметром должно быть значение, совместимое с типом Byte. Но если речь идет о заполнении символом, то последнее значение должно быть символьного типа. Самой процедуре FillChar этот момент безразличен, и можно для числового массива A записать

FillChar( A, SizeOf( А ), '0' );

- 300 -

но результатом здесь будет заполнение не нулем, а кодом Ord('0'), что равняется 48.

Следует также помнить, что заполняется заданным значением каждый байт блока с размером, заданным параметром NBytes. И если переменная A сконструирована не из однобайтных значений, а из более длинных (Word, Integer, Real и т.п.), то корректно работает лишь заполнение нулем. Например, заполнение переменной W типа Word вызовом

FillChar( W, SizeOf( Word ), 1 );

приведет к тому, что в W будет записано значение 257. Если надо заполнить не всю структуру, а часть ее, то следует указать идентификатор того элемента структуры, начиная с которого надо проводить заполнение. Так, можно заполнить средние элементы массива A:

VAR

А : Array [ 1..500 ] of LongInt;

BEGIN

FillChar( A[ 100 ], 200 * SizeOf( LongInt ), 0 );

...

END.

В этом примере 200 значений типа LongInt массива A, начиная с 100-го, будут заполнены нулем.

С особой осторожностью надо заполнять строки символами, так как нужно заботиться о нулевом байте строки. Подробно об этом говорилось в гл. 8 «Обработка символов и строк».

Кроме того, надо всегда следить за согласованностью реального размера переменной (первого параметра) и длины заполняемого блока (значением NBytes). Если длина блока превышает размер переменной, то будут заполнены байты ОЗУ, следующие за переменной, но к ней уже не относящиеся! Иными словами, если A — статическая переменная или разыменованная ссылка, то следует придерживаться правила

NBytes <= SizeOf( A ).

Сам Турбо Паскаль проверок на корректность параметров не производит.

То, что процедура FillChar заполняет все по байтам, не всегда удобно. В справочном руководстве по Турбо Паскалю приводится пример функции в машинных кодах, заполняющей области памяти так же, как FillChar, но значениями типа Word — по 2 байта сразу (рис. 14.4).

- 301 -

| PROCEDURE FillWord( VAR V; NWords, Fill : Word );

| BEGIN

| inline(

| $C4/$BE/ V / { LES DI, bp+V}

| $8B/$8E/ NWords/ { MOV CX, bp+NWords }

| $8B/$86/ Fill/ {MOV AX, bp+Fill}

| $FC/ { CLD }

| $F3/$AB ) { REP STOSW }

| END;

| VAR

| P : Pointer;

| BEGIN

| P := Ptr( $B800, 0 ); {Начало памяти экрана для цветных мониторов; для монохромных надо задавать P := Ptr( $8000, 0 ) }

| FillWord( Р^, 80*25, 176 + 14 * 256 );

| ReadLn

| END.

Рис. 14.4

На рис. 14.4 дан пример заполнения области экрана (размером 80x25 видимых символов) символом #176 цветом номер 14. Код и цвет скомбинированы в одно значение типа Word. При таком заполнении помните, что первым в машинном представлении слова (Word) идет младший байт, а следом за ним — старший (значение множителя при 256). Обратите внимание на разыменование указателя P, что означает передачу в FillWord адреса начала видеоизображения, а не самого значения P.

 

14.5. Процедура перемещения данных Move

Процедура Move в некотором роде — уникальная. Она практически не имеет аналогов в стандартах языков высокого уровня. По своей сути она скорее является командой машинного уровня. Процедура содержит три параметра:

Move( VAR Source, Dest; NBytes : Word )

и служит для перемещения в ОЗУ блоков данных размером NBytes. Начало блока задается переменной Source любого типа (первый байт блока соответствует первому байту значения Source). Переменная Dest, точнее задаваемый ею первый байт, указывает на место в

- 302 -

памяти, начиная с которого будет размещен блок. Длина блока должна измеряться в байтах.

Очень эффективно работает процедура Move в различных трюках программистов, таких как копирование области видеопамяти (см. пример к процедуре Keep модуля DOS). Но не менее эффективно ее можно использовать и в более традиционных задачах. Например, копирование массива B в массив A:

А := В;

может быть выполнено процедурой

Move( В, A, SizeOf( В ) );

т.е. блок байтов — значений массива B соответствующего размера — будет скопирован в область памяти, занимаемую массивом A. В этом случае применение Move не дает особого эффекта. Но если, например, нам надо скопировать одну структуру в другую, причем сами структуры — разнотипные, то Move позволяет проделать это максимально просто и с наибольшим быстродействием (рис. 14.5). В этом случае не надо уже беспокоиться об индексах, а надо только указать размер копируемого блока.

Рис. 14.5

Еще одна область приложения, где Move эффективнее прочих способов — это перемещение значений (сдвиг) внутри одного массива. Пусть, к примеру, объявлен массив

VAR

A : Array[ 1..10000 ] of Real;

- 303 -

(тип элементов может быть и любым другим), и надо скопировать тысячу элементов, начиная с первого на сто индексов выше (т.е. как бы сдвинуть значения с первого на сто первый индекс). Обычное, но необдуманное решение проблемы — цикл FOR:

for i:=1 to 1000 do A[ i+100] := A[ i ];

который лишь испортит данные массива A. Это произойдет из-за перекрытия исходного и конечного отрезков значений (рис. 14.6).

Рис. 14.6

Здесь элементы, начиная со 101-го, будут замещены раньше, чем скопированы! Корректный цикл FOR должен быть убывающим:

for i:=1000 downto 1 do A[ i+100 ] := А[ i ];

Чтобы избежать всех этих сложностей, рекомендуем пользоваться процедурой Move. Рассматриваемая задача решается так:

Move( А[ 1 ], А[ 101 ], 1000 * SizeOf( Real ) );

При этом проблема перекрытия снимается автоматически самой процедурой Move (она выбирает направление копирования исходя из заданных параметров). Параметры A[1] и A[101] в вызове имеют смысл не значений 1-го и 101-го элементов массива A, а адресов этих элементов в памяти.

Если же понадобится вернуть 1000 элементов «назад» в первую позицию массива, вызов будет таким:

Move( А[ 101 ], А[ 1 ], 1000 * SizeOf( Real ) );

и проблема перекрытия вновь будет решена автоматически.

Помните, что никаких проверок на корректность значений параметров в Move не происходит, и если значение длины блока больше, чем может вместить переменная — адрес назначения (второй параметр Move), то будет заполнена часть памяти, отведенная под другие

- 304 -

данные, что весьма неприятно. Советуем использовать функцию SizeOf для вычисления длин блока. Выражения типа 1000*SizeOf (Real) состоят из констант и могут быть вычислены еще во время компиляции программы, так что длинные арифметические последовательности в вызове Move ничуть не замедляют работу программ.

 

14.6. Функции обработки машинных слов Lo, Hi и Swap

Среди прочих специальных средств низкого уровня Турбо Паскаль предоставляет несколько удобных функций для работы над отдельными байтами машинных слов. Некоторые системные переменные и функции Турбо Паскаля возвращают два однобайтовых значения, объединенных в тип Word. Для их «распаковки» как раз подходят описываемые здесь функции. Их три (табл. 14.1).

Таблица 14.1

Аргумент X имеет тип Word или Integer ( 2-байтовый целый), и возвращаемое значение имеет тот же тип, что и X.

Любое число типа Word раскладывается на два слагаемых из значений своих байтов по правилу (для типа Integer эта формула не подходит)

X := Hi(X) * 256 + Lo(X);

Функция Swap возвращает число типа Word или Integer в зависимости от типа аргумента X, в котором старший и младший байты поменялись местами. Следует быть осторожным при использовании функции с аргументом типа LongInt. В версии 5.5 Турбо Паскаля компилятор «ничего не имеет против» таких вызовов, но возвращаемое значение при счете усекается до типа Word, меняя его иной раз до неузнаваемости.

 

14.7. Вставки машинного кода в программе

 

14.7.1. Оператор inline

Несмотря на то, что средствами Турбо Паскаля можно сделать практически все, не всегда полученный результат будет максимально

- 305 -

эффективным по быстродействию, если сравнивать с грамотно написанной программой на ассемблере. Другой вопрос, за сколько дней и ночей будет написан и отлажен ассемблерный текст, а за сколько — программы на Турбо Паскале. Все это верно и для других языков. В последних версиях языка Си можно просто писать вставки на ассемблере посреди текста Си-программ. Довольно похожим способом решена проблема включения машинных команд в текст программ на Турбо Паскале. Правда, в текущих версиях языка для того надо употреблять не мнемонические команды языка ассемблера, а их аналоги в машинном коде. Оператор вставки машинного кода записывается с помощью зарезервированного слова inline и списка кодов, разделенных косой чертой:

inline ( Код1/ Код2/ Код3/ .../ КодN );

Встретив такой оператор, компилятор прекращает на время генерировать код и вставляет Код1, Код2 и другие из оператора inline без каких-либо особых преобразований, а затем снова начинает преобразовывать предложения Турбо Паскаля в выполнимый код. Это более гибкий способ, чем компоновка объектного файла директивой {$L ИмяФайла}, поскольку позволяет вставлять в программу «чисто ассемблерные» отдельные операторы, в то время как {$L...} позволяет лишь использовать внешние процедуры и функции. Программирование в чистых машинных кодах, как это требует формат inline, — занятие не для начинающих. Не имея большого опыта работы с ассемблерами для процессоров семейства 8086/286, лучше избегать применения оператора inline, тем более, что необходимость в нем возникает не так уж часто. В книге Дж.Дунтемана [5], посвященной подобным вопросам, приводится такой список задач, требующих прямого использования машинных кодов:

1. Процедуры обработки прерываний.

2. Резидентные программы.

3. Организация многозадачных режимов.

Дж. Дунтеман характеризует эти задачи как задачи «не для малодушных», особенно третью. Код в операторе inline — это либо константа, либо имя переменной. Константа должна быть целым положительным числом типа Byte или Word и может быть записана как в десятичном, так и в шестнадцатеричном формате. Пример: оператор

inline( $CD / 05 ); { Мнемоника -> INT 05H }

это то же самое, что вызов прерывания 05 (печать с экрана). Если значение константы попадает в диапазон 0...255, то она хранится

- 306 -

как однобайтовый код. Если же оно превосходит 255, то хранится как слово (два байта). В последнем случае код хранится по машинному правилу: младший байт (Lo( Word )) предшествует старшему (Hi( Word )). Можно явно заказывать формат хранения кода, используя перед константой знаки «<» и «>». Если константа записана с предшествующим знаком «<», то от нее будет взят только младший байт. Но если ей предшествует знак «>», то она будет записана в двух байтах, например:

inline( >1 ) даст два байта кода: $01 и $00.

Размер хранения кодов важен для организации переходов внутри оператора inline.

Если вместо константы стоит имя переменной, то оно трактуется как слово (два байта) — смещение в сегменте хранения этой переменной. Таким образом, переменная в inline задает адрес в сегменте DS (DSeg) или SS (SSeg) первого байта своего значения. Если же нужен не первый байт значения, а, например, третий, то можно указать это, дописав к переменной константу — смещение от ее первого байта, например:

inline(.../ XVar+2 /...);

Адрес первого байта XVar может быть записан как XVar+0. Смещение от начала переменной может быть и отрицательным, достаточно заменить знак «+» на «-».

Внутри кодов inline могут быть доступны значения глобальных переменных и типизированных констант (они хранятся в сегменте DS), а также, если inline стоит внутри тела процедуры или функции, становятся доступными локальные переменные этих процедур и их переменные параметры. Подробное изложение техники обращения к ним, соглашений о размещении и размерах локальных переменных, способах передачи значений в процедуры, функции и обратно заняло бы слишком много места (не считая таблицы машинных кодов для 8088/86/286). Подробно вопросы интерфейса с ассемблерными программами и работа с inline рассматривается в гл. 15 справочного руководства по Турбо Паскалю 5.0 [2] и в уже упоминавшейся книге [5] (с оговорками, ибо она написана для версии 3.0). Здесь же мы дадим один последний совет начинающим любителям машинных кодов: во избежание фатальных последствий запрещено модифицировать кодами оператора inline регистры процессора ВР, SP, SS и DS. Остальные — можно.

- 307 -

 

14.7.2. Процедуры с директивой inline

Вставки машинных кодов в программу могут производиться и другим способом: посредством описания процедур или функций директивой inline, содержащей машинные коды, как и оператор inline, рассмотренный в предыдущем разделе. Такие процедуры, собственно, уже не столько процедуры, сколько ассемблерные макросы. Механизм их работы существенно изменяется.

Когда вызывается обычная процедура или функция, не имеющая директивы inline, происходят предварительные действия по размещению локальных переменных в стеке, затем выполняется тело процедуры, после чего освобождается стек и управление передается вызывающей части программы. Но при вызове inline-процедуры или функции просто будут выполнены коды, указанные в директиве inline, без каких-либо предварительных или последующих манипуляций. Пример объявления такой процедуры:

PROCEDURE PrintScreen; inline( $CD / 05 );

Вызов такой процедуры PrintScreen эквивалентен выполнению ассемблерной команды INT 05.

Inline-процедуры и функции не могут иметь тела. Все их содержимое описывается кодами в директиве inline. Но они могут иметь параметры, которые, впрочем, нельзя указывать по имени совместно с кодами (это не относится к глобальным идентификаторам).

Директивы inline предназначены только для очень коротких (менее 10 байтов) процедур и функций в машинных кодах. Из-за того, что процедуры и функции с директивой inline являются макроопределениями, к ним неприменимы операции взятия адреса (оператор @, функции Addr, Ofs и Seg).

 

14.8. Процедура завершения и обработка ошибок программ

Если действия написанной программы вступают в противоречие с вычислительными возможностями ПЭВМ или требуют невозможного от ее ресурсов, то они, как правило, прерываются с выдачей сообщения типа «Runtime Error NNN». В таком случае мы говорим о фатальной ошибке времени счета (или во время счета). Такие ошибки могут возникать при запросах на размещение динамических переменных при малом объеме свободной памяти, попытках записи на переполненный диск, чтении с пустых дисководов, делениях на нуль или при нарушениях области допустимых значений аргументов функций Sqrt, Ln и т.д. Список этот можно продолжить. Общим для всех этих причин является то, что неизвестно, где и как они могут

- 308 -

возникнуть. Как правило, ошибки, не связанные с вводом-выводом, возникают из-за недосмотров в логическом построении программ. Причем хорошо, если все закончится выдачей текста «Runtime Error...», ведь программа может «зависнуть» так, что разблокировать ПЭВМ можно будет только полным перезапуском...

Все ошибки времени счета можно разделить на условно и безусловно фатальные. Условно фатальные ошибки — это те, которые могут блокироваться соответствующими режимами компиляции. Например, ошибка при проверке диапазонов с кодом 201 (Range Check Error) может появиться лишь, если программа откомпилирована в режиме {$R+}, ошибка 202 — переполнение стека (Stack Overflow) — в режиме {$S+}. К условно фатальным можно отнести все ошибки, связанные с вводом-выводом (коды ошибок 2-199), подробно рассмотренные в гл. 12. Отключение соответствующих режимов контроля ошибок вовсе не повышает безошибочность программ. Оно всего лишь загоняет «болезнь» программы внутрь и дает лишний повод усомниться в корректности выдаваемых программой ответов. Безусловно фатальные ошибки — это такие, которые нельзя ничем заблокировать. Сюда относятся все ошибки вычислений с плавающей точкой и некоторые другие.

Мы уже обсуждали способы обработки ошибок ввода-вывода и ошибок при распределении памяти (см. разд. 12.11, 11.5.6). Ниже будет рассмотрен способ обработки фатальных ошибок.

Турбо Паскаль дает возможность перехватить стандартную цепочку завершения программы и подставить свою собственную процедуру, которая будет выполнять любые действия вместо выдачи малоинформативного «Runtime Error...». Восстановить нормальную работу программы при возникновении фатальной ошибки уже нельзя, и после выполнения предписанных действий программа все равно прервется, но перед этим она сможет «нормальным» языком объяснить причину останова, восстановить видеорежимы, цвета, размеры курсора и т.п.

Механизм подстановки процедуры несложен. Вот его алгоритм:

1. Пишется процедура завершения программы. Это вполне обычная процедура. Требования к ней таковы: она не должна иметь параметров и должна быть откомпилирована в режиме {$F+}. Кроме того, в ней необходимо предпринять ряд действий по обработке ошибок и восстановлению системных адресов.

2. Объявляется переменная, например, с именем OldExitProc, имеющая тип Pointer.

- 309 -

3. В самом начале программы запоминается значение предопределенной системной переменной ExitProc — адрес стандартной процедуры завершения. Оно записывается в объявленную ранее переменную (у нас — в OldExitProc). А в ExitProc записывается значение адреса новой процедуры выхода.

4. Тело новой процедуры завершения должно начинаться с восстановления старого значения ExitProc. Далее, необходимо как бы обнулить системный указатель на фатальную ошибку (даже если ее не будет в действительности, это не повредит), записав в системную переменную ErrorAddr значение nil. Если этого не сделать, то после выполнения анализа ошибки и других действий на экран может вылезти уже не нужное «Runtime Error...».

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

Хотя по определению процедура выхода не содержит параметров, ей доступно значение кода ошибки и кодов завершения, посылаемых оператором Halt(N). Они хранятся в системной переменной ExitCode типа Integer. Совместно со значением адреса ErrorAddr переменная ExitCode определяет причину остановки программы (N — значение ExitCode):

Если программа была прервана пользователем с помощью комбинации клавиш Ctrl+Break, то в ExitCode запишется значение 255. Рассмотрим пример подстановки процедуры завершения (рис. 14.7).

Программа на рис. 14.7 всегда будет чистить за собой экран и заканчивать свою работу выдачей одного из предписанных сообщений. Если выполнимый код программы создан в режимах $R- и $I-, то варианты 2..199 и 201 могут никогда не сработать. Можно было использовать условную компиляцию для изъятия их из текста при необходимости.

В принципе возможно создать целую цепочку процедур завершения. Для этого надо лишь в каждой процедуре присваивать

- 310 -

| USES CRT; { используется модуль CRT }

| VAR

| OldExitProc : Pointer; { здесь запомнится ExitProc }

| {$F+} { режим компиляции $F+ }

| PROCEDURE NewExit; { новая процедура выхода }

| BEGIN

| ExitProc := OldExitProc; { восстановление пути выхода }

| TextAttr := White; { задание белого цвета (CRT) }

| ClrScr; { очистка всего экрана (CRT) }

| if ErrorAddr <> nil { Выход из-за ошибки? }

| then { Да. Обрабатывается ее код. }

| case ExitCode of

| 2..199:WriteLn('Ошибка ввода-вывода.' );

| 200 :WriteLn('ДЕЛЕНИЕ НА 0.Проверьте входные данные');

| 201 :WriteLn('Переполнение диапазона.' );

| 203 : begin

| WriteLn('HE ХВАТАЕТ СВОбОДНОЙ ПАМЯТИ.' );

| WriteLn('Освободите память и повторите запуск');

| end ;

| 205 :WriteLn('Переполнение в вещественном числе.');

| 206 :WriteLn('Потеря порядка в вещественном числе.' );

| else WriteLn ('Ошибка ', ExitCode, '. ',

| 'Смотрите описание TURBO PASCAL 5.5')

| end {case и then }

| else (Нет. Нормальное завершение }

| case ExitCode of

| 255 :WriteLn('Программа прервана.');

| else WriteLn('Код завершения программы : ', ExitCode )

| end ; {case и else }

| ErrorAddr := nil; { обнуление адреса ошибки }

| END ; {$F-} { можно вернуть режим $F- }

| { == ОСНОВНОЙ БЛОК ПРОГРАММЫ == }

| BEGIN

| OldExitProc:= ExitProc; {запоминается адрес ExitProc }

| ExitProc:= @NewExit; {назначается новая процедура }

| {...любые остальные действия программы... }

| END.

Рис. 14.7

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

- 311 -

Иногда удобно оформлять процедуры завершения как модули. Программу на рис. 14.7 очень легко переделать в модуль. Надо лишь вписать слова unit Имя, interface и implementation. Тогда при его подключении к основной программе инициализирующая часть настроит процедуру завершения еще до начала выполнения основной программы. Подключать такой модуль надо будет одним из первых в списке раздела USES.

 

14.8.1. Оператор RunError

В Турбо Паскале введен особый оператор

RunError(N : Word)

Его предназначение — останавливать работу программ так, как будто произошла фатальная ошибка с номером N. Всюду, где можно поставить оператор Halt, можно поставить и оператор RunError. Отличие будет лишь в том, что в последнем случае программа завершится выдачей сообщения об ошибке. Оператор RunError очень удобен при отладке программ, особенно содержащих процедуры завершения и обработки ошибок. С его помощью можно испытать программу на рис. 14.7, не провоцирую реальных критических ситуаций. Вызов RunError без указания номера ошибки эквивалентен вызову RunError(0).

 

14.8.2. Сводка номеров фатальных ошибок

Фатальные ошибки (табл. 14.2) всегда приводят к немедленной установке программы.

Таблица 14.2

	ОПИСАНИЕ ОШИБОК
200	Division by zero (деление на ноль) ИСТОЧНИК: /, mod, div
201	Range check error (ошибка в границах/диапазонах) ИСТОЧНИК: ошибка генерируется операторами, скомпилированными в состоянии {$R+} , при возникновении одной из следующих ситуаций: -индекс элемента массива вышел из описанного диапазона; -была осуществлена попытка присвоить переменной значение, находящееся вне диапазона значений типа переменной; -была попытка передать значение, находящееся вне допустимого диапазона, в качестве параметра процедуре или функции

- 312 -

202	Stack overflow error (переполнение стека) ИСТОЧНИК: вызов процедуры или функции, откомпилированной в режиме $S+, в случае, если нет достаточной области для размещения их локальных переменных. Надо увеличить размер стека, используя директиву компилятора $М
203	Heap overflow error (переполнение кучи) ИСТОЧНИК: процедуры New или GetMem в случае, если нет достаточно свободного места в динамической области памяти, чтобы выделить память для блока требуемого размера
204	Invalid pointer operation (неверная операция со ссылкой) ИСТОЧНИК: процедуры Dispose или FreeMem в случае, если их аргумент имеет значение nil или указывает на адрес, лежащий за пределами динамически распределяемой области, или если список свободных блоков переполнен
205	Floating point overflow (переполнение при операции с плавающей точкой) ИСТОЧНИК: операция с плавающей точкой
206	Floating point underflow (исчезновение порядка при операции с плавающей точкой) ИСТОЧНИК: операция с плавающей точкой. Эта ошибка генерируется только в случае, если используется математический сопроцессор 8087 с управляющим словом, которое демаскирует ошибки, возникающие при исчезновении порядка. По умолчанию исчезновение порядка приводит к возвращению результата, равного нулю
207	Invalid floating point operation (недопустимая операция с плавающей запятой) ИСТОЧНИК: функции Trunc или Round, если их аргумент не может быть преобразован в целое число, находящееся в диапазоне значений типа LongInt (от -2147483648 до 2147483647). ИСТОЧНИК: функции Sqrt, если ее аргумент — отрицательный, и Ln, если аргумент — неположительный. ИСТОЧНИК: переполнение стека 8087. Надо упростить математическое выражение в программе или разбить его на части

- 313 -

208	Overlay manager not installed (не установлена подсистема управления оверлеями) ИСТОЧНИК: вероятнее всего — отсутствие обращения к процедуре OvrInit или неудачное обращение к этой процедуре. Нужно помнить, что если в каком-либо из оверлейных модулей содержится код инициализации, то нужно создать дополнительный неоверлейный модуль, вызывающий процедуру OvrInit, и использовать этот модуль перед любым из оверлейных модулей
209	Overlay file read error (ошибка чтения оверлейного файла) ИСТОЧНИК: когда подсистема управления оверлеями пыталась считать оверлей из оверлейного файла, произошла ошибка чтения
210	Object not initialized (объект не был инициализирован) ИСТОЧНИК: попытка вызова виртуального метода объекта, который не был ранее инициализирован вызовом конструктора. Эта ошибка генерируется, если программа создана в режиме компиляции $R+

- 314 -

 

15.1. Вывод специальных символов

При подключенном модуле CRT можно выводить на дисплей строки и символы, содержащие в себе управляющие коды (коды 0...31). При этом они не будут оказывать управляющие воздействия, а будут изображаться на дисплее, согласно таблице изображений символов по их ASCII-коду. Исключение составляют лишь четыре кода (табл. 15.1):

Таблица 15.1

- 317 -

Ниже приводится ряд программ (рис. 15.2 и 15.3), показывающих работу с управляющими символами.

| Программа вывода изображений управляющих кодов }

| USES CRT; { Используется модуль CRT }

| CONST

| SpecialChars : Set of Char = [ #7, #8, #10, #13 ];

| { символы из таблицы }

| Ch : Char = #0; { переменная-символ }

| VAR i : Byte; { параметр цикла }

| BEGIN

| ClrScr; { очистка экрана }

| while Ch < #32 do { цикл по #0...#31 }

| begin

| for i:=1 to 2 do begin

| Write ( ' Код', Ord( Ch ):3, ' -—> ');

| if ( Ch in SpecialChars )

| then Write ( ' Имеет действие' )

| else Write ( Ch:15 );

| Ch := Succ( Ch ); { следующий символ }

| end ; { for }

| WriteLn { закрытие строки }

| end ; { конец цикла while }

| Write ( 'Нажмите ввод для окончания ...' );

| ReadLn { пауза до нажатия клавиши ввода }

| END.

Рис. 15.2

| {Программа использования 4-х управляющих кодов экрана }

| USES CRT; { используется модуль CRT }

| VAR i : Byte; { переменная для цикла }

| BEGIN

| ClrScr; { очистка всего экрана }

| WriteLn ( 'Нажимайте клавишу ввода для продолжения' );

| ReadLn;

| WriteLn ( ' Эффект от кода 7 - короткий звук'#7 );

| WriteLn; WriteLn; ReadLn;

| WriteLn ( ' Демонстрация кода возврата - #8 (BS)' );

| for i:=1 to 40 do Write('/'); { 40 правых косых скобок }

| for i:=1 to 40 do begin

| Delay ( 100); { задержка в 100 мс }

| Write ( #8, '\', #8 ); { Передвижение на символ }

| { влево, замена на '\' и снова один сдвиг влево }

Рис. 15.3

- 318 -

| end ; { for }

| WriteLn; WriteLn; ReadLn;

| WriteLn ('Демонстрация кода разрыва строки - f10(LF)');

| WriteLn;

| Write('Эта '#10'строка '#10'разорвана '#10'кодами 10');

| Writeln( #10#10 ); ReadLn;

| WriteLn ('Работа с кодом возврата каретки - #13'#10);

| for i:=1 to 40 do Write('/'); { 40 правых косых скобок }

| Write ( #13 ); {перевод курсора в начало }

| for i:=1 to 40 do begin

| Delay ( 100 ); { задержка в 100 мс }

| Write ( '\'); { поочередная печать '\' }

| end ; { конец цикла }

| WriteLn; ReadLn { пауза до нажатия клавиши ввода }

| END

Рис. 15.3 (окончание)