Доступ к файлам

Любой программе доступны два предварительно объявленных файла со стандартными файловыми переменными: INPUT - для чтения данных с клавиатуры и OUTPUT - для вывода на экран. Стандартный Паскаль требует обязательного упоминания этих файлов в заголовке программы, например, так:

PROGRAM NameOfProgram(input,output) ;

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

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

Файловая переменная связывается с именем файла в результате обращения к стандартной процедуре ASSIGN:

ASSIGN (<ф.п.>, <имя файла или л.у.>); .

Здесь <ф.п.> - файловая переменная (правильный идентификатор, объявленный в программе как переменная файлового типа); 

<имя файла или л.у.> - текстовое выражение, содержащее имя файла или

логическое устройство.

Если имя файла задается в виде пустой строки, например, ASSIGN(f, ' '), то в зависимости от направления обмена данными файловая переменная связывается со стандартным файлом INPUT или OUTPUT.

Файлы

Доступ к файлам

Имена файлов

Логические устройства

Инициация файла

Процедуры и функции для работы с файлами

Текстовые файлы

Типизированные файлы

Нетипизированные файлы

Под файлом понимается либо именованная область внешней памяти ПК (жесткого диска, гибкой дискеты, электронного «виртуального» диска), либо логическое устройство - потенциальный источник или приемник информации.

Любой файл имеет три характерные особенности. Во-первых, у него есть имя, что лает возможность программе работать одновременно с несколькими файлами. Во-вторых, он содержит компоненты одного типа. Типом компонентов может быть любой тип Турбо Паскаля, кроме файлов. Иными словами, нельзя создать «файл файлов». В-третьих, длина вновь создаваемого файла никак не оговаривается при его объявлении и ограничивается только емкостью устройств внешней памяти.

Файловый тип или переменную файлового типа можно задать одним из трех способов:

<имя> = FILE OF <тип>; 

<имя> = TEXT; 

<имя> = FILE;

Здесь <имя> - имя файлового типа (правильный идентификатор); 

FILE, OF - зарезервированные слова (файл, из); 

TEXT - имя стандартного типа текстовых файлов; 

<тип> - любой тип Турбо Паскаля, кроме файлов.

Например:

type

product = record

name : String;

code : Word;

cost : comp 

end;

textSO = file of String [80] ;

var

fl : file of char;

f2 : text;

f3 : file;

f4 : text80;

f5 : file of product;

В зависимости от способа объявления можно выделить три вида файлов:

типизированные файлы (задаются предложением FILE OF...);

текстовые файлы (определяются типом TEXT);

нетипизированные файлы (определяются типом FILE).

В наших примерах F1, F4 и F5- типизированные файлы, F2 - текстовый файл, F3 -нетипизированный файл. Вид файла, вообще говоря, определяет способ хранения

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

Имена файлов

Имя файла - это любое выражение строкового типа, которое строится по правилам определения имен в MS-DOS (операционной системе ПК):

имя содержит до восьми разрешенных символов; разрешенные символы - это прописные и строчные латинские буквы, цифры, и символы: 

! @ # $ % ^ & ( ) ' ~ - _

имя начинается с любого разрешенного символа;

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

Имя диска - это один из символов A...Z, после которого ставится двоеточие. Имена А: и В: относятся к дисковым накопителям на гибких дискетах, имена С:, D: и т.д. - к жестким дискам. Эти имена могут относиться также к одному или нескольким виртуальным дискам, созданным в оперативной памяти ПК специальной командой VDISK в ходе выполнения файла автоустановки CONFIG.SYS дисковой операционной системы.

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

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

var

finp: text;

fout:file of String;

const

name = 'c:\dir\subdir\out.txt'; 

begin

assign(finp,'123.dat') ;

assign(fout,name); 

end.

Инициализация файла

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

Для чтения файл инициируется с помощью стандартной процедуры RESET:

RESET (<ф.п.>);

Здесь <ф.п.> - файловая переменная, связанная ранее процедурой ASSIGN с уже существующим файлом или логическим устройством-приемником информации.

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

Если делается попытка инициировать чтение из несуществующего файла или из логического устройства PRN, возникает ошибка периода исполнения, которая может быть сообщена программе ненулевым значением встроенной функции IORESULT типа WORD. Например, следующий фрагмент программы позволяет установить, существует ли требуемый файл на диске:

var

f : file of char; 

begin

assign(f,'myfile.dat');

{$I-} {Отключаем контроль ошибок ввода-вывода} 

reset(f);

{$I+} {Включаем контроль ошибок ввода-вывода} 

if IOResult <> 0 then

 ..... {Файл не существует} 

else

..... {Файл существует} 

end.

В этом фрагменте с помощью директивы компилятора {$I-} отключается автоматический контроль ошибок ввода-вывода. Если этого не сделать, то отсутствие файла приведет к аварийному завершению программы.

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

Стандартная процедура

REWRITE (<ф.п.>).

инициирует запись информации в файл или в логическое устройство, связанное ранее с файловой переменной <ф.п.>. Процедурой REWRITE нельзя инициировать запись информации в ранее существовавший дисковый файл: при выполнении этой процедуры старый файл уничтожается и никаких сообщений об этом в программу не передается. Новый файл подготавливается к приему информации и его указатель принимает значение 0.

Стандартная процедура

APPEND (<ф.п.>)

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

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

Логические устройства

Стандартные аппаратные средства ПК, такие как клавиатура, экран дисплея, печатающее устройство (принтер) и коммуникационные каналы ввода-вывода, определяются в Турбо Паскале специальными именами, которые называются логическими устройствами. Все они в Турбо Паскале рассматриваются как потенциальные источники или приемники текстовой информации.

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

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

PRN - логическое имя принтера. Если к ПК подключено несколько принтеров, доступ к ним осуществляется по логическим именам LPT1, LPT2 и LPT3 . Имена PRN и LPT1 первоначально - синонимы. Средствами ДОС можно присвоить имя PRN любому другому логическому устройству, способному принимать информацию.

Стандартный библиотечный модуль PRINTER, входящий в библиотеку TURBO.TPL, объявляет имя файловой переменной LST и связывает его с логическим

устройством LPT1. Это дает возможность использовать простое обращение к принтеру. Например, программа

Uses Printer; 

begin

WriteLn(LST, 'Привет, мир!') 

end.

выведет на принтер фразу «Привет, мир!», а все необходимые операции по открытию логического устройства выполнит библиотечный блок PRINTER (подробности работы с модулями см. в гл. 9).

AUX - логическое имя коммуникационного канала, который обычно используется для связи ПК с другими машинами. Коммуникационный канал может осуществлять и прием, и передачу данных, однако в программе в каждый момент времени ему можно назначить только одну из этих функций. Как правило, в составе ПК имеются два коммуникационных канала, которым даются имена логических устройств СОМ1 и COM2. Первоначально имена AUX и СОМ1 - синонимы.

NUL - логическое имя «пустого» устройства. Это устройство чаще всего используется в отладочном режиме и трактуется как устройство-приемник информации неограниченной емкости. При обращении к NUL как источнику информации выдается признак конца файла EOF.

Связывание логического устройства с файловой переменной осуществляется процедурой ASSIGN, например:

var

fi,fo : text; 

begin

assign(fi,'AUX');

assign(fо,'LPT2'); 

end.

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

Нетипизированные файлы

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

При инициации нетипизированного файла процедурами RESET или REWRITE можно указать длину записи нетипизированного файла в байтах. Например, так:

var

f: file;

begin

.......

assign(f, 'myfile.dat') 

reset(f,512);

.......

end.

Длина записи нетипизированного файла указывается вторым параметром при обращении к процедурам RESET или REWRITE, в качестве которого может использоваться выражение типа WORD. Если длина записи не указана, она принимается равной 128 байтам.

Турбо Паскаль не накладывает каких-либо ограничений на длину записи нетипизированного файла, за исключением требования положительности и ограничения максимальной длины 65535 байтами (емкость целого типа WORD). Однако для обеспечения максимальной скорости обмена данными следует задавать длину, которая была бы кратна длине физического сектора дискового носителя информации (512 байт). Более того, фактически пространство на диске выделяется любому файлу порциями - кластерами, которые в зависимости от типа диска могут занимать 2 и более смежных секторов. Как правило, кластер может быть прочитан или записан за один оборот диска, поэтому наивысшую скорость обмена данными можно получить, если указать длину записи, равную длине кластера.

При работе с нетипизированными файлами могут применяться все процедуры и функции, доступные типизированным файлам, за исключением READ и WRITE, которые заменяются соответственно высокоскоростными процедурами BLOCKREAD и 3LOCKWRITE . Для вызова этих процедур используются следующие предложения:

BLOCKREAD (<ф .п . >, <буф>, < [, <NN>] ) 

BLOCKWRITE (<ф . п . >, <буф>, < [, <NN>] )

Здесь <буф> - буфер: имя переменной, которая будет участвовать в обмене данными с дисками; 

<D> - количество записей, которые должны быть прочитаны или записаны

за одно обращение к диску; 

<NN> - необязательный параметр, содержащий при выходе из процедуры

количество фактически обработанных записей.

За одно обращение к процедурам может быть передано до N*RECS байт, где RECS - длина записи нетипизированного файла. Передача идет, начиная с первого байта переменной <буф>. Программист должен позаботиться о том, чтобы длина внутреннего представления переменной <буф> была достаточной для размещения всех N*RECS байт при чтении информации с диска. Если при чтении указана переменная <буф> недостаточной длины или если в процессе записи на диск не окажется нужного свободного пространства, возникнет ошибка ввода-вывода, которую можно заблокировать, указав необязательный параметр <NN> (переменная типа WORD).

После завершения процедуры указатель смещается на <NN> записей. Процедурами SEEK, FILEPOS и FILESIZE можно обеспечить доступ к любой записи нетипизированного файла.

Процедуры и функции для работы с файлами

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

Процедура Close.

Закрывает файл, однако связь файловой переменной с именем файла, установленная ранее процедурой ASSIGN, сохраняется. Формат обращения:

CLOSE (<ф.п.>)

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

Процедура RENAME.

Переименовывает файл. Формат обращения:

RENAME (<ф.п.>, <новое имя>)

Здесь <новое имя> - строковое выражение, содержащее новое имя файла. Перед выполнением процедуры необходимо закрыть файл, если он ранее был открыт процедурами RESET, REWRITE или APPEND.

Процедура ERASE.

Уничтожает-файл. Формат обращения:

ERASE (<ф.п.>)

Перед выполнением процедуры необходимо закрыть файл, если он ранее был открыт процедурами RESET, REWRITE или APPEND.

Следующий фрагмент программы показывает, как можно использовать процедуры RENAME и CLOSE при работе с файлами. Предположим, что требуется отредактировать файл, имя которого содержит переменная NAME. Перед редактированием необходимо убедиться, что нужный файл имеется на диске, и переименовать его - заменить расширение этого файла на ВАК (страховочная копия). Если файл с таким расширением уже существует, его надо стереть.

var

fi : text; {Исходный файл}

fo : text; {Отредактированный файл}

name : String;

name_bak: String;

k, i: Word; 

const

bak = '.bak'; 

begin

.......

{Получаем в name bak имя файла с расширением .ВАК:}

k := pos('.',name); 

if k = 0 then

k := length(name) +1; 

name_bak := copy(name,1,k-1) + bak; 

{Проверяем существование исходного файла:} 

assign(fi,name);

{$I-} ' reset(fi); 

if lOResult <> 0 then

halt; {Завершаем программу: файла не существует} 

close(fi); , 

{Проверяем существование .ВАК-файла:} 

assign(fо,name_bak); 

reset (fo); 

{$I+}

if lOResult = 0 then 

begin {Файл .ВАК существует:}

close(fo); {Закрываем его} 

erase(fo) {и уничтожаем} 

end;

{Проверки закончены, подготовка к работе:} 

rename(f i,name_bak); 

reset(fi); 

assign(fo,name); 

rewrite(fo);

.......

end.

Обратите внимание: проверка на существование файла .ВАК в данном примере необходима, так как обращение

rename(fi,name_bak); 

вызовет ошибку в случае, если такой файл существует.

Процедура FLUSH.

Очищает внутренний буфер файла и, таким образом, гарантирует сохранность всех последних изменений файла на диске. Формат обращения:

FLUSH (<ф.п.>)

Любое обращение к файлу в Турбо Паскале осуществляется через некоторый буфер, что необходимо для согласования внутреннего представления файлового компонента (записи) с принятым в ДОС форматом хранения данных на диске. В ходе выполнения процедуры FLUSH все новые записи будут действительно записаны на диск. Процедура игнорируется, если файл был инициирован для чтения процедурой RESET.

Функция EOF (<ф. п. >) : BOOLEAN.

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

Процедура CHDIR.

Изменение текущего каталога. Формат обращения:

CHDIR (<путь>)

Здесь <путь> - строковое выражение, содержащее путь к устанавливаемому по умолчанию каталогу.

Процедура GETDIR.

Позволяет определить имя текущего каталога (каталога по умолчанию). Формат обращения:

GETDIR (<устройство>, <каталог>)

Здесь <устройство> - выражение типа WORD , содержащее номер устройства: 0 - устройство по умолчанию, 1 - диск А, 2 - диск В и т.д.; 



<каталог> - переменная типа STRING, в которой возвращается путь к текущему каталогу на указанном диске.

Процедура MKDIR.

Создает новый каталог на указанном диске. Формат обращения:

MKDIR (<каталог>)

Здесь <каталог> - выражение типа STRING, задающее путь к каталогу. Последним именем в пути, т.е. именем вновь создаваемого каталога не может быть имя уже существующего каталога.^

Процедура RMDIR.

Удаляет каталог. Формат обращения:

RMDIR (<каталог>)

Удаляемый каталог должен быть пустым, т.е. не содержать файлов или имен каталогов нижнего уровня.

Функция IORESULT: WORD.

Возвращает условный признак последней операции ввода-вывода.

Если операция завершилась успешно, функция возвращает ноль. Коды ошибочных операций ввода-вывода представлены в прил.З. Следует помнить, что IORESULT становится доступной только при отключенном автоконтроле ошибок ввода-вывода. Директива компилятора {$I-} отключает, а директива {$I+} включает автоконтроль. Если автоконтроль отключен, а операция ввода-вывода привела к возникновению ошибки, устанавливается флаг ошибки и все последующие обращения к вводу-выводу блокируются, пока не будет вызвана функция IORESULT.

Ряд полезных файловых процедур и функций становится доступным при использовании библиотечного модуля DOS.TPU, входящего в стандартную библиотеку TURBO. TPL . Эти процедуры и функции указаны ниже. Доступ к ним возможен только после объявления USES DOS в начале программы (подробнее о работе с модулями см. гл.9).

Функция DISKFREE (<диск>) : LONGINT.

Возвращает объем в байтах свободного пространства на указанном диске. При обращении к функции выражение <диск> типа BYTE определяет номер диска: 0 - устройство по умолчанию, 1 - диск А , 2 - диск В и т.д. Функция возвращает значение -1, если указан номер несуществующего диска.

Функция DISKSIZE (<диск>) : LONGINT.

Возвращает полный объем диска в байтах или -1 , если указан номер несуществующего диска.

Процедура FINDFIRST.

Возвращает атрибуты первого из файлов, зарегистрированных в указанном каталоге. Формат обращения:



FINDFIRST (<маска>, <атрибуты>, <имя>)

Здесь <маска> - строковое выражение, содержащее маску файла;

<атрибуты> - выражение типа BYTE, содержащее уточнение к маске (атрибуты); <имя> - переменная типа SEARCHREC, в которой будет возвращено имя файла.

При формировании маски файла используются следующие символы-заменители ДОС:

* означает, что на месте этого символа может стоять сколько угодно (в том числе ноль) разрешенных символов имени или расширения файла;

? означает, что на месте этого символа может стоять один из разрешенных символов.

Например:

* . *      выбирает все файлы из каталога;

с* . *    выбирает все файлы с именами, начинающимися на с (cl.pas,сс!2345, c.dat и т.д.); 

a?.dat     выбирает имена файлов типа a0.dat, az.dat и т.д.

Маске может предшествовать путь'. Например, команда

с:\dir\subdir\*.pas

эзначает выбирать все файлы с расширением .PAS из каталога SUBDIR, находящегося на диске С; каталог SUBDIR зарегистрирован в каталоге верхнего уровня DIR, который, в свою очередь, входит в корневой каталог.

Байт <атрибуты> содержит двоичные разряды (биты), уточняющие, к каким именно файлам разрешен доступ при обращении к процедуре FINDFIRST . Вот как объявляются файловые атрибуты в модуле DOS. TPU:

const

Readonly = $01; {только чтение}

Hidden = $02; {скрытый файл}

SysFile = $04; {системный файл}

VolumeID = $08; {идентификатор тома}

Directory = $10; {имя подкаталога}

Archive =$20; {архивный файл}

AnyFile= $3F; {любой файл}

Комбинацией бит в этом байте можно указывать самые разные варианты, например $ 06 - выбирать все скрытые и/или системные файлы.

Результат работы процедуры FINDFIRST возвращается в переменной типа SEARCHREC. Этот тип в модуле DOS. TPU определяется следующим образом:

type

SearchRec = record

Fill : array [1..21] of Byte;

Attr : Byte;

Time : LongInt;

Size : LongInt;

Name : String.[12] 

end;

Здесь Attr - атрибуты файла (см. выше);



Time - время создания или последнего обновления файла; возвращается в упакованном формате; распаковать параметр можно процедурой UNPACKTIME (см.ниже); 

Size - длина файла в байтах; 

Name - имя и расширение файла. Для распаковки параметра TIME используется процедура

UNPACKTIME(Time: Longlnt; var T:DateTime). 

В модуле DOS. TPU объявлен следующий тип DateTime:

type

DateTime = record

year:Word; {год в формате 19ХХ}

month:Word; {месяц I..12}

day:Word; {день 1..31}

hour:Word; {час 0..23}

min:Word; {минуты 0..59}

sec:Word {секунды 0..59}

end;

Результат обращения к процедуре FINDFIRST можно проконтролировать с помощью функции DOSERROR типа WORD, которая возвращает значения:

0 - нет ошибок;

2 - не найден каталог;

18 - каталог пуст (нет указанных файлов).

Процедура FINDNEXT.

Возвращает имя следующего файла в каталоге. Формат обращения:

FINDNEXT (<сл.файл>)

Здесь <сл.фаш> - запись типа SEARCHREC (см. выше), в которой возвращается информация о файле.

Следующая простая программа иллюстрирует способ использования процедур FINDFIRST и FINDNEXT. Программа выводит на экран список всех PAS-файлов текущего каталога:

Uses DOS; 

var

S: SearchRec;

begin

FindFirst('*.pas',AnyFile,S); 

while DosError = 0 do begin

with S do

WriteLn(Name:12,Size:12); 

FindNext(S) 

end 

end.

Процедура GETFTIME.

Возвращает время создания или последнего обновления файла. Формат обращения:

GETFTIME (<ф.п.>, <время>)

Здесь <время> - переменная типа LONGINT, в которой возвращается время в упакованном формате.

Процедура SETFTIME.

Устанавливает новую дату создания или обновления файла. Формат обращения:

SETFTIME (<ф.п.>, <время>)

Здесь <время> - время и дата в упакованном формате.

Упаковать запись типа DATETIME в переменную типа LONGINT можно процедурой

PACKTIME (var T:DateTime; var Time:LongInt). 

(Описание типа DA TETIME см. выше).

Процедура GETFATTR.

Позволяет получить атрибуты файла. Формат обращения:



GETFATTR (<ф.п.>, <атрибуты>)

Здесь <атрибуты> - переменная типа WORD, в младшем байте которой возвращаются устанавливаемые атрибуты файла.

Процедура SETFATTR.

Позволяет установить атрибуты файла. Формат обращения:

SETFATTR (<ф.п.>, <атрибуты>) 

Функция FSEARCH: PATHSTR.

Ищет файл в списке каталогов. Формат вызова:

FSEARCH (<имя>, <сп.каталогов>)

Здесь <имя> - имя отыскиваемого файла (строковое выражение или переменная типа PATHSTR; имени может предшествовать путь); <сп.каталогов> - список каталогов, в которых отыскивается файл (строковое выражение или переменная типа STRING); имена каталогов разделяются точкой с запятой.

Результат поиска возвращается функцией FSEARCH в виде строки типа PATHSTR. В строке содержится путь и имя файла, если поиск был успешным, в противном случае возвращается пустая строка.

Тип PATHSTR в модуле DOS.TPU объявлен следующим образом:

type

PathStr = String[79];

Следует учесть, что поиск файла всегда начинается в текущем каталоге и только после этого продолжается в тех, что перечислены в <сп.каталогов>. Если файл обнаружен, дальнейший поиск прекращается, даже если часть каталогов осталась непросмотренной. В частности, если файл зарегистрирован в текущем каталоге, он «заслонит» собой одноименные файлы в других каталогах.

Пусть, например, на диске имеется файл \SUBDIR\MYFILE.PAS. Тогда в случае, если текущий каталог - корневой, обращение

FSEARCH ('MYFILE,PAS','\SUB; \SUBDIR').

вернет строку \SUBDIR\MYFILE.PAS, а обращение

FSEARCH ('MYFILE.PAS1,'\SUB')

вернет пустую строку. Однако, если текущим установлен каталог SUBDIR, то в обоих случаях вернется строка MYFILE.PAS (если файл находится в текущем каталоге,в выходной строке путь к нему не указывается).

Процедура FSPLIT.

«Расщепляет» имя файла, т.е. возвращает в качестве отдельных параметров путь к файлу, его имя и расширение. Формат обращения:

FSPLIT (<файл>, <путь>, <имя>, <расширение>)



Здесь <файл> - строковое выражение, содержащее спецификацию файла (имя с расширением и, возможно, с предшествующим путем); 

<путь> - переменная типа DIRSTR=STRING [67], в которой возвращается путь к файлу; 

<имя> - переменная типа NAMESTR=STRING [8], в которой возвращается имя файла;

<расширение> - переменная типа EXTSTR=STRING [4], в которой возвращается расширение с предшествующей ему точкой.

Процедура не проверяет наличие на диске указанного файла. В качестве входного параметра может использоваться переменная типа PATHSTR.

Функция FEXPAND: PATHSTR.

Дополняет файловое имя до полной спецификации, т.е. с указанием устройства и пути. Формат вызова:

FEXPAND (<файл>)

Здесь <файл> - строковое выражение или переменная типа PATHSTR.

Функция не проверяет наличие указанного файла на диске, а просто дополняет имя файла недостающими параметрами - текущим устройством и путем к текущему каталогу. Результат возвращается в строке типа PATHSTR.

Текстовые файлы

Текстовые файлы связываются с файловыми переменными, принадлежащими стандартному типу TEXT. Текстовые файлы предназначены для хранения текстовой

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

Текстовый файл трактуется в Турбо Паскале как совокупность строк переменной длины. Доступ к каждой строке возможен лишь последовательно, начиная с первой. При создании текстового файла в конце каждой записи (строки) ставится специальный признак EOLN (End OfLiNe - конец строки), а в конце всего файла - признак EOF (End Of File - конец файла). Эти признаки можно протестировать одноименными логическими функциями (см. ниже). При формировании текстовых файлов используются следующие системные соглашения:

EOLN- последовательность кодов ASCII #13 (CR) и #10 (LF);

EOF - код #26 стандарта ASCII.

Для доступа к записям применяются процедуры READ, READLN, WRITE, WRITELN. Они отличаются возможностью обращения к ним с переменным числом фактических параметров, в качестве которых могут использоваться символы, строки и числа. Первым параметром в любой из перечисленных процедур может стоять файловая переменная. В этом случае осуществляется обращение к дисковому файлу или логическому устройству, связанному с переменной процедурой ASSIGN. Если файловая переменная не указана, происходит обращение к стандартным файлам INPUT к OUTPUT.

Процедура READ.

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

READ (<ф.п.>,<сп.ввода>) или READ (<сп.ввода>)

Здесь <сп.ввода> - список ввода: последовательность из одной или более переменных типа CHAR, STRING, а также любого целого или вещественного типа.

При вводе переменных типа CHAR выполняется чтение одного символа из файла и присваивание считанного значения переменной. Если перед выполнением чтения указатель файла достиг конца очередной строки, то результатом чтения будет символ CR (ASCII код #13), а если достигнут конец файла, то - символ EOF (код #26). При вводе с клавиатуры символ CR вводится при нажатии на клавишу Enter, а символ EOF - при одновременном нажатии клавиш CTRL и Z.

При вводе переменных типа STRING количество считанных процедурой и помещенных в строку символов равно максимальной длине строки, если только раньше не встретились символы CR или EOF. В этом случае сами символы CR и EOF в строку не помещаются. Если количество символов во входном потоке данных больше максимальной длины строки, «лишние» символы до конца строки отбрасываются,а новое обращение к READ возвращает пустую строку. Таким образом, процедура READ не в состоянии прочесть последовательность строк: первая строка будет прочитана нормально, а все последующие окажутся пустыми. Для ввода последовательности строк нужно использовать процедуру READLN (см. ниже).

При вводе числовых переменных процедура READ вначале выделяет подстроку во входном потоке по следующему правилу: все ведущие пробелы, символы табуляции и маркеры конца строк EOLN пропускаются; после выделения первого значащего символа, наоборот, любой из перечисленных символов или символ EOF служат признаком конца подстроки. Выделенная таким образом подстрока затем рассматривается как символьное представление числовой константы соответствующего типа и преобразуется во внутреннее представление, а полученное значение присваивается переменной. Если в подстроке был нарушен требуемый формат представления численной константы, возникает ошибка ввода-вывода. Если при пропуске ведущих пробелов встретился символ EOF, переменная получает значение 0. Отметим, что в Турбо Паскале не предусмотрен ввод шестнадцатеричных констант.

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

Backspace, Ctrl-H, перевод курсора влево - стирают символ слева от курсора;

перевод курсора вправо - восстанавливает символ за символом предыдущую строку ввода;

Ctrl-Z Enter - завершает ввод по процедуре READ; оставшиеся «лишние» символьные параметры принимают значение CHR(26), строки возвращаются пустыми, а численные переменные остаются без изменения.



Максимальная длина буфера ввода при работе с клавиатурой составляет 127 символов. Ввод с клавиатуры по процедуре READ сопровождается эхо-повтором вводимых символов на экране ПК.

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

const

N = 1000; {Максимальная длина ввода}

var

f : text;

m : array [1..N] of real; 

i : Integer; 

begin

assign(f, 'prog.dat') ; 

reset(£); i := 1;

while not EOF(f) and (i <= N) do 

begin

read(f ,m[i] ) ; 

inc(i) 

end; 

close(f);

.......

end.

Процедура READLN.

Обеспечивает ввод символов, строк и чисел. Эта процедура идентична процедуре READ за исключением того, что после считывания последней переменной оставшаяся часть строки до маркера EOLN пропускается, поэтому следующее обращение к READLN или READ начинается с первого символа новой строки. Кроме того, эту процедуру можно вызвать без параметра <cn.вводa> (см. процедуру READ), что приведет к пропуску всех символов текущей строки вплоть до EOLN.

Если процедура используется для чтения с клавиатуры, нажатие на клавишу Enter отобразится на экране как последовательность CR + LF и курсор будет помещен в начало следующей строки, в то время как в процедуре READ эхо-повтором клавиши Enter является символ CR и курсор помещается в начало текущей строки.

Процедура WRITE.

Обеспечивает вывод информации в текстовый файл или передачу ее на логическое устройство. Формат обращения:

WRITE (<ф.п.>, <сп.вывода>) или WRITE (<сп.вывода>)

Здесь <сп.вывода> - список вывода: последовательность из одного или более выражений типа CHAR, STRING, BOOLEAN, a также любого целого или вещественного типа.



Файловая переменная <ф.п.>, если она указана, должна быть предварительно описана как переменная типа TEXT и связана с именем файла или логическим устройством процедурой ASSIGN. Если файловая переменная отсутствует, подразумевается вывод в стандартный файл OUTPUT, который обычно связан с экраном ПК.

Любой элемент списка вывода может иметь форму

OutExpr [ : MinWidth [ : DecPlaces ] ]

Здесь OUTEXPR - выводимое выражение;

MINWIDTH, DECPLACES - выражения типа WORD (квадратные скобки означают возможность отсутствия заключенных в них параметров).

Подпараметр MINWIDTH, если он присутствует, указывает минимальную ширину поля, в которое будет записываться символьное представление значения OUTEXPR. Если символьное представление имеет меньшую длину, чем MINWIDTH, оно будет дополнено слева пробелами, если - большую длину, то подпараметр MINWIDTH игнорируется и выводится необходимое число символов.

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

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

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

При выводе логических выражений в зависимости от их значения выводятся строки TRUE или FALSE. (Ввод логических констант процедурами READ или READLN не предусмотрен).

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

_s#.##############E*####,

где:

_     пробел;

s    пробел для положительного и знак «-» для отрицательного чисел;

#    десятичная цифра;



Е    символ десятичного основания;

*    знак «+» или «-» в зависимости от знака десятичного порядка числа.

Если подпараметр MINWIDTH опущен, принимается его значение по умолчанию (23). Если MINWIDTH меньше 10, считается, что он равен 10.

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

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

Процедура WRITELN. Эта процедура полностью идентична процедуре WRITE за исключением того, что выводимая строка символов завершается кодами CR и LF. При вызове WRITELN можно опускать параметр <сп.вывода>: в этом случае в файл передается маркер EOLN, что при выводе на экран приведет к переводу курсор» в начало следующей строки.

Логическая функция EOLN. Возвращает TRUE, если во входном текстовом файле достигнут маркер конца строки. Формат обращения:

EOLN<ф.п.>

Если параметр <ф.п.> опущен, функция проверяет стандартный файл INPUT.

Существует некоторое отличие в работе функций EOLN и EOF с дисковыми файлами и логическими устройствами. Дело в том, что для логического устройства невозможно предвидеть, каким будет результат чтения очередного символа. Поэтому при работе с логическим устройством функция EOLN возвращает TRUE, если последним считанным с устройства символом был EOLN или EOF, в то время как при чтении с диска TRUE возвращается в случае, если следующим считываемым символом будет EOLN или EOF. Аналогичное различие наблюдается и в функции EOF: для логического устройства TRUE возвращается в случае, если последним символом был EOF, а при чтении с диска - если следующим считываемым символом будет EOF. Иными словами, функции тестируют соответствующие признаки для логического устройства после очередного чтения, а для файла - перед чтением.



Логическая функция SEEKEOLN.

Пропускает все пробелы и знаки табуляции до маркера конца строки EOLN или до первого значащего символа и возвращает TRUE, если маркер обнаружен. Формат обращения:

SEEKEOLN (<ф.п.>)

 Если параметр <ф.п.> опущен, функция проверяет стандартный файл INPUT.

Логическая функция SEEKEOF.

Пропускает все пробелы, знаки табуляции и маркеры конца строки EOLN до маркера конца файла или до первого значащего символа и возвращает TRUE, если маркер обнаружен. Формат обращения:

SEEKEOF (<ф.п.>)

Если параметр <ф.п.> опущен, функция проверяет стандартный файл INPUT.

В следующем примере, иллюстрирующем работу с текстовым файлом, подсчитывается общее количество символов в файле и результат делится на 40000 - таким способом можно оценить объем рукописи в так называемых учетно-издательских листах:

var

f : text; 

s: String; 

const

Sum: LongInt = 0; {Здесь будет количество символов}

begin

Write('Имя файла: ');{Запрашиваем...}

Readln(s); {и вводим имя файла.}

assign(f,s);

Reset (f); {Открываем файл}

while not EOF(f) do {Подсчитываем...}

begin {количество. . .}

ReadLn(f,s); {символов...} 

inc(Sum, Length(s)) {в файле}

end ; 

Close(f); {Закрываем файл}

WriteLn('Объем = ', Sum/40000 : 6:2,' уч.изд.л.')

end.

Типизированные файлы

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

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

Процедура READ.

Обеспечивает чтение очередных компонентов типизированного файла. Формат обращения:

READ (<ф.п.>,<сп.ввода>)

Здесь <cn.вводa> - список ввода, содержащий одну или более переменных такого же типа, что и компоненты файла.

Файловая переменная <ф.п.> должна быть объявлена предложением FILE OF... и связана с именем файла процедурой ASSIGN. Файл необходимо открыть процедурой RESET. Если файл исчерпан, обращение к READ вызовет ошибку ввода-вывода.

Процедура WRITE.

 Используется для записи данных в типизированный файл. Формат обращения:

WRITE (<ф.п.>,<сп.вывода>)

Здесь <сп.вывода> - список вывода, содержащий одно или более выражений того же типа, что и компоненты файла.

Процедура SEEK.

Смещает указатель файла к требуемому компоненту. Формат обращения:

SEEK (<ф.п.>,<N компонента>)

Здесь <N компонента> - выражение типа LONGINT, указывающее номер компонента файла.

Первый компонент файла имеет номер 0. Процедуру нельзя применять к текстовым файлам.

Функция FILESIZE.

Возвращает значение типа LONGINT, которое содержит количество компонентов файла. Формат обращения: '

FILESIZE (<ф.п.>)

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

seek (FileVar, FileSize(FileVar)); 

где FILEVAR - файловая переменная.

Функция.FILEPOS.

Возвращает значение типа LONGINT, содержащее порядковый номер компонента файла, который будет обрабатываться следующей операцией ввода-вывода. Формат обращения:

FILEPOS (<ф.п.>)

Функцию нельзя использовать для текстовых файлов. Первый компонент файла имеет порядковый номер 0.

Администратор кучи

Как уже отмечалось, администратор кучи - это служебная подпрограмма, которая обеспечивает взаимодействие пользовательской программы с кучей. Администратор кучи обрабатывает запросы процедур NEW, GETMEM, DISPOSE, FREEMEM и др. и изменяет значения указателей HEAPPTR и FREELIST. Указатель HEAPPTR содержит адрес нижней границы свободной части кучи, а указатель FREELIST - адрес описателя первого свободного блока. В модуле SYSTEM указатель FREELIST описан как POINTER, однако фактически он указывает на следующую структуру данных:

type

PFreeRec = ATFreeRec; 

TFreeRec = record

Next : pointer;

Size : pointer 

end;

Эта списочная структура предназначена для описания всех свободных блоков памяти, которые расположены ниже границы HEAPPTR. Происхождение блоков связано со случайной последовательностью использования процедур NEW-DISPOSE или GETMEM-FREEMEM («ячеистая» структура кучи). Поле NEXT, в записи TFREEREC содержит адрес описателя следующего по списку свободного блока кучи или адрес, совпадающий с HEAPEND, если этот участок последний в списке. Поле SIZE содержит ненормализованную длину свободного блока или 0, если ниже адреса, содержащегося в HEAPPTR, нет свободных блоков. Ненормализованная длина определяется так: в старшем слове этого поля содержится количество свободных параграфов, а в младшем - количество свободных байт в диапазоне 0... 15. Следующая функция преобразует значение поля SIZE в фактическую длину свободного блока:

Function BlbckSize(Size: pointer): Longint;

{Функция преобразует ненормализованную длину свободного блока в байты}

type

PtrRec = record

Lo, Hi : word

end; 

var

LengthBlock: Longint; 

begin

BlockSize := Longint(PtrRec(Size).Hi)*16 + PtrRec(Size).Lo 

end;

Сразу после загрузки программы указатели HEAPPTR и FREELIST содержат один и тот же адрес, который совпадает с началом кучи (этот адрес содержится в указателе HEAPORG). При этом в первых 8 байтах кучи хранится запись, соответствующая типу TFREEREC (поле NEXT содержит адрес, совпадающий со значением HEAPEND, a поле SIZE - ноль, что служит дополнительным признаком отсутствия «ячеек» в динамической памяти). При работе с кучей указатели HEAPPTR и FREELIST будут иметь одинаковые значения до тех пор, пока в куче не образуется хотя бы один свободный блок ниже границы, содержащейся в указателе HEAPPTR. Как только это произойдет, указатель FREELIST станет ссылаться на начало этого блока, а в первых 8 байтах освобожденного участка памяти будет размещена запись TFREEREC. Используя FREELIST как начало списка, программа пользователя всегда сможет просмотреть весь список свободных блоков и при необходимости модифицировать его.

Описанный механизм вскрывает один не очень существенный недостаток, связанный с работой администратора кучи, а именно: в любой освободившийся блок администратор должен поместить описатель этого блока, а это означает, что длина блока не может быть меньше 8 байтов. Администратор кучи всегда выделяет память блоками, размер которых кратен размеру записи TFREEREC, т.е. кратен 8 байтам. Даже если программа запросит 1 байт, администратор выделит ей фактически 8 байт. Те же 8 байт будут выделены при запросе 2, 3 ,..., 8 байт; при запросе 9 байт будет выделен блок в 16 байт и т.д. Это обстоятельство следует учитывать, если Вы хотите минимизировать возможные потери динамической памяти. Если запрашиваемый размер не кратен 8 байтам, в куче образуется <дырка> размером от 1 до 7 байт, причем она не может использоваться ни при каком другом запросе динамической памяти вплоть до того момента, когда связанная с ней переменная не будет удалена из кучи.

Если при очередном обращении к функции NEW или GETMEM администратор не может найти в куче нужный свободный блок, он обращается к функции, адрес которой содержит переменная HEAPERROR. Эта функция соответствует следующему процедурному типу:

type

HeapErrorFun = function (Size:word): Integer;

Здесь SIZE - размер той переменной, для которой нет свободной динамической памяти. Стандартная функция, адрес которой при запуске программы содержит переменная HEAPERROR, возвращает 0, что приводит к останову программы по ошибке периода счета с кодом 203 (см. прил. 3). Вы можете переопределить эту функцию и таким образом блокировать останов программы. Для этого необходимо написать собственную функцию и поместить ее адрес в указатель HEAPERROR. Например:

Function HeapFunc(Size: Word): Integer; far; 

begin

HeapFunc := 1 end; 

begin {Основная программа}

HeapError := @HeapFunc;

.......

end.

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

0 - прекратить работу программы;

1 - присвоить соответствующему указателю значение NIL и продолжить работу программы;

2 - повторить выделение памяти; разумеется, в этом случае внутри функции типа HEAPERRORFUN необходимо освободить память нужного размера.

Адреса и указатели

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

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

В ПК адреса задаются совокупностью двух шестнадцатиразрядных слов, которые называются сегментом и смещением. Сегмент - это участок памяти, имеющий длину 65536 байт (64 Кбайт) и начинающийся с физического адреса, кратного 16 (т.е. О, 16, 32, 48 и т.д.). Смещение указывает, сколько байт от начала сегмента необходимо пропустить, чтобы обратиться к нужному адресу.

Адресное пространство ПК составляет 1 Мбайт (речь идет о так называемой стандартной памяти ПК; на современных компьютерах с процессорами 80386 и выше адресное пространство составляет 4 Гбайт, однако в Турбо Паскале нет средств, поддерживающих работу с дополнительной памятью; при использовании среды Borland Pascal with Objects 7.0 такая возможность имеется). Для адресации в пределах 1 Мбайта нужно 20 двоичных разрядов, которые получаются из двух шестнадцатиразрядных слов (сегмента и смещения) следующим образом (рис.6.1): содержимое сегмента смещается влево на 4 разряда, освободившиеся правые разряды заполняются нулями, результат складывается с содержимым смещения.

Puc.6.1. Схема формирования адреса в ПК

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

Таким образом, по своей внутренней структуре любой указатель представляет собой совокупность двух слов (данных типа WORD), трактуемых как сегмент и смещение. С помощью указателей можно размещать в динамической памяти любой из известных в Турбо Паскале типов данных. Лишь некоторые из них (BYTE, CHAR, SHORTINT, BOOLEAN) занимают во внутреннем представлении один байт, остальные - несколько смежных. Поэтому на самом деле указатель адресует лишь первый байт данных.

Динамическая память

Все переменные, объявленные в программе, размещаются в одной непрерывной области оперативной памяти, которая называется сегментом данных. Длина сегмента данных определяется архитектурой микропроцессоров 80x86 и составляет 65536 байт, что может вызвать известные затруднения при обработке больших массивов данных. С другой стороны, объем памяти ПК (обычно не менее 640 Кбайт) достаточен для успешного решения задач с большой размерностью данных. Выходом из положения может служить использование так называемой динамической памяти.

Динамическая память - это оперативная память ПК, предоставляемая программе при ее работе, за вычетом сегмента данных (64 Кбайт), стека (обычно 16 Кбайт) и собственно тела программы. Размер динамической памяти можно варьировать в широких пределах (см. прил.1). По умолчанию этот размер определяется всей доступней памятью ПК и, как правило, составляет не менее 200...300 Кбайт.

Динамическая память - это фактически единственная возможность обработки массивов данных большой размерности. Многие практические задачи трудно или невозможно решить без использования динамической памяти. Такая необходимость возникает, например, при разработке систем автоматизированного проектирования (САПР): размерность математических моделей, используемых в САПР, может значительно отличаться в разных проектах; статическое (т.е. на этапе разработки САПР) распределение памяти в этом случае, как правило, невозможно. Наконец, динамическая память широко используется для временного запоминания данных при работе с графическими и звуковыми средствами ПК.

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

Использование указателей

Подведем некоторые итоги. Итак, динамическая память составляет 200...300 Кбайт или больше, ее начало хранится в переменной HEAPORG, а конец соответствует адресу переменной HEAPEND. Текущий адрес свободного участка динамической памяти хранится в указателе HEAPPTR.

Посмотрим, как можно использовать динамическую память для размещения крупных массивов данных. Пусть, например, требуется обеспечить доступ к элементам прямоугольной матрицы 100x200 типа EXTENDED. Для размещения такого массива требуется память 200000 байт (100*200*10).

Казалось бы, эту проблему можно решить следующим образом:

var

i,j : Integer;

PtrArr : array [1..100, 1...200] of  Real; 

begin

for i := 1 to 100 do 

for j := 1 to 200 do

new(PtrArr[i,j]);

.......

end.

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

PtrArr[1,1] := 0;

if PtrArr[i,j*2] > 1 then ......

Вспомним, однако, что длина внутреннего представления указателя составляет 4 байта, поэтому для размещения массива PTRARR потребуется 100*200*4 = 80000 байт, что превышает размер сегмента данных (65536 байт), доступный, как уже отмечалось, программе для статического размещения данных.

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

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

SEG(X) - возвращает сегментную часть адреса; 

OFS(X) - возвращает смещение.

Аргументом X при обращении к этим функциям может служить любая переменная, з том числе и та, на которую указывает указатель. Например, если имеем

var

р : Real; 

begin

......

new(p);

р := 3.14;

.......

end.

то функция SEG(P) вернет сегментную часть адреса, по которому располагается 4-байтный указатель Р, в то время как SEG(P^) - сегмент 6-байтного участка кучи, в котором хранится число 3.14 .

С другой стороны, с помощью встроенной функции

PTR(SEG,OFS: WORD): POINTER

можно создать значение указателя, совместимое с указателями любого типа. Таким образом возможна такая последовательность действий. Вначале процедурой GETMEM из кучи забираются несколько фрагментов подходящей длины (напомню, что за одно обращение к процедуре можно зарезервировать не более 65521 байт динамической памяти). Для рассматриваемого примера удобно резервировать фрагменты такой длины, чтобы в них могли, например, разместиться строки прямоугольной матрицы, т.е. 100 * 10 = 2000 байт. Начало каждого фрагмента, т.е. фактически начало размещения в памяти каждой строки, запоминается в массиве PTRSTR, состоящем из 100 указателей, теперь для доступа к любому элементу строки нужно вычислить смещение этого элемента от начала строки и сформировать соответствующий указатель:

var

i,j:Integer; 

PtrStr : array [1..100] of pointer;

const

SizeOfReal = 6; 

begin

for i := 1 to 100 do

GetMem (PtrStr [i] , SizeOfReal*200) ;

.......

{Обращение к элементу матрицы [i,j]} 

pr := ptr(seg(PtrStr[i]),

ofs(PtrStr[i])+(j-1)*SizeOfReal); 

if рr > 1 then

.......

end.

Поскольку оператор вычисления адреса PR := PTR... будет, судя по всему, использоваться в программе неоднократно, полезно ввести вспомогательную функцию GETR, возвращающую значение элемента матрицы, и процедуру PUTR, устанавливающую новое значение элемента (правила объявления процедур и функций изложены в гл. 8). Каждая из них, в свою очередь, обращается к функции ADDRR для вычисления адреса. В примере 6.1 приводится программа, создающая в памяти матрицу из NxM случайных чисел и вычисляющая их среднее значение.

Пример 6.1 

const

SizeOfReal = 6; {Длина переменной типа REAL}



N = 100; {Количество столбцов}

М = 200; {Количество строк} 

var

i,j : Integer;

PtrStr: array [1..N] of pointer;.

s : Real ; 

type

RealPoint =^Real;

{-------------------}

Function AddrR(i,j: word): RealPoint; 

{По сегменту i и смещению j выдает адрес вещественной переменной} 

begin

AddrR := ptr(seg (PtrStr [i]),

ofs{ PtrStr [i]) + (j -1) * SizeOfReal) 

end {AddrR} ;

{-------------------}

Function GetR(i,j: Integer): Real;

{ Выдает значение вещественной переменной по сегменту i и смещению j ее адреса}

begin

GetR := AddrR(i,j)

end {GetR};

{-------------------}

Procepure PutR(i,j : Integer; x: Real);

{Помещает в переменную, адрес которой имеет сегмент i

и смещение j, вещественное значение x}

begin

AddrR ( i , j ) : = x 

end {PutR};

{-------------------}

begin {Main}

for i :=1 to N do 

begin

GetMem (PtrStr [i] , M*SizeOfReal) ; 

for j := 1 to M do PutR(i, j, Random) 

end; 

S := 0;

for i := 1 to N do 

for j := 1 to M do

s := s +GetR(i,j);

WriteLn(s/(N * М) :12:10)

end {Main} .

В рассмотренном примере предполагается, что каждая строка размещается в куче, начиная с границы параграфа, и смещение для каждого указателя PTRSTR равно нулю. В действительности при последовательных обращениях к процедуре GETMEM начало очередного фрагмента следует сразу за концом предыдущего и может не попасть на границу сегмента. В результате, при размещении фрагментов максимальной длины (65521 байт) может возникнуть переполнение при вычислении смещения последнего байта.

Оъбявление указателей

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

var

P1 :^Integer; 

р2 :^Real; 

type

PerconPointer = PerconRecord; 

PerconRecord = record

Name : String;

Job : String;

Next : PerconPointer 

end;

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

Рис.6.2. Списочная структура данных

В Турбо Паскале можно объявлять указатель и не связывать его при этом с каким-либо конкретным типом данных. Для этого служит стандартный тип POINTER, например:

var

р: pointer;

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

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

var

p1,p2: integer; 

р3 : Rеа1; 

рр : pointer;

то присваивание

p1 := р2;

вполне допустимо, в то время как

р1 := р3;

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

pp := p3; 

p1 := pp;

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

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

Процедуры и функции для работы с динамической памятью

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

Функция ADDR.

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

ADDR ( X )

Здесь Х- любой объект программы (имя любой переменной, процедуры, функции). Возвращаемый адрес совместим с указателем любого типа. Отметим, что аналогичный результат возвращает операция @ .

Функция CSEG.

Возвращает значение, хранящееся в регистре CS микропроцессора в начале работы программы в регистре CS содержится сегмент начала кода программы). Обращение:

CSEG 

Результат возвращается в слове типа WORD.

Процедура DISPOSE.

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

DISPOSE(TP)

Здесь ТР - типизированный указатель. При повторном использовании процедуры применительно к уже освобожденному фрагменту возникает ошибка периода исполнения. При освобождении динамических объектов можно указывать вторым параметром обращения к DISPOSE имя деструктора (подробнее см. гл.10).

Функция DSEG.

Возвращает значение, хранящееся в регистре DS микропроцессора (в начале работы программы в регистре DS содержится сегмент начала данных программы). Обращение:

DSEG 

Результат возвращается в слове типа WORD.

Процедура FREEMEM.

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

FREEMEM ( Р, SIZE )

Здесь Р - нетипизированный указатель;

SIZE - длина в байтах освобождаемого фрагмента.

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

Процедура GETMEM.

Резервирует за нетипизированным указателем фрагмент динамической памяти требуемого размера. Обращение:

GETMEM ( Р, SIZE )

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

Процедура MARK.

Запоминает текущее значение указателя кучи HEAPPTR. Обращение:

MARK ( PTR )

Здесь PTR - указатель любого типа, в котором будет возвращено текущее значение HEAPPTR. Используется совместно с процедурой RELEASE для освобождения части кучи.

Функция MAXAVAIL.

Возвращает размер в байтах наибольшего непрерывного участка кучи. Обращение:

MAXAVAIL

Результат имеет тип LONGINT. За один вызов процедуры NEW или GETMEM нельзя зарезервировать памяти больше, чем значение, возвращаемое этой функцией.

Функция MEMAVAIL.

Возвращает размер в байтах общего свободного пространства кучи. Обращение:

MEMAVAIL 

Результат имеет тип LONGINT.

Процедура NEW.

Резервирует фрагмент кучи для размещения переменной. Обращение:

NEW ( ТР )

Здесь ТР - типизированный указатель.

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

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

type

PInt =^Integer; 

var

p: Pint; 

begin

p := New(PInt);

......

end.

При размещении в динамической памяти объекта разрешается в качестве второго параметра обращения к NEW указывать имя конструктора (см. гл.10).

Функция OFS.

Возвращает значение типа WORD, содержащее смещение адреса указанного объекта. Вызов:

OFS ( X ) 

Здесь Х- выражение любого типа или имя процедуры.

Функция PTR.

Возвращает значение типа POINTER по заданному сегменту SEG и смещению OFS. Вызов:

PTR ( SEG, OFS )

Здесь SEG - выражение типа WORD, содержащее сегмент;

OFS - выражение типа WORD, содержащее смещение. 

Значение, возвращаемое функцией, совместимо с указателем любого типа.

Процедура RELEASE.

Освобождает участок кучи. Обращение:

RELEASE ( PTR ) 

Здесь PTR - указатель любого типа, в котором предварительно было сохранено процедурой MARK значение указателя кучи. Освобождается участок кучи от адреса, хранящегося в PTR, до конца кучи. Одновременно уничтожается список всех свободных фрагментов, которые, возможно, были созданы процедурами DISPOSE или FREEMEM.

Функция SEG.

Возвращает значение типа WORD, содержащее сегмент адреса указанного объекта. Вызов:

SEG ( X ) 

Здесь X - выражение любого типа или имя процедуры.

Функция SIZEOF.

Возвращает длину в байтах внутреннего представления указанного объекта. Вызов:

SIZEOF ( X ) 

Здесь X - имя переменной, функции или типа. Например, везде в программе из примера 6.1 вместо константы SIZEOFREAL можно было бы использовать обращение SIZEOF(REAL).

Указатели и динамическая память

Динамическая память

Адреса и указатели

Объявление указателей

Выделение и освобождение динамической памяти

Использование указателей

Процедуры и функции для работы с динамической памятью

Администратор кучи

Выделение и освобождение динамической память

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

Начало кучи хранится в стандартной переменной HEAPORG (рис. 6.3), конец - в временной HEAPEND. Текущую границу незанятой динамической памяти указывает указатель HEAPPTR.

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

var

i, j : Integer; 

r : Real; 

begin 

New(i) ;

.......

end.

После выполнения этого фрагмента указатель / приобретет значение, которое перед этим имел указатель кучи HEAPPTR, а сам HEAPPTR увеличит свое значение на 2, так как длина внутреннего представления типа INTEGER, с которым связан указатель I, составляет 2 байта (на самом деле это не совсем так: память под любую переменную выделяется порциями, кратными 8 байтам - см. п.6.7). Оператор

new(r);

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

Рис.6.3. Расположение кучи в памяти ПК

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

i := 2; {B область памяти i помещено значение 2} 

r := 2*pi; {В область памяти r помещено значение 6.28}

Таким образом, значение, на которое указывает указатель, т.е. собственно данные, размещенные в куче, обозначаются значком ^, который ставится сразу за указателем. Если за указателем нет значка ^, то имеется в виду адрес, по которому размещены данные. Имеет смысл еще раз задуматься над только что сказанным: значением любого указателя является адрес, а чтобы указать, что речь идет не об адресе, а о тех данных, которые размещены по этому адресу, за указателем ставится л. Если Вы четко уясните себе это, у Вас не будет проблем при работе с динамической памятью.

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

r := sqr(r) + i - 17;

Разумеется, совершенно недопустим оператор

r := sqr(r) + i - 17;

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

r := sqr(r) ;

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

r :=i;

так как вещественным данным, на которые указывает R, нельзя присвоить значение указателя (адрес).

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

dispose (r) ; 

dispose (i) ;

вернут в кучу 8 байт, которые ранее были выделены указателям I и R (см. выше).

Отметим, что процедура DISPOSE(PTR) не изменяет значения указателя PTR, а лишь возвращает в кучу память, ранее связанную с этим указателем. Однако повторное применение процедуры к свободному указателю приведет к возникновению ошибки периода исполнения. Освободившийся указатель программист может пометить зарезервированным словом NIL. Помечен ли какой-либо указатель или нет, можно проверить следующим образом:

const

p:  Real = NIL;

begin

.......

if p = NIL then

new(p);

.......

dispose(p); 

p := NIL;

.......

end.

Никакие другие операции сравнения над указателями не разрешены.

Приведенный выше фрагмент иллюстрирует предпочтительный способ объявления указателя в виде типизированной константы (см. гл. 7) с одновременным присвоением ему значения NIL. Следует учесть, что начальное значение указателя (при его объявлении в разделе переменных) может быть произвольным. Использование указателей, которым не присвоено значение процедурой NEW или другим способом, не контролируется системой и может привести к непредсказуемым результатам.

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



Другая возможность состоит в освобождении целого фрагмента кучи. С этой целью перед началом выделения динамической памяти текущее значение указателя HEAPPTR запоминается в переменной-указателе с помощью процедуры MARK. Теперь можно в любой момент освободить фрагмент кучи, начиная от того адреса, который запомнила процедура MARK, и до конца динамической памяти. Для этого используется процедура RELEASE. Например:

var

p,p1,p2,

рЗ,р4,р5 : Integer; 

begin

new(p1);

new(p2) ;

mark(p); .

new(p3);

new(p4);

new(p5)

......

release(p); 

end.

В этом примере процедурой MARK(P) в указатель Р было помещено текущее значение HEAPPTR, однако память под переменную не резервировалась. Обращение RELEASE(P) освободило динамическую память от помеченного места до конца кучи. Рис.6.4 иллюстрирует механизм работы процедур NEW-DISPOSE и NEW-MARK-RELEASE для рассмотренного примера и для случая, когда вместо оператора RELEASE(P) используется, например, DISPOSE(P3).

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

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

GETMEM (P, SIZE) - резервирование памяти; 

FREEMEM(P, SIZE) - освобождение памяти.

Здесь Р - нетипизированный указатель;

SIZE - размер в байтах требуемой или освобождаемой части кучи.



Puc.6.4. Состояние динамической памяти: а) перед освобождением; б) после Dispose(p3); в) после Release(p)

За одно обращение к куче процедурой GETMEM можно зарезервировать до 65521 байта динамической памяти.

Использование процедур GETMEM-FREEMEM, как и вообще вся работа с динамической памятью, требует особой осторожности и тщательного соблюдения простого правила: освобождать нужно ровно столько памяти, сколько ее было зарезервировано, и именно с того адреса, с которого она была зарезервирована.



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

var

i,j : Integer; 

r : Real; 

begin

new(i); {i := HeapOrg; HeapPtr:= HeapOrg + 2}

j := i; {j := HeapOrg} 

j := 2;

dispose(i); {HeapPtr := HeapOrg} 

new(r); {r := HeapOrg; HeapPtr:= HeapOrg + 6}

r := pi; 

WriteLn(j) 

end.

Что будет выведено на экран дисплея? Чтобы ответить на этот вопрос, проследим за значениями указателя HEAPPTR. Перед исполнением программы этот указатель имел значение адреса начала кучи HEAPORG, которое и было передано указателю I, азатем и J. После выполнения DISPOSE(I) указатель кучи вновь приобрел значение HEAPORG, этот адрес передан указателю R в процедуре NEW(R). После того как по адресу R разместилось вещественное число pi=3.14159, первые 2 байта кучи оказались заняты под часть внутреннего представления этого числа. В то же время J все еще сохраняет адрес HEAPORG, поэтому оператор WRITELN(J^) будет рассматривать 2 байта числа pi как внутреннее представление целого числа (ведь J - это указатель на тип INTEGER) и выведет 8578.

Константы - массивы

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

type

colors '= (white, red, black); 

const

ColStr : array [colors] of String [5] =('white', 'red', 'blaсk'); 

vector : array [1..5] of Byte = (0,0,0,0,0); .

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

const

digit : array [0..9] of Char =

('0', Ч','2','3','4','5','6', ' 7 ' , ' 8 ' , ' 9 ') ;

digchr: array [0..9] of Char =0123456789';

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

Следующая программа выведет на экран три строки с монотонно увеличивающимися целыми числами:

var

i, j, k, 1 : Byte; 

const

matr : array [1..3, 1..5] of Byte = ((0, 1, 2, 3,4),

(5, 6, 7, 8, 2) , (10,11,12,13,14)) ; 

cube : array [0..1, 0..1, 0..2] of Integer = 

(((0 ,1 ,2 ), (3 ,4 ,5 )), ((6 ,7 ,8 ), (9 ,10,11))) ; 

mas4 : array [0..1, 0..1, 0..1, 0..1] of Word = (

(((0 ,1 ), (2 ,3 )) ,((4 ,5 ), (6 ,7 ))), (((8 ,9 ), (10,11)), ((12,13), (14,15))));

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

Константы - множества

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

type

days = set of 1. .31;

digc = set of ' 0 ' . . ' 9 ' ;

error = set of 1..24; 

const

WorkDays : days = [1..5, 8.. 12, 15.. 19, 22.. 26, 29, 30];

EvenDigits: digc = ['0', '2', '4', '6', '8'];

ErrorFlag : error= [] ;

Константы простых типов и типа String

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

type

colors = (white, red, black); { ------- Правильные объявления: ----- } 

const

CurrCol colors = red;

name String = 'Вирт Н.';

year Word =1989;

x Real = 0.1;

min Integer = 0;

max Integer =10;

days 1..31 = 1;

answer Char = ' Y'; {------ Неправильные объявления: ------ }

mass : array [min..max] of Real; {Нельзя использовать типизированные константы в качестве границ диапазона}

a,b,c : Byte = 0; {Нельзя использовать список идентификаторов}

var

NameF: String [22] = 'prog.pas'; {Нельзя объявлять типизированную константу в разделе переменных}

Константы - указатели

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

const 

pr : Real= NIL;

Константы - записи

Определение константы-записи имеет следующий вид:

<идентификатор> : <тип> = (<сп.знач.полей>)

Здесь <идентификатор> - идентификатор константы; 

          <тип> - тип записи; 

         <сп.знач.полей> - список значений полей.

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

type

point = record

х, у : Real 

end;

vect = array [0..1] of point; 

month = (Jan, Feb, Mar, Apr, May, Jun,

Jly, Aug, Sep, Oct, Nov, Dec); 

date = record

d : 1..31;

m : month; 

у : 1900..1999 

end;

const

origon :point = (x :0; у : -1) ;

line:vector = ((x:-3.1; у: 1.5) , (x: 5.9; у: 3.0)) ;

SomeDay: date = (d : 16; m : Mar; у : 1989);

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

type

forma = record

case Boolean of

true : (Birthplace: String [40]); 

false : (Country : String [20] ; EntryPort : String [20] ; 

        EntryDate : array [1..3] of Word; count : Word) 

end ; 

const

Perconl : forma = (Country : 'Норвегия'; EntryPort : 

        'Мурманск'; EntryDate : (16, 3, 89); count : 12) ; 

Percon2 : forma = (Birthplace : 'Москва');

Типизированные константы

Константы простых типов и типа STRING

Константы-массивы

Константы-записи

Константы-множества

Константы-указатели

В Турбо Паскале допускается использование типизированных констант. Они задаются в разделе объявления констант следующим образом:

<идентификатор> : <тип> = <значение>

Здесь <идентификатор> - идентификатор константы; 

          <тип> - тип константы; 

         <значение> - значение константы.

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

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

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

Локализация имен

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

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

Рис.8.1. Пример структуры программы

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

Program ...; 

Procedure А; 

Procedure A1;

.......

begin

.......

end {A1}; 

Procedure A2;

.......

begin

end {A2}; 

begin {A}

.......

end {A};

Procedure В; 

Procedure B1;

.......

begin {B};

end

Procedure B2 ; 

Procedure B21;

.......

и т.д.

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

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

При входе в подпрограмму низшего уровня становятся доступными не только объявленные в ней имена, но и сохраняется доступ ко всем именам верхнего уровня. Образно говоря, любая подпрограмма как бы окружена полупрозрачными стенками: снаружи подпрограммы мы не видим ее внутренности, но, попав в подпрограмму, можем наблюдать все, что делается снаружи. Так, например, из подпрограммы В21 мы можем вызвать подпрограмму А, использовать имена, объявленные в основной программе, в подпрограммах В и В2, и даже обратиться к ним. Любая подпрограмма может, наконец, вызвать саму себя - такой способ вызова называется рекурсией.

Пусть имеем такое описание:

Program ..;

var V1 : ... ; 

Procedure A; 

var V2 :...;

.......

end {A}; 

Procedure B; 

var V3 :...;

Procedure Bl; 

var V4 :...;

Procedure В11; 

var V5;

.......

Из процедуры В11 доступны все пять переменных V1,...,V5, из процедуры В1 доступны переменные V1,..., V4, из центральной программы - только V1.

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

В отличие от стандартного Паскаля в Турбо Паскале допускается произвольная последовательность описания констант, переменных, типов, меток и подпрограмм. Например, раздел VAR описания переменных может появляться в пределах раздела описаний одной и той же подпрограммы много раз и перемежаться с объявлениями других объектов и подпрограмм. Для Турбо Паскаля совершенно безразличен порядок следования и количество разделов VAR, CONST, TYPE, LABEL, но при определении о6ласти действия этих описаний следует помнить, что имена, описанные ниже по тексту программы, недоступны из ранее описанных подпрограмм, например: 



var V1 : ...; 

Procedure S; 

var V2 : ...;

end {S}; 

var V3 :...;

.......

Из процедуры S можно обратиться к переменным V1 и V2, но нельзя использовать V3, так как описание V3 следует в программе за описанием процедуры S.

Имена, локализованные в подпрограмме, могут совпадать с ранее объявленными глобальными именами. В этом случае считается, что локальное имя «закрывает» глобальное и делает его недоступным, например: 

var

i : Integer; 

Procedure P; 

var

i : Integer; 

begin

writeln(i) 

end {P}; 

begin

i := 1; 

P 

end.

Что напечатает эта программа? Все, что угодно: значение внутренней переменной I при входе в процедуру Р не определено, хотя одноименная глобальная переменная

имеет значение 1. Локальная переменная «закроет» глобальную и на экран будет выведено произвольное значение, содержащееся в неинициированной внутренней переменной. Если убрать описание

var

i : Integer;

из процедуры Р, то на экран будет выведено значение глобальной переменной I, т.е. 1. Таким образом, одноименные глобальные и локальные переменные - это разные переменные. Любое обращение к таким переменным в теле подпрограммы трактуется как обращение к локальным переменным, т.е. глобальные переменные в этом случае попросту недоступны.

Нетипизированные параметры - переменные

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

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

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

В примере 8.4 функция NORMA вычисляет норму вектора, длина которого меняется случайным образом. Стандартная константа MAXINT содержит максимальное значение целого типа INTEGER и равна 32767.

Следует учесть, что при обращении к функции NORMA массив X помещается в стек и передается по ссылке, поэтому описание локальной переменной А в виде одномерного массива максимально возможной длины в 65532 байта (встроенная константа MAXINT определяет максимально возможное значение типа INTEGER и равна 32767), совпадающего с X, на самом деле не приведет к выделению дополнительного объема памяти под размещение этой переменной. Иными словами, переменная А - фиктивная переменная, размер которой никак не влияет на объем используемой памяти. С таким же успехом можно было бы объявить ее в виде массива из одного элемента, правда, в этом случае необходимо позаботиться об отключении контроля выхода индекса за

границы диапазона.

Пример 8.4 

const

NN = 100; {Максимальная длина вектора} 

var

а : array [1..NN] of Real;

i, j, N : Integer;

{----------------}

Function Norma (var x; N: Integer) : Real; 

var

a : array [1..2*MaxInt div SizeOf (Real) ] of Real absolute x;

i : Integer;

s : Real; 

begin {Norma}

s := 0;

for i := 1 to N do 

s := s + sqr (a [i] ) ;

Norma := sqrt(s) 

end {Norma} ;

{-------------------}

begin {main}

for i := 1 to 10 do 

begin

N := Random (NN) + 1; {Текущая длина вектора}

for j := 1 to N do

a [ j ] : = Random ; 

WriteLn ('N = ', N:2,норма=',Norma(a, N):10:7)

end 

end {main} .

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

Описание программы

Описание подпрограммы состоит из заголовка и тела подпрограммы.

и может отсутствовать. Если же

Список формальных параметров необязателен и может отсутствовать. Если же он есть, то в нем должны быть перечислены имена формальных параметров и их типы, например:
Procedure SB(a: Real; b: Integer; c: Char);
Как видно из примера, параметры в списке отделяются друг от друга точками с запятой. Несколько следующих подряд однотипных параметров можно объединять в подсписки, например, вместо
Function F(a: Real; b: Real): Real; 
можно написать проще:
Function F(a,b: Real): Real;
Операторы тела подпрограммы рассматривают список формальных параметров как своеобразное расширение раздела описаний: все переменные из этого списка могут использоваться в любых выражениях внутри подпрограммы. Таким способом осуществляется настройка алгоритма подпрограммы на конкретную задачу.
Рассмотрим следующий пример. В языке Турбо Паскаль нет операции возведения в степень, однако с помощью встроенных функций LN(X) и ЕХР(Х) нетрудно реализовать новую функцию с именем, например, POWER, осуществляющую возведение любого вещественного числа в любую вещественную степень. В программе (пример 8.1) вводится пара чисел X и Y и выводится на экран дисплея результат возведения X сначала в степень +Y, а затем - в степень -Y. Для выхода из программы нужно ввести Ctrl-Z и Enter.
Пример 8.1

var
х,у:Real;
Function Power (a, b : Real): 
Real; 
begin {Power} 
if a > 0 then
Power := exp(b * In (a)) 
else if a < 0 then
Power := exp(b * ln(abs(a)) 
else if b = 0 then
Power := 1 
else
Power := 0 
end {Power} ;
{--------------------}
begin {main} 
repeat
readln(x,y) ;
writeln (Power (x,y) :12:10, Power (x, -y) : 15 : 10) 
until EOF 
end {main} .
Для вызова функции POWER мы просто указали ее в качестве параметра при обращении к встроенной процедуре WRITELN. Параметры X и Y в момент обращения к функции - это фактические параметры. Они подставляются вместо формальных параметров А и В в заголовке функции и затем над ними осуществляются нужные действия. Полученный результат присваивается идентификатору функции - именно он и будет возвращен как значение функции при выходе из нее. В программе функция POWER вызывается дважды - сначала с параметрами Х и Y, а затем Х и -Y, поэтому будут получены два разных результата.


Механизм замены формальных параметров на фактические позволяет нужным образом настроить алгоритм, реализованный в подпрограмме. Турбо Паскаль следит за тем, чтобы количество и тип формальных параметров строго соответствовали количеству и типам фактических параметров в момент обращения к подпрограмме. Смысл используемых фактических параметров зависит от того, в каком порядке они перечислены при вызове подпрограммы. В примере 8.1 первый по порядку фактический параметр будет возводиться в степень, задаваемую вторым параметром, а не наоборот. Пользователь должен сам следить за правильным порядком перечисления фактических параметров при обращении к подпрограмме.
Любой из формальных параметров подпрограммы может быть либо параметром-значением, либо параметром-переменной, либо, наконец, параметром-константой.
В предыдущем примере параметры А и В определены как параметры-значения. Если параметры определяются как параметры-переменные, перед ними необходимо ставить зарезервированное слово VAR, а если это параметры-константы,- слово CONST, например:
Procedure MyProcedure (var a: Real; b: Real; const c: String); 
Здесь A - параметр-переменная, В -параметр-значение, а С - параметр-константа.
Определение формального параметра тем или иным способом существенно, в основном, только для вызывающей программы: если формальный параметр объявлен
как параметр-переменная, то при вызове подпрограммы ему должен соответствовать фактический параметр в виде переменной нужного типа; если формальный параметр
объявлен как параметр-значение или параметр-константа, то при вызове ему может
соответствовать произвольное выражение. Контроль за неукоснительным соблюдением этого правила осуществляется компилятором Турбо Паскаля. Если бы для предыдущего примера был использован такой заголовок функции:
Function Power (var a, b : Real) : Real;
то при втором обращении к функции компилятор указал бы на несоответствие типа фактических и формальных параметров (параметр -Уесть выражение, в то время как соответствующий ему формальный параметр описан как параметр-переменная).


Для того чтобы понять, в каких случаях использовать тот или иной тип параметров, рассмотрим, как осуществляется замена формальных параметров на фактические в момент обращения к подпрограмме.
Если параметр определен как параметр-значение, то перед вызовом подпрограммы это значение вычисляется, полученный результат копируется во временную память и передается подпрограмме. Важно учесть, что даже если в качестве фактического параметра указано простейшее выражение в виде переменной или константы, все равно подпрограмме будет передана лишь копия переменной (константы). Любые возможные изменения в подпрограмме параметра-значения никак не воспринимаются вызывающей программой, так как в этом случае изменяется копия фактического параметра.
Если параметр определен как параметр-переменная, то при вызове подпрограммы передается сама переменная, а не ее копия (фактически в этом случае подпрограмме передается адрес переменной). Изменение параметра-переменной приводит к изменению самого фактического параметра в вызывающей программе.
В случае параметра-константы в подпрограмму также передается адрес области памяти, в которой располагается переменная или вычисленное значение. Однако компилятор блокирует любые присваивания параметру-константе нового значения в теле подпрограммы.
Представленный ниже пример 8.2 поясняет изложенное. В программе задаются два
целых числа 5 и 7, эти числа передаются процедуре INC2, в которой они удваиваются. Один из параметров передается как параметр-переменная, другой - как параметр-значение. Значения параметров до и после вызова процедуры, а также результат их удвоения выводятся на экран.
Пример 8.2

а : Integer = 5; 
b : Integer = 7 ;
{-----------------}
Procedure Inc2 (var c: Integer; b: Integer) ; 
begin {Inc2} 
с := с + с; 
b := b + b; 
WriteLn ( 'удвоенные: ', c:5, b:5)
end {inc2}; 
{--------------}
begin {main}
WriteLn('исходные: ', a:5, b:5);
Inc2(a,b);
WriteLn('результат: ', a:5, b:5) 
end {main}.


В результате прогона программы будет выведено:
исходные:   5  7
удвоенные: 10 14
результат: 10  7
Как видно из примера, удвоение второго формального параметра в процедуре INC2 не вызвало изменения фактической переменной В, так как этот параметр описан в заголовке процедуры как параметр-значение. Этот пример может служить еще и иллюстрацией механизма «накрывания» глобальной переменной одноименной локальной: хотя переменная В объявлена как глобальная (она описана в вызывающей программе перед описанием процедуры), в теле процедуры ее «закрыла» локальная переменная В, объявленная как параметр-значение.
Итак, параметры-переменные используются как средство связи алгоритма, реализованного в подпрограмме, с внешним миром: с помощью этих параметров подпрограмма может передавать результаты своей работы вызывающей программе. Разумеется, в распоряжении программиста всегда есть и другой способ передачи результатов - через глобальные переменные. Однако злоупотребление глобальными связями делает программу , как правило, запутанной, трудной в понимании и сложной в отладке. В соответствии с требованиями хорошего стиля, программирования рекомендуется там, где это возможно, использовать передачу результатов через фактические параметры-переменные.
С другой стороны, описание всех формальных параметров как параметров-переменных нежелательно по двум причинам. Во-первых, это исключает возможность вызова подпрограммы с фактическими параметрами в виде выражений, что делает программу менее компактной. Во-вторых, и главных, в подпрограмме возможно случайное использование формального параметра, например, для временного хранения промежуточного результата, т.е. всегда существует опасность непреднамеренно испортить фактическую переменную. Вот почему параметрами-переменными следует объявлять только те, через которые подпрограмма в действительности передает результаты вызывающей программе. Чем меньше параметров объявлено параметрами-переменными и чем меньше в подпрограмме используется глобальных переменных, тем меньше опасность получения непредусмотренных программистом побочных эффектов, связанных с вызовом подпрограммы, тем проще программа в понимании и отладке. По той же причине не рекомендуется использовать параметры-переменные в заголовке функции: если результатом работы функции не может быть единственное значение, то логичнее использовать процедуру или нужным образом декомпозировать алгоритм на несколько подпрограмм.
Существует еще одно обстоятельство, которое следует учитывать при выборе вида формальных параметров. Как уже говорилось, при объявлении параметра-значения
осуществляется копирование фактического параметра во временную память. Если
этим параметром будет массив большой размерности, то существенные затраты времени и памяти на копирование при многократных обращениях к подпрограмме можно
минимизировать, объявив этот параметр параметром-константой. Параметр-константа не копируется во временную область памяти, что сокращает затраты времени на вызов подпрограммы, однако любые его изменения в теле подпрограммы невозможны - за
этим строго следит компилятор.

Параметры - массивы и параметры - строки

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

Procedure S (a: array [1..10] of Real);

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

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

type

atype = array [1..10]of Real; 

Procedure S (a: atype);

.......

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

type

intype = String [15] ;

outype = String [30] ; 

Function St (s : intype): outype;

.......

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

подпрограммах массивы с «плавающими» границами изменения индексов. Например, если разработана программа, обрабатывающая матрицу 10х10 элементов, то для обработки матрицы 9x11 элементов необходимо переопределить тип, т.е. перекомпилировать всю программу (речь идет не о динамическом размещении массивов в куче, а о статическом описании массивов и передаче их как параметров в подпрограммы). Этот недостаток, как и отсутствие в языке средств обработки исключительных ситуаций (прерываний), унаследован из стандартного Паскаля и представляет собой объект постоянной и вполне заслуженной его критики. Разработчики Турбо Паскаля не рискнули кардинально изменить свойства базового языка, но, тем не менее, включили в него некоторые средства, позволяющие в известной степени смягчить отмеченные недостатки.Эти недостатки практически полностью устранены в языке Object Pascal, используемом в визуальной среде программирования Delphi.

Прежде всего, в среде Турбо Паскаля можно установить режим компиляции, при котором отключается контроль за совпадением длины фактического и формального параметра-строки (см. прил.1). Это позволяет легко решить вопрос о передаче подпрограмме строки произвольной длины. При передаче строки меньшего размера формальный параметр будет иметь ту же длину, что и параметр обращения; передача строки большего размера приведет к ее усечению до максимального размера формального параметра. Следует сказать, что контроль включается только при передаче строки, объявленной как формальный параметр-переменная. Если, соответствующий параметр объявлен параметром-значением, эта опция игнорируется и длина не контролируется.
Значительно сложнее обстоит дело с передачей массивов произвольной длины. Наиболее универсальным приемом в этом случае будет, судя по всему, работа с указателями и использование индексной арифметики. Несколько проще можно решить эту проблему при помощи нетипизированных параметров (см. п.8.5). В версии Турбо Паскаля 7.0 язык поддерживает так называемые открытые массивы, легко решающие проблему передачи подпрограмме одномерных массивов переменной длины.
Открытый массив представляет собой формальный параметр подпрограммы, описывающий базовый тип элементов массива, но не определяющий его размерности и границы:
Procedure MyProc(OpenArray: array of Integer);
Внутри подпрограммы такой параметр трактуется как одномерный массив с нулевой нижней границей. Верхняя граница открытого массива возвращается функцией HIGH, упоминавшейся в п.4.1.1. Используя 0 как минимальный индекс и значение, возвращаемое функцией HIGH, как максимальный индекс, подпрограмма может обрабатывать одномерные массивы произвольной длины:
{Иллюстрация использования открытых массивов: программа выводит на экран содержимое двух одномерных массивов разной длины с помощью одной процедуры ArrayPrint} 
Procedure  ArrayPrint(aArray: array of Integer); 
var
k: Integer; 
begin
for k := 0 to High(aArray) do 
Write(aArray[k]:8);
WriteLn 
end;
const
A:array [-1..2] of Integer = (0,1,2,3); 
B: array [5..7] of Integer = (4,5,6); 
begin
ArrayPrint(A);
ArrayPrint(B) 
end.
Как видно из этого примера, фактические границы массивов А и В, передаваемых в качестве параметров вызова процедуре ArrayPrint, не имеют значения. Однако размерность открытых массивов (количество индексов) всегда равна 1 - за этим следит компилятор. Если бы, например, мы добавили в программу двумерный массив С
var
С: array [1..3,1..5] of Integer;
то обращение
ArrayPrint(С)
вызывало бы сообщение об ошибке
Error26: Type mismatch. 
(Ошибка 26: Несоответствие типов.)

Процедурные типы. Параметры - функции и параметры - процедуры.

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

Для объявления процедурного типа используется заголовок процедуры (функции), в котором опускается ее имя, например:

type

Prod = Procedure (a, b, c: Real; var d: Real);

Proc2 = Procedure (var a, b) ;

РгосЗ = Procedure;

Func1 = Function: String;

Func2 = Function (var s: String): Real;

Как видно из приведенных примеров, существует два процедурных типа: тип-процедура и тип-функция.

Пример 8.3 иллюстрирует механизм передачи процедур в качестве фактических параметров вызова. Программа выводит на экран таблицу двух функций:

sin1(х) = (sin(x) + 1) * ехр(-х)

cos1(x) = (cos(x) + 1) * exp(-x).

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

Пример 8.3.

Uses CRT; 

type

Func = Function (x: Real) : Real;

{----------------}

Procedure PrintFunc (XPos: Byte; F:Func) ; 

{Осуществляет печать функции F . (XPos - горизонтальная позиция начала вывода) } 

const

np = 20; {Количество вычислений функций} 

var

х : Real; i : Integer; 

begin {PrintFunc} 

for i := 1 to np do 

begin

x := i * (2 * pi / np) ; 

GotoXY (XPos, WhereY) ; 

WriteLn (x:5:3, F(x):18:5) 

end 

end; {PrintFunc}

{-----------------}

Function Sin1fx: Real): Real; far; 

begin

sinl := (sin(x) + 1) * exp(-x) 

end;

Function Cos1(x: Real): Real; far; 

begin

cosl := (cos(x) + 1) * exp(-x) 

end;

{---------------}

begin {основная программа} 

ClrScr; {Очищаем экран}

PrintFunc (1, sin1); GotoXY (1,1); {Переводим курсор

в левый верхний угол}

PrintFunc (40, cos1) 

end.

Обратите внимание: для установления правильных связей функций SIN1 и COS1 с процедурой PRINTFUNC они должны компилироваться с расчетом на дальнюю модель памяти. Вот почему в программу вставлены стандартные директивы FAR сразу

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

Стандартные процедуры (функции) Турбо Паскаля не могут передаваться рассмотренным способом.

В программе могут быть объявлены переменные процедурных типов, например, так:

var

p1 : Proc1; 

f1, f2 : Func2; 

р : array [1..N] of Proc1;

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

type

Proc = Procedure (n: word; var a: Byte); 

var

ProcVar: Proc; x, у : Byte;

Procedure Procl(x: word; var y: Byte); far; 

begin

if x > 255 then

у := x mod 255 

else

у := Byte(x) 

end;

begin {Главная программа} 

ProcVar := Proc1; 

for x := 150 to' 180 do 

begin

ProcVar (x + 100, y); 

Write (y:8) 

end 

end.

Разумеется, такого рода присваивания допустимы и для параметров-функций, например:

type

FuncType = Function (i : Integer) : Integer; 

var

VarFunc : FuncType;

i : Integer; 

Function MyFunc (count : Integer) : Integer; far;

begin

.......

end; {MyFunc} 

begin {Основная программа}

.......

i := MyFunc(1); {Обычное использование результата функции}

.......

VarFunc := MyFunc;

{Присваивание переменной процедурного типа имени функции MyFunc}

.......

end.

Отметим, что присваивание

VarFunc := MyFunc(1);

будет недопустимым, так как слева и справа от знака присваивания используются несовместимые типы: слева - процедурный тип, а справа - INTEGER; имя функции со списком фактических параметров MyFunc(1) трактуется Турбо Паскалем как обращение к значению функции, в то время как имя функции без списка параметров рассматривается как имя функции.

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

Процедуры и функции

Локализация имен

Описание подпрограммы

Заголовок

Параметры

Параметры-массивы и параметры-строки

Процедурные типы. Параметры-функции и параметры-процедуры

Нетипизированные параметры-переменные

Рекурсия и опережающее описание

Расширенный синтаксис вызова функций

Как отмечалось в гл.2, процедуры и функции представляют собой относительно самостоятельные фрагменты программы, оформленные особым образом и снабженные именем. Упоминание этого имени в тексте программы называется вызовом процедуры (функции). Отличие функции от процедуры заключается в том, что результатом исполнения операторов, образующих тело функции, всегда является некоторое единственное значение или указатель, поэтому обращение к функции можно использовать в соответствующих выражениях наряду с переменными и константами. Условимся далее называть процедуру или функцию общим именем «подпрограмма», если только для излагаемого материала указанное отличие не имеет значения.

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

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

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

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

Расширинный синтаксис вызова функций

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

{$Х+} {Включаем расширенный синтаксис}

Function My.Func (var x : Integer) : Integer; 

begin

if x<0 then x:=0 

else MyFunc := x+10 

end; {MyFunc} 

var

i : Integer; 

begin {main} 

i := 1;

i := 2*MyFunc(i) -100; {Стандартный вызов функции} 

MyFunc ( i ) {Расширенный синтаксис вызова} 

end. {main}

Расширенный синтаксис делает использование функций таким же свободным, как, например, их использование в языке Си, и придает Турбо Паскалю дополнительную гибкость. С помощью расширенного синтаксиса нельзя вызывать стандартные функции. Компиляция с учетом расширенного синтаксиса включается активным состоянием опции EXTENDED SYNTAX диалогового окна OPTIONS/COMPILER (см. прил.1) или глобальной директивой компилятора {$Х+}.

Рекурсия и опережающее описание

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

Рассмотрим классический пример - вычисление факториала (пример 18). Программа вводит с клавиатуры целое число N и выводит на экран значение N!, которое вычисляется с помощью рекурсивной функции РАС. Для выхода из программы необходимо либо ввести достаточно большое целое число, чтобы вызвать переполнение при умножении чисел с плавающей запятой, либо нажать Ctrl-Z и Enter.

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

тривиальное решение поставленной задачи. В примере 8.5 решение при N = 0 тривиально и используется для остановки рекурсии.

Пример 8.5

Program Factorial;

{$S+} {Включаем контроль переполнения стека} 

var

n: Integer;

Function Facfn: Integer): Real; 

{Рекурсивная функция, вычисляющая n ! } 

begin {Fac}

 if n < 0 then

WriteLn ('Ошибка в задании N') 

else

if n = 0 then

Fac := 1

else Fac := n * Fac(n-l) 

end {Fac} ;

{---------------}

begin {main} repeat

ReadLn (n) ; 

WriteLn ('n!= ',Fac(n)) 

until EOF 

end {main} .

Рекурсивная форма организации алгоритма обычно выглядит изящнее итерационной и дает более компактный текст программы, но при выполнении, как правило, медленнее и может вызвать переполнение стека (при каждом входе в подпрограмму ее локальные переменные размещаются в особым образом организованной области памяти, называемой программным стеком). Переполнение стека особенно ощутимо сказывается при работе с сопроцессором: если программа использует арифметический сопроцессор, результат любой вещественной функции возвращается через аппаратный стек сопроцессора, рассчитанный всего на 8 уровней. Если, например, попытаться заменить тип REAL функции FAC (см. пример 8.5) на EXTENDED, программа перестанет работать уже при N = 8. Чтобы избежать переполнения стека сопроцессора, следует размещать промежуточные результаты во вспомогательной переменной. Вот правильный вариант примера 8.5 для работы с типом EXTENDED:

Program Factorial;

{$S+,N+,E+} {Включаем контроль Стека и работу сопроцессора} 

var

n: Integer;

Function Fac(n: Integer): extended; 

var

F: extended; {Буферная переменная

для разгрузки стека сопроцессора}

{Рекурсивная функция, вычисляющая п! } 

begin {Рас} 

if n < 0 then

WriteLn ('Ошибка в задании N') else

if n = 0 then

Fac := 1 else begin

F := Fac(n-l) ; Fac := F * n end end {Fac} ;

{--------------}

begin {main} 

repeat

ReadLn (n) ;

WriteLn ('n! = ',Fac(n)) 

until EOF 

end {main} .

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

Procedure A (i : Byte) ; 

begin

.......

В (i);

.......

end ;

Procedure В (j : Byte) ;

.......

begin

.......

A(j);

.......

end;

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

Procedure В(j : Byte); forward;

Procedure A(i : Byte);

begin

.......

В (i) ;

.......

end ;

Procedure В; 

begin

.......

A(j);

.......

end;

Как видим, опережающее описание заключается в том, что объявляется лишь заголовок процедуры В, а ее тело заменяется стандартной директивой FORWARD. Теперь в процедуре А можно использовать обращение к процедуре В - ведь она уже описана, точнее, известны ее формальные параметры, и компилятор может правильным образом организовать ее вызов. Обратите внимание: тело процедуры В начинается заголовком, в котором уже не указываются описанные ранее формальные параметры.

Заголовок

Заголовок процедуры имеет вид:

PROCEDURE <имя> [ (<сп. ф. п . >) ] ; 

Заголовок функции:

FUNCTION <имя> [ (<сп.ф.п.>)] : <тил>;

Здесь <имя> - имя подпрограммы (правильный идентификатор); 

<сп.ф.п.> - список формальных параметров; 

<тип> - тип возвращаемого функцией результата.

Сразу за заголовком подпрограммы может следовать одна из стандартных директив ASSEMBLER, EXTERNAL, FAR, FORWARD, INLINE, INTERRUPT, NEAR. Эти директивы уточняют действия компилятора и распространяются на всю подпрограмму и только на нее, т.е. если за подпрограммой следует другая подпрограмма, стандартная директива, указанная за заголовком первой, не распространяется на вторую.

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

EXTERNAL - с помощью этой директивы объявляется внешняя подпрограмма (см. п.11.1).

FAR - компилятор должен создавать код подпрограммы, рассчитанный на дальнюю модель вызова. Директива NEAR заставит компилятор создать код, рассчитанный на ближнюю модель памяти. По умолчанию все подпрограммы, объявленные в интерфейсной части модулей, генерируются с расчетом на дальнюю модель вызова, а все остальные подпрограммы - на ближнюю модель.

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

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

Явное объявление модели памяти стандартными директивами имеет более высокий приоритет по сравнению с опциями настройки среды Турбо Паскаля.

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

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

INTERRUPT - используется при создании процедур обработки прерываний (см. п.11.4).

Доступ к объявленным в модуле объектам

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

UNIT Cmplx;

{---------------------}

INTERFACE

{---------------------}

type complex = record 

re, im:real

end;

{---------------------}

IMPLEMENTATION

{---------------------}

Procedure AddC; begin

z.re := x.re + y.re; z . im := x.im + y. im

end {AddC};

Procedure SubC;

begin

z.re := x.re - y. re ; 

z.im := x.im - y.im

end {SubC};

Procedure MulC;

begin

z.re := x.re*y.re - x.im*y. im;

z.im := x.re*у.im + x.im*y.re

end {MulC};

Procedure DivC;

var

zz : real;

begin

zz := sqr(y.re) + sqr(y.im); 

z. re := (x.re * y.re + x.im * y.im) / zz; 

z.im := (x.re * y.im - x.im * y.re) / zz

end {DivC};

end.

Текст этого модуля следует поместить в файл CMPLX.PAS. Вы можете его откомпилировать, создав TPU-файл, после чего Вашей программе станут доступны процедуры из новой библиотеки. Например, в следующей программе (пример 9.1) осуществляются четыре арифметические операции над парой комплексных чисел.

Пример 9.1

Uses Cmplx; 

var

а, Ь, с : complex; 

begin

a.re := 1; a.im := 1; 

b.re := 1; b.im := 2; 

AddC(a, b, c); 

WriteLn('Сложение: 'c.re:5:1, c.im:5:1,'i') ; 

SubC(a, b, c) ; 

WriteLn('Вычитание: 'с.re:5:1, с.im:5:1,'i');

MulC(a, b, c); 

WriteLn('Умножение: 'c.re:5:1, c.im:5:l,'i') ; 

DivC(a, b, c); 

WriteLn('Деление: 'c.re:5:l, с.im:5:1,'i');

end.

После объявления Uses Cmplx программе стали доступны все объекты, объявленные в интерфейсной части модуля CMPLX. При необходимости можно переопределить любой их этих объектов, как это произошло, например, с объявленной в модуле типизированной константой С. Переопределение объекта означает, что вновь объявленный объект «закрывает» ранее определенный в модуле одноименный объект. Чтобы получить доступ к «закрытому» объекту, нужно воспользоваться составным именем: перед именем объекта поставить имя модуля и точку. Например, оператор

WriteLn(cmplx.c.re:5:l, cmplx.с.im:5:1,'i');

выведет на экран содержимое «закрытой» типизированной константы из предыдущего примера.

Инициирующая часть

Инициирующая часть завершает модуль. Она может отсутствовать вместе с начинающим ее словом BEGIN или быть пустой - тогда за BEGIN сразу следует признак конца модуля (слово END и следующая за ним точка).

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

Unit FileText;

Interface

Procedure Print(s : string);

Implementation

var

f: text; const 

name = 'output.txt'; Procedure Print; 

begin

WriteLn(f, s) 

end;

{ Начало инициирующей части: } 

begin

assign(f, name);

rewrite(f);

{ Конец инициирующей части } 

end.

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

Интерфейсная часть

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

Unit Cmplx; 

Interface

tуре

complex = record

re, im : real 

end;

Procedure AddC (x, у : complex; var z : complex); 

Procedure MulC (x, у : complex; var z : complex);

Если теперь в основной программе написать предложение

Uses Cmplx;

то в программе станут доступными тип COMPLEX и две процедуры - ADDC и MULC из мдуля CMPLX

Отметим, что объявление подпрограмм в интерфейсной части автоматически сопровождается их компиляцией с использованием дальней модели памяти (см. гл.8). Таким образом обеспечивается доступ к подпрограммам из основной программы и других модулей. Следует учесть, что все константы и переменные, объявленные в интерфейсной части модуля, равно как и глобальные константы и переменные основной программы, помещаются компилятором Турбо Паскаля в общий сегмент данных (максимальная длина сегмента 65536 байт). Порядок появления различных разделов объявлений и их количество может быть произвольным. Если в интерфейсной части объявляются внешние подпрограммы или подпрограммы в машинных кодах (см. гл. И), их тела (т.е. зарезервированное слово EXTERNAL, в первом случае, и машинные коды вместе со словом INLINE - во втором) должны следовать сразу за их заголовками в исполняемой части модуля (не в интерфейсной!). В интерфейсной части модулей нельзя использовать опережающее описание.

Исполняема часть

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

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

Unit Cmplx;

Interface

type

complex = record

re, im : real 

end;

Procedure AddC (x, у : complex; var z : complex); 

Implementation

Procedure AddC; 

begin

z.re := x.re +Y.re;

z.im := x.im +y.im

end;

end.

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

Компиляция модулей

В среде Турбо Паскаля имеются средства, управляющие способом компиляции модулей и облегчающие разработку крупных программных проектов. В частности, определены три режима компиляции: COMPILE, MAKE и BUILD (см. прил.1). Режимы отличаются только способом связи компилируемого модуля или основной программы с другими модулями, объявленными в предложении USES,

При компиляции модуля или основной программы в режиме COMPILE все упоминающиеся в предложении USES модули должны быть предварительно откомпилированы и

результаты компиляции помещены в одноименные файлы с расширением TPU. Например, если в программе (модуле) имеется предложение

Uses Global;

то на диске в каталоге, объявленном опцией UNIT DIRECTORIES (см. прил.1), уже должен находиться файл GLOBAL.TPU. Файл с расширением TPU (от англ. Turbo Pascal Unit) создается автоматически в результате компиляции модуля (если основная программа может компилироваться без создания исполняемого ЕХЕ-файла, то компиляция модуля всегда приводит к созданию TPU-файла).

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

В режиме BUILD существующие TPU-файлы игнорируются, и система пытается отыскать (и компилировать) соответствующий РAS-файл для каждого объявленного в предложении USES модуля. После компиляции в режиме BUILD программист может быть уверен в том, что учтены все сделанные им изменения в любом из модулей.

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

косвенное обращение модуля к самому себе. Например, недопустимы следующие объявления:

Unit A;              Unit В; 

Interface            Interface

Uses В;              Uses А;

.......              .......

Implementation       Implementation 

.......              .......

end.                 end.

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

Unit A;              Unit В; 

Interface            Interface

.......              .......

Implementation       Implementation 

Uses B;              Uses A;

......               .......

end.                 end.

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

Модули

Структура модулей

Заголовок модуля и связь модулей друг с другом

Интерфейсная часть

Исполняемая часть

Инициирующая часть

Компиляция модулей

Доступ к объявленным в модуле объектам

Стандартные модули

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

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

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

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

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

Стандартные модули

В Турбо Паскале имеется восемь стандартных модулей, в которых содержится большое число разнообразных типов, констант, процедур и функций. Этими модулями являются SYSTEM, DOS, CRT, PRINTER, GRAPH, OVERLAY, TURBOS и GRAPH3. Модули GRAPH, TURBOS и GRAPHS выделены в отдельные TPU-файлы, а остальные входят в состав библиотечного файла TURBO.TPL. Лишь один модуль SYSTEM подключается к любой программе автоматически, все остальные становятся доступны только после указания их имен в списке, следующем за словом USES.

Ниже приводится краткая характеристика стандартных модулей. Полное описание входящих в них программных средств приведено в прил.4, а описанию объектно-ориентированной библиотеки Turbo Vision посвящена вся вторая часть книги.

Модуль SYSTEM. В него входят все процедуры и функции стандартного Паскаля, а также встроенные процедуры и функции, которые не вошли в другие стандартные модули (например, INC, DEC, GETDIR и т.п.). Как уже отмечалось, модуль SYSTEM подключается к любой программе независимо от того, объявлен ли он в предложении USES или нет, поэтому его глобальные константы, переменные и подпрограммы считаются встроенными в Турбо Паскаль.

Модуль PRINTER. Делает доступным вывод текстов на матричный принтер. В нем определяется файловая переменная LST типа TEXT, которая связывается с логическим устройством PRN. После подключения модуля может быть выполнена, например, такая программа:

Uses Printer; 

begin

writeln (LST, 'Турбо Паскаль') 

end.

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

Модуль GRAPH. Содержит обширный набор типов, констант, процедур и функций для управления графическим режимом работы экрана. С помощью подпрограмм, входящих в модуль GRAPH, можно создавать разнообразные графические изображения и выводить на экран текстовые надписи стандартными или разработанными программистом шрифтами. Подпрограммы модуля GRAPH после соответствующей настройки могут поддерживать различные типы аппаратных графических средств. Настройка на имеющиеся в распоряжении программиста технические средства графики осуществляется специальными программами - драйверами, которые не входят в файл GRAPH. TPU, но поставляются вместе с ним.

Модуль DOS. В модуле собраны процедуры и функции, открывающие доступ программам к средствам дисковой операционной системы MS- DOS.

Модуль OVERLAY. Он необходим при разработке громоздких программ с перекрытиями. Как уже говорилось, Турбо Паскаль обеспечивает создание программ, длина которых ограничивается лишь основной оперативной памятью ПК. Операционная система MS-DOS оставляет исполняемой программе около 580 Кбайт основной памяти (без учета резидентных программ и самой системы Турбо Паскаль). Память такого размера достаточна для большинства применений, тем не менее использование программ с перекрытиями (см. гл.11) снимает это ограничение.

Два библиотечных модуля TURBO3 и GRAPHS введены для совместимости с ранней версией 3.0 системы Турбо Паскаль.

Структура модулей

Модуль имеет следующую структуру:

UNIT <имя>; 

INTERFACE

<интерфейсная часть> 

IMPLEMENTATION

<исполняемая часть>

BEGIN

<инициирующая часть>

END.

Здесь UNIT - зарезервированное слово (единица); начинает заголовок модуля; <имя> - имя модуля (правильный идентификатор); INTERFACE - зарезервированное слово (интерфейс); начинает интерфейсную часть модуля;

IMPLEMENTATION - зарезервированное слово (выполнение); начинает исполняемую часть; 

BEGIN - зарезервированное слово; начинает инициирующую часть модуля;

конструкция BEGIN Инициирующая частъ> необязательна;

 END - зарезервированное слово - признак конца модуля.

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

Заголовок модуля и связь модулей друг с другом

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

Unit Global;

то исходный текст соответствующего модуля должен размещаться в дисковом файле GLOBAL.PAS. Имя модуля служит для его связи с другими модулями и основной программой. Эта связь устанавливается специальным предложением

USES <сп.модулей>

Здесь USES - зарезервированное слово {использует);

<сп.модулей> - список модулей, с которыми устанавливается связь; элементами списка являются имена модулей, отделяемые друг от друга запятыми, например:

Uses CRT, Graph, Global;

Если объявление USES... используется, оно должно открывать раздел описаний основной программы. Модули могут использовать другие модули. Предложение USES в модулях может следовать либо сразу за зарезервированным словом INTERFACE, либо сразу за словом IMPLEMENTATION, либо, наконец, и там, и там (т.е. допускаются два предложения USES).

---

---