1. Ввод-вывод данных и файловая система

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

Операция вывода данных означает пересылку данных из рабочей памяти (ОЗУ) в файл; а операция ввода - заполнение ячеек памяти данными, полученными из файла.

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

2. Понятие логического файла

Логический файл описывается как переменная одного из файловых типов, определенных в Турбо Паскале. После того, как в программе в разделе описания переменных объявлена файловая переменная, она может быть использована как средство общения с любым физическим файлом, независимо от природы последнего. Само имя физического файла может появиться в программе только один раз, когда специальной процедурой устанавливается, что объявленный логический файл будет служить средством доступа именно к этому физическому файлу (данным на диске, портам, печати и т.п.). Если, например, мы хотим работать с текстовым файлом `A:\text.doc', то в программе должны быть также строки:

Var

F: text; {объявляется файловая переменная f)

Begin

Assign (f,'A:\text.doc');

. . .

End.

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

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

3. Физические файлы

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

В Турбо Паскале имена могут быть строковыми константами или храниться в строковых переменных.

Имя файла на диске может иметь адресную часть, оформленную в соответствии с правилами

` C:\PAS\TESTFILE.PAS';

` A:\TEST.TXT';

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

Имя	Расшифровка устройства	Примечание
CON	Консоль (клавиатура и экран)	Ввод из CON - это чтение с клавиатуры, а вывод-это запись на экран
LPT1 LPT2 LPT3	Параллельные порты	Через эти имена файлов происходит вывод данных на принтеры или другие устройства
PRN	Принтер.(Синоним LPT1)	Имя обращения к принтеру
COM1 COM2	Последовательные порты	Имена файлов- устройств для ввода-вывода через серийные порты коммуникации
AUX	Синоним (COM1)	Файл - устройство COM1
NUL	Фиктивное устройство	Бездонный файл, принимающий что угодно, но всегда пустой

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

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

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

4. Понятие буфера ввода-вывода

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

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

5. Файловые типы Турбо Паскаля

Турбо Паскаль поддерживает три файловых типа:

- текстовые файлы (типа Text);

- компонентные файлы (типа File Of…);

- бестиповые файлы (типа File).

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

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

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

6. Общие процедуры и функции для работы с файлами

Процедура или функция	Действие
Assign (Var f; FileName: string)	Связывает файловую переменную f с именем физического файла, заданного в строке FileName
Reset (Var f)	Открывает файл с логическим именем f для чтения
Rewrite (Var f)	Открывает файл с логическим именем f для записи
Close (Var f)	Закрывает канал ввода-вывода файла с логическим именем f
Rename (Var f; NewName:string)	Переименовывает физический файл, ранее связанный с файловой переменной f, в имя NewName. Должна вызываться до открытия файла (применима лишь к закрытым файлам)
Erase (Var f)	Стирает (если это возможно) физический файл, связанный с файловой переменной f с носителя информации. Стираемый файл должен быть закрытым.
EOF (Var f): Boolean	Возвращает значение TRUE, если достигнут конец файла f, т. е. из него ничего уже нельзя прочитать или файл пуст. Иначе возвращается FALSE

6.1 Связывание файлов

Процедура Assign ( var f; FileName: String) устанавливает связь между логическим файлом, описываемым файловой переменной f любого файлового типа, и конкретным файлом, полное имя которого задано в строке FileName. Иными словами, логический файл f связывается с физическим файлом. Строка FileName может содержать имя файла на диске, имя стандартного устройства или пустую строку.

Assign (f, `file.dat');	{связь с файлом текущего каталога}
Assign (f, `a:\x.pas');	{связь с файлом x.pas на диске А:}
Assign (f, `LPT2');	{связь со вторым принтером }
Assign (f, `');	{связь со стандартным файлом, как правило файлом `COM'}

Имя физического файла должно быть корректным и уникальным. Нельзя вставлять символы шаблонов `*' и `?' в имя файла, но можно связывать файловые переменные с еще не существующими файлами на диске (для дальнейшего их создания).

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

Будучи однажды установленной, связь между файловой переменной f и физическим файлом сохраняется до следующего вызова Assign с той же переменной f. Это означает, что можно проделывать различные операции с файлом f, лишь единожды связав его с физическим файлом:

Assign(f, 'test.tmp');	{установлена связь}
Rewrite (f);	{открытие файла для перезаписи}
Write (f…);	{запись в файл f}
Close (f);	{закрытие файла (вызов необязателен)}
Reset (f);	{открытие файла для чтения}
Read (f…);	{чтение из файла f}
Close (f);	{закрытие файла (вызов обязателен)}
Erase (f);	{удаление файла с диска}

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

6.2 Открытие файлов

Процедура Reset(Var f) открывает логический файл f для последующего чтения данных или, как говорят, открывает входной файл. После успешного выполнения процедуры Reset файл готов к чтению из него первого элемента.

Процедура Rewrite (Var f) открывает логический файл f для последующей записи данных (открывает выходной файл). После успешного выполнения этой процедуры файл готов к записи в него первого элемента.

Эти же процедуры фиксируют размер буфера файла, который устанавливается автоматически, если только не был переопределен вызовом SetTextBuf для файлов типа Text или расширенной записью Reset/ Rewrite для бестиповых файлов.

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

6.3 Закрытие файлов

Процедура Close (var f) закрывает открытый до этого логический файл f. Попытка закрыть уже закрытый (или ещё не открытый) файл вызовет сбой программы. Процедура не изменяет связь между файловой переменной f и физическим файлом, но назначает им текущее состояние «закрыт». Это особенно важно для файлов, открытых для записи. Закрытие файла гарантирует сохранность и полноту заполнения. Фатальная ошибка в программе уже не сможет повлиять на содержимое файла после его закрытия.

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

Вызовы процедуры Close необходимы при завершении работы с файлами. Необходимо также закрывать файлы перед их удалением (Erase) или переименованием (Rename).

6.4 Переименование файла

Процедура Rename(Var f; NewName: string) позволяет переименовать физический файл на диске, связанный с логическим файлом f. Процедура выполнима только с закрытым файлом, в противном случае возникнет сбой.

Файловая переменная f должна быть предварительно связана вызовом процедуры Assign с некоторым физическим файлом, например FileName. Вызов Rename(Var f; NewName) сменит имя физического файла с FileName на NewName.

Например:

Var f: file of real; Begin
Assign (f, `a:\real.dat');	{установлена связь}
Rewrite (f);	{открытие файла для записи}
Write (f…);	{запись в файл f}
Close (f);	{обязательно закрытие файла}
(Пусть теперь надо сменить имя файла)
Rename (f,' a:\float.dat');	{готово}

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

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

6.5 Удаление файлов

Процедура Erase(Var f) уничтожает (стирает) физический файл на носителе (диске). Файловая переменная f должна быть предварительно связана с существующим физическим файлом. Сам файл к моменту вызова Erase должен быть закрыт.

Для уничтожения файла с именем FileName, достаточно конструкции

Assign (f, FileName);

Erase (f);

где f- файловая переменная любого типа.

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

6.6 Анализ состояния файла

Логическая функция EOF(Var f): Boolean возвращает значение true, когда при чтении достигнут конец файла f. Это означает, что уже прочитан последний элемент в файле или файл f после открытия оказался пуст. Во всех остальных случаях функция возвращает значение false. Состояние EOF обновляется автоматически при каждом обращении к процедуре ввода данных. Файл f должен быть открыт.

Обращение к EOF без указания файла соответствует анализу конца стандартного файла Input (как правило, связанного с клавиатурой). Стандартный файл считается текстовым, и конец файла в нем обозначен символом #26 (в прочих, нетекстовых файлах, явного обозначения конца файла не существует).

Назначение функции EOF- указывать на возникновение конца файла. Наиболее часто EOF используется в цикле while, читающем файл до конца:



While not EOF (f) do	{пока не достигнут конец файла f}
Read (f…);	{читать данные из этого файла}

Эта конструкция гарантирует, что чтение прекратится только после считывания последнего элемента в файле с логическим именем f. Используется именно цикл while…do, а не repeat…until ,т.к. функция EOF постоянно следит за статусом чтения и позволяет опознать конец файла до того, как он непосредственно будет прочитан.

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

Текстовые файлы - это файлы, в которых:

- информация представляется в текстовом виде посредством символов в коде ASCII;

- порции информации могут разделяться на строки. Признаком конца строки служит символ #13(код 13 - CR). Он может быть объединен с символом перевода строки #10(код 10- LR);

- конец файла обозначается явно символом ^Z (код 26);

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

- при чтении чисел и строк они автоматически преобразуются из текстового представления в машинное.

Если файл можно вывести на экран в текстовом режиме и прочитать его, то это- текст. Клавиатура посылает в компьютер «сплошной» текст- файл. Компьютер посылает на принтер текст- файл, даже если принтер рисует в графическом режиме. Рассмотрим небольшой текст-файл:

[13][10]

Вы читаете текстовый файл, который [13][10]

может храниться на диске или печататься [13][10]

на принтере. [13][10]

В нем можно хранить цифровые записи чисел: [13][10]

123 456 789 0 [13][10]

234 567 890 1 [13][10]

1.2 3.4 5.60 4 [13][10]

-100.254 [13][10]

Конец файла [13][10]

[26]

Цифры в квадратных скобках - управляющие коды с тем же номером, т.е. [13]= #13.

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

Var

f : text;

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

В системной библиотеке Турбо - Паскаля определены две текст - файловые переменные: Input и OutPut. Они связаны с устройством `CON'( или фиктивным устройством CRT, если подключен модуль CRT) автоматически.

8. Текст-ориентированные процедуры и функции

Процедуры и функции	Действие
SetTextBuf (Var f: Text; Var Buf [; BufSize: word]	Устанавливает размер буфера файла f равным BufSize байт. Должна выполняться перед открытием файла f. Буфер размещается в переменной Buf
Append (Var f: text)	Открывает текстовый файл f для дозаписи в конец файла
Flush (Var f: text)	Выводит текущее содержимое буфера файла f в физический файл, не дожидаясь заполнения буфера до конца. Имеет смысл при записи в файл
EOLn (Var f: text): Boolean	Функция возвращает TRUE, если текущая позиция в файле - конец строки или конец файла, и FALSE, если нет
SeekEOLn (Var f: text): Boolean	Функция возвращает TRUE, если достигнут конец строки или конец файла, или перед ними стоят лишь пробелы и (или) символы табуляции(#9)
SeekEOF (Var f: text): Boolean	Функция возвращает TRUE, если достигнут конец файла, или перед ними стоят лишь пробелы, признаки концов строк и (или) символы табуляции(#9)

8.1 Процедура SetTextBuf ( VAR f: Text; VAR Buf [; BufSize: Word])

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

При задании нового буфера, необходимо передать процедуре SetTextBuf не только логический файл f, но и переменную Buf, в которой этот буфер расположится. Это означает, что придётся ввести ещё одну переменную соответствующего размера. Тип переменной Buf не имеет значения, важен её размер. Буфер файла начнётся с первого байта, отведённого Buf, и займёт столько байт, сколько задано в необязательном параметре BufSize. Если в вызове процедуры число BufSize не указано, то считается, что оно равно размеру переменной Buf. Задание BufSize больше, чем размер самой Buf, приведёт к потере данных, «соседних» по памяти с Buf.

Рассмотрим вариант использования SetTextBuf

Var
Ft: text;	{текстовый логический файл}
Buf: array [1..4*1024] of byte;	{его новый буфер}
Begin
Assign (Ft,'textfile.doc);	{файл связывается с диском}
SetTextBuf (ft, Buf);	{меняется буфер (теперь он в переменной)}
	{размером 4 К)}
Reset (Ft);	{открытие файла}
Read (Ft...);	{операции ввода-вывода}
Reset (Ft);	{возврат в самое начало файла}
	{прочие действия с файлом Ft}
End.

Будучи однажды установленным для файла ft, буфер не меняет своего места и (или) размера до следующего вызова SetTextBuf или Assign с той же файловой переменной ft.

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

Procedure GetFileAndOpenIt(Var f : text);

Var

Buffer: array [1..16*1024] of byte; его новый буфер

FileName: string;

Begin

Readln(FileName)

Assign(f,FileName); файл связывается с диском

SetTextBuf (ft, buffer);

Rewrite(f);

End;

Var

ft: text;

Begin

GetFileAndOpenIt(ft);

Write (ft...); попытка записи в файл

Дальше неважно, что будет. Все равно результат уже неверный

End.

Дело в том, что локальная переменная Buffer (а именно в ней мы размещаем буфер открываемого файла) существует лишь во время выполнения процедуры. После окончания она исчезает, область буфера становится общедоступной и наверняка очень быстро заполнится совершенно «посторонними» значениями, а переданный в вызывающий блок файл f (ff) будет вести себя непредсказуемо. При всём этом не возникнет ни ошибки компиляции, ни ошибки во время счёта.

Если размещать буфер в статической переменной, то он «съедает» часть области данных или стека. А они ограничены размером 64К, что вовсе не так много. Выгоднее было бы размещать буфер в динамической памяти (куче)

Var
ft : text;	{файл типа текст}
PBuf: Pointer;	{ссылка на буфер}
Const
BufSize=1024;	{размер буфера}
Begin
Assign (ft,'textfile.doc');
GetMem ( PBuf,BufSize);	{в памяти отводится блок памяти размером с буфер}
SetTextBuf (ft,PBuf^,BufSize);	{задается буфер в динамической памяти}
Reset (ft);	{открытие файла}
..........	{работа с файлом ft}
Close (ft);
FreeMem(PBuf,BufSize);	{буфер удаляется из памяти}
End.

В этом случае нужно отводить и освобождать память под буфер, а в SetTextBuf обязательно указывать его размер, так как блок памяти с началом в P Buf€ «не знает» своего размера.

Размер буфера выбирается кратным 512 байт. Диск читается по секторам и дорожкам, и длина считываемой в одном месте порции информации колеблется от 512 до 4096 байт для гибких и жёстких дисков.

8.2 Процедура Append( VAR f: Text)

Эта процедура служит для специального открытия файлов для записи. Она применима только к уже существующим физическим файлам и открывает их для дозаписи, т.е. файл не стирается, как при вызове Rewrite, а подготавливается к записи элемента в конец файла. Если Append применяется к несуществующему файлу, то возникнет ошибка времени счета. Новый файл может быть создан только процедурой Rewrite.

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

8.3 Процедура Flush ( VAR f : Text)

Эта процедура применяется к файлам, открытым для записи (процедурами Rewrite или Append). Данные для записи накапливаются в буфере файла и только после полного его заполнения записываются в физический файл. Процедура Flush принудительно записывает данные из буфера и файл независимо от степени его заполнения. Когда буфер имеет большую емкость, его содержимое может не попасть в физический файл, если программа внезапно прервется в процессе счета. Этого можно избежать, если перед «аварийными» частями программы ставить вызовы Flush.

Процедура Flush не закрывает файл и не влияет на последовательность вывода. Flush может найти применение при работе со стандартными файлами MS-DOS: устройствами AUX, или COM1, COM2...PRN, или LPT1...LPT3. При работе с ними данным незачем «отстаиваться » в буфере, и процедура Flush, поставленная после Write, снимет эффект задержки буфера файла.

8.4 Функция EOLn ( var f : Text) : Boolean

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

«End-Of-Line» -- конец строки. EOLn возвращает значение True, если следующей операцией будет прочитан признак конца строки (символ #13) или конца файла (символ #26) и False во всех прочих случаях. Функция как бы предчувствует результат предстоящего чтения и анализирует его. Необходимость в EOLn (f ) возникает всякий раз, когда заранее не известно, где встретится конец строки. Пусть у нас имеется файл со столбцами цифр (рис. 12.5).12.3 17.8 55.5 [26]	13.2 -7.6 6.06	14.4 100 7.8	5.7 456 0.00	126.0 [13] [10] 987.6 [13] [10] 10.11 [13] [10]

С помощью EOLn можно автоматически определить число столбцов в нем и наладить чтение

Var
f : Text;	{логический текстовый файл }
Ncol: Byte;	{счетчик числа столбцов}
R: Real;	{число для чтения из файла}
BEGIN
Assign (f, `DIGITS.DAT');	{связывание файлов}
Reset (f);	{открытие f для чтения}
Ncol: = 0;	{стартовое значение Ncol}
while NOT EOLn(r) do begin	{ Цикл до конца строки: }
Read (f, R );	{ чтение вправо по строке}
Inc (Ncol )	{ увеличение счетчика столбцов }
end; {while}	{ конец цикла счета столбцов }
Reset( f );	{возврат на 1-ю позицию в файле}
{ ... и повторение чтения, уже зная число столбцов }
END.

Существует разновидность функции EOLn без параметров. В этом случае считается, что действие функции относится к стандартному файлу Input, т.е. вводу с клавиатуры. Здесь функция EOLn возвращает True не перед, а после прохождения признака конца строки: сразу после нажатия клавиши ввода. Более того, EOLn без параметра не дает значения False,а «подвешивает» программу и возвращает управление следующему оператору только после нажатия ввода, т. е. способ организации паузы до нажатия ввода следующий

WriteLn (EOLn);

8.5 Функция SeekEOLn ( VAR f: Text): Boolean.

Эта функция является ближайшей родственницей» функции EOLn(f). Файл f должен быть текстовым и открытым для чтения. Функция возвращает значение True, если до конца строки (символ #13) или, конца файла (символ #26) могут быть считаны только пробелы и(или) символы табуляции (символ #9). Значение True также вернется,если текущее положение в файле непосредственно предшествует символам #13 или #26. Другими словами, SeekEOLn всегда вернет True , если EOLn на ее месте вернет True. Но в отличие от EOLn функция SeekEOLn как бы «видит» конец строки (или файла) через пробелы и знаки табуляции.

SeekEOLn ориентирована, главным образом, на работу с текстовыми файлами чисел. Последний пример из описания EOLn можно было бы переписать, заменив EOLn на SeekEOLn. От этого он заработал бы только лучше. Действительно, чтобы EOLn вернула True,нужно «упереться» в признак конца. А для этого надо убедиться, что «пустопорожние» пробелы после последнего числа в строке не являются числами: съедается время. SeekEOLn же игнорирует все пробелы и табуляции и «видит» конец издалека, ускоряя обработку.

8.6 Функция SeekEOF(VAR : Text) : Boolean

Эта функция замыкает ряд функций, начатый EOLn и SeekEOLn. Если отнять у SeekEOLn способность реагировать на признак конца строки, то получится функция SeekEOF, которая возвращает True, пли только следующий за текущим положением символ -- конец файла (#26), или если перед концом файла имеются только пробелы и(или) символы табуляции (#9), и(или) признаки конца строки (#13). Короче говоря, символы #9, #13, #32 (пробел) для SeekEOF являются «прозрачными», и если сквозь них «виден» конец файла # 26, то функция возвращает значение True. Во всех прочих случаях вернется значение False.

Функция позволяет найти смысловой конец файла, а не физический. Это полезно при работе с числами (реже с символами). Так, цикл чтения из файла f

while not EOF( f ) do Read( f, ... );

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

while not SeekEOF( f ) do Read( f,… );

он станет работать более эффективно.

Как и SeekEOLn, функция SeekEOF применима только к открытым для чтения текстовым файлам.

9. Операции ввода-вывода в текстовые файлы

Ввод и вывод числовой и текстовой информации в Турбо Паскале осуществляется операторами:

ввод - Read(f, Х ) или Read(f, X1,X2,...,Xn ) и

ReadLn(f, Х ) или ReadLn ( f, X1,X2,...,Xn );

вывод - Write(f, Х ) или Write(f, X1,X2,...,Xn ) и

WriteLn(f, Х ) или WriteLn(f, Х1,Х2,...,Хn ).

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

Если операторы содержат один лишь список ввода-вывода, то считается, что ввод сопряжен со стандартным логическим файлом Input (под ним подразумевается клавиатура с «эхом» ввода на экране), а вывод - с логическим файлом Output (что соответствует выводу на экран дисплея).

Имена Input и Output являются предопределенными в системной библиотеке (модуле System). В стандартном Паскале любая программа, использующая ввод-вывод, должна начинаться со слов PROGRAM имя (Input, Output); что, по сути, открывает каналы ввода-вывода. В Турбо Паскале можно опускать описание PROGRAM и не надо описывать имена Input и Output.

Таким образом, оператор Read(x1, x2) полностью эквивалентен оператору Read(Input, x1, x2), а оператор Write (х3, х4) - оператору Write (Output, х3, х4 ).

9.1 Операторы Read/ReadLn

Рассмотрим сначала операторы ввода информации - Read и ReadLn. Их аргументами должен быть список переменных, значения которых будут считаны (введены). Тип переменных при вводе из текстового файла (в том числе и с клавиатуры) может быть только целым, вещественным, символьным(Char), строковым или совместимыми с ними. Сложные структурированные типы (такие, как массивы, множества, записи и др.) могут быть введены только по элементам (по полям для записей).

Например:

Var i : word; l : longint; r : real;
Rec : record; х, у : Real; i : Char END;	{ запись }
Dim: Array [0...99] of Byte; S: string; { . . . ЧИТАЮТСЯ С КЛАВИАТУРЫ: . . . }	{массив}
read(I, l);	{ два целых числа}
read(l, r, s);	{ целое, вещественное число и строка}
read(Rec.x, Rec.y, Rec.ch );	{ запись по полям}
for i:= 0 to 99 do Read( Dim[i] );	{ввод массива}
End.

Всякие попытки вставить «сокращения» типа Read(Rec) или Read(Dim[i]) вызовут понятное возмущение компилятора. Такое возможно лишь при вводе из типизированного файла. При вводе из текстового файла, будь то файл на диске или клавиатура, необходимо помнить правила чтения значений переменных. Когда вводятся числовые значения, два числа считаются разделенными, если между ними есть хотя бы один пробел, или символ(ы) табуляции (#9), или символ(ы) конца строки (#13). Так, при выполнении оператора Read(i, r ) можно ввести значения с клавиатуры несколькими способами:

123 1.23 [Клавиша ввода]

ИЛИ

123 [Клавиша ввода] 1.23 [Клавиша ввода]

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

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

VAR

сh1, ch2: Char;

…

Read (ch1, ch2 );

В этом случае надо не спешить нажать клавишу ввода на клавиатуре:

аб[ВВОД] --> ch1 = 'а' , ch2 = 'б'

а [ВВОД] б [ВВОД] --> ch1 = 'а' , ch2 = #13

[ВВОД] [ВВОД] --> ch1 = #13 , ch2 = #13

И, наконец, ввод строк. Начало строки идет сразу за последним введенным до этого символом (с первой позиции, если соответствующая строчная переменная стоит первой в списке ввода). Считывается количество символов, равное объявленной длине строки. Но если во время считывания попался символ #13, то чтение строки прекращается. Сам символ #13 (конец строки) служит разделителем строк и в переменную никогда не считывается.

Рассмотрим пример комплексного списка ввода:

Read (realVar, intVar, Ch, String11, String88).

При вводе последовательность символов будет разбита на разнотипные части следующим образом [# 13] обозначает один символ с кодом 13:

игнорируется

-1.234Е-5	+12930		abcdefghiJk	FGTH [13] …
realVar	intUar	Сh	String 11	String88

Символьная переменная Ch здесь может заполучить себе только пробел (или #13 и #9), иначе, если следом сразу начнется строка, произойдет сбой при чтении целого значения! Строка String88 будет заполнена не целиком, а на ту часть, которая успела считаться до символа #13 (нажатия клавиши ввода или конца строки в файле).

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

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

При вводе с клавиатуры («с экрана») особой разницы между Read и ReadLn нет. Процедура ReadLn (Read Line) считывает значения > , в текущей строке и переводит позицию на начало следующей строки,даже если в текущей строке остались непрочитанные данные.

Так, при чтении в текстовом файле f строки: 12.3 13.4 14.5 15.6 оператором ReadLn (f, r1, r2) вещественные переменные r1 и r2 получат значения 12.3 и 13.4, после чего произойдет переход на другую строку, и следующие два числа (14.5 и 15.6) будут проигнорированы. Вызов ReadLn (f) вообще пропустит строку в файле f. Вызов ReadLn без указания файла сделает паузу до нажатия клавиши ввода.

Символ-признак конца текста #26 также является разделителем и ограничивает строку, но за ним чтение уже невозможно. Файл на нем кончается. Конец файла может быть считан в символьную переменную, в строчную он не войдет (как не входит символ #13), а чтение #26 вместо ожидаемых числовых значений эквивалентно прочтению 0.

9.2 Операторы Write/WriteLn

Операторы Write и WriteLn выводят значение Х или список значений XI, Х2,..., Хn в текстовый файл f. Если файл не указан, то считается, что вывод направлен в файл Output (на дисплей). Значения, как и при вводе, могут иметь лишь целые, вещественные, символьные и строковые типы, а также производные от них. Всевозможные структуры (записи, массивы) должны выводится по их полям или элементам. Множества, указатели (Pointer), файловые переменные также не могут быть выведены без предварительного их преобразования в выводимые составляющие. Исключение составляет лишь тип Boolean:

CONST

tr : Boolean = True;

fа : Boolean = False;

…

Write( tr, '...', fa );

Оператор Write напечатает на экране: 'TRUE ... FALSE '. Прочитать эти значения из файла в том же виде невозможно. Чтобы получить из файла логическое значение, необходимо закодировать его байтом:

0 = False

1 = True

и считайте в байтовую переменную, а затем преобразуйте в логическое значение:

VAR
by : Byte;	{байтовое значение }
boo : Boolean absolute by;	{ логическое значение }
…
Read( by );	{ вводится значение-байт 0 или 1 }
if boo then ... ;	{и считается логическим значением }

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

Процедура WriteLn (Write Line) выводит именно строку данных и закрывает ее: приписывает символ #13 в ее конец (точнее, символы #13 и #10, но последний как бы «сливается» с основным кодом). Это автоматически открывает следующую строку, а на экране возвращает курсор в крайнюю левую позицию и опускает его на строку вниз.

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

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

Write (RealVar, ' номер ', intVar, #10#10'сумма=`);

WriteLn (RealVar+IntVar, '+', Cos(5*5) );

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

9.3 Форматы вывода данных

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

Write (Ch: 2, St: 20 );

Это число показывает, сколько позиций отводится под значение. Так, значение Ch (символ) будет размещено в двух позициях, хотя реально займет лишь одну, а строка St - в 20 позициях. Если реальное значение «короче» формата, излишек будет заполнен пробелами. Но если наоборот (формат «мал»), то значение будет выводиться, игнорируя спецификацию. Ошибки при этом не возникает. Выравнивание значения в поле формата здесь происходит по правому краю. На этом можно сыграть следующим образом. Часто надо выводить значения с середины строки. При выводе на экран можно использовать специальную процедуру из модуля CRT для установки курсора, но при выводе в файл на диске это работать не будет А как передвинуть значение? Решение очевидно:

Write (' ', ChapterNameStr );

Но так же очевидно, что это неэффективно (в программе будет попусту «болтаться» столько пробелов!). Разумное решение таково:

Write ( ' ' : 25, ChapterNameStr );

Один пробел, но в поле из 25 символов. Эффект будет тот же. Можно даже выкинуть пробел и поставить пустую строку ".

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

Формат целочисленных значений задается размером поля за значением:

Write (intVar: 5, 123:4, (6*8):10 );

Целое число, включая знак минус, если нужен, будет размещено в заданном числе позиций и выровнено по правому краю. Излишки исполнятся пробелами, а если формата не хватит, то он игнорируется. Формат удобно использовать для вывода таблиц. Пусть надо красиво вывести 10 столбцов целых значений в 80 колонок экрана. Для этого можно задать формат

WriteLn (х1: 7, х2: 7, х3: 7.... х10: 7);

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

Write (RealVar: 12 : 3, 123.456 : 8 : 1 );

Реальная длина числа равна сумме одной позиции под знак, числа знаков до десятичной точки, одной позиции под точку и значения второго параметра формата. Поэтому бессмысленны форматы типа ':4:3'. В примере переменная RealVar на экране будет иметь три знака после точки, и если полная ее длина не превысит двенадцать позиций, то она будет выровнена по правому краю. Оставшееся место будет пусто. При некорректном задании формата игнорируется только первый его параметр, а число знаков после точки устанавливается всегда корректно, но не превышает точности типа.

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

Можно выводить вещественные числа без дробной части. Для этого следует задать второй параметр равным 0:

Write (123.456 : 6 : 0 ); { ' 123' }

При необходимости вывода вещественных значений в экспоненциальном формате надо задавать вновь только одно поле. Это поле указывает число позиций, в которых надо разместить число. Само число будет иметь вид -5.5678Е+00 или 0.0012Е-20. При задании подобного формата надо учесть место под знак числа, одну цифру до точки, саму точку, хотя бы одну цифру после точки, и четыре знака под степень - всего восемь позиций.

При формате, меньшим, чем восемь позиций, он устанавливается автоматически равным восьми:

Write (123.456 : 8, ' ', 123.456 : 6); {одно и то же}

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

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

Var

F, n: Shortint;

Begin

F:=8; n: =3;

WriteLn (123.456 : F: n);

End.

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

Короткое число в формате 10 = 12

Длинное число в формате 10 = 12345678

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

Короткое число в формате-10 = 12

Длинное число в формате-10 = 12345678

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

Write (123.456 : 6 : 1, 22 : 4 ); { ' 123.5' и ' 22' }

Write (123.456: -6: 1, 22: -4); { '123.5' и '22' }

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

9.4 Типизированные файлы и операции ввода-вывода

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

File of Тип компонента,

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

TYPE

DimComp = Array [1..100,1..2] of Real;

RecComp = RECORD

X., Y: Byte;

A: DimComp

END;

DimFile = File of DimComp;

RecFile = File of RecComp;

IntFile = File of Integer;

Но компилятор не пропустит такие типы:

TYPE

FlleFilel = File of File of Real; {неверно: файл файлов}

FlleFile2 = File of DimFile; {неверно: файл файлов}

FRecComp = RECORD

X, Y: Byte;

F: File of Char

END;

FRecFile = File of FRecComp; {нельзя: файл в компоненте!}

ObjComp = OBJECT

…

END;

ObjFile = File of ObjComp; {неверно: файл объектов}

При написании программ необязательно определять специальные файловые типы. Это можно сделать «на ходу» при описании переменных:

VAR

FR: File of Real;

FD: File of DimComp;

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

Assign (FR. `RFILE.DAT'); Reset (FR);

Assign (FD, `DFILE.DAT'); Rewrite (FD);

Для типизированных файлов обе процедуры Reset и Rewrite устанавливают режим «чтение/запись» в соответствии со значением предопределенной системной переменной FileMode (оно по умолчанию равно 2), т.е. независимо от выбора процедуры открытия, файл открывается и для чтения, и для записи. Это верно только для типизированных и бестиповых файлов, но ни в коем случае, не для текстовых. Этот порядок нарушится только в том случае, когда значение FileMode соответствует режиму «только запись» (1) или только чтение» (0). Сменить режим можно простым присваиванием нужного значения переменной FileMode перед открытием файла. После этого вызов Reset будет открывать файл в заданном режиме, даже если он будет «только запись»! Процедура Rewrite также должна «слушаться» указаний FileMode, но только в том случае, когда файл уже существует. Для новых файлов Rewrite всегда включает режим «чтение/запись».

После открытия файла ввод и вывод данных осуществляется стандартными операторами

Read (f, x) и Write (f, x)

или

Read (f, x1, x2, x3...xn) и Write (f, х1, х2, х3… хn).

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

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

VAR

f : File of String[80];

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

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

Для специальных целей (например, написания программ перекодировки текстов) можно трактовать текстовые файлы как File of Char. Это, разумеется, не оживит работу процедур ReadLn/WriteLn и функции EOLn, работающей с текстами, но при соблюдении неприкосновенности и неизменности кодов конца строки и конца файла (символ #26), даст возможность побуквенного чтения, изменения и последующей записи в другой File of Char исходного текста.

PROGRAM Decode_Text;
VAR
fin, fOut : File of Char;	{файлы для чтения и записи}
Ch: Char;	{обрабатываемый символ}
FUNCTION DecodeChar(С : Char ) : Char	{Функция должна возвращать символ, получающийся перекодировкой из С. } BEGIN { . . . } END;
BEGIN
Assign (fin, 'C:\DOC\DOCUM.A');
Reset (fin);
Assign (fOut, 'C:\DOC\DOCUM.B');
Rewrite (fOut);
Ch: =' `;	{очистка Ch}
while Ch 0 #26 do	{цикл до конца ТЕКСТОВОГО файла:}
Begin
Read (fin, Ch);	{читается символ}
Write( fOut, DecodeChar(Ch) )	{ запись замены }
end; {while}	{ конец цикла )
Close (fin); Closet fOut)	{закрытие файлов}
END.

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

TYPE dim100x20 = Array [1.. 100,1. .20] of Real; VAR XX, YY: dim100x20; fin, Fout : File of dim100x20; Begin
...	{открытие файлов fin и fOut}
Read (fin, XX );	{считывается сразу весь массив}
...	{ обрабатываются массивы }
Write (fOut, YY );	{записывается весь массив сразу}
...	{ среди прочего - закрытие файлов}
End.

В то же время эти файлы неоптимальны для хранения строк (лучше использовать Text-файлы) и имеют сложное внутреннее представление

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

9.5 Бестиповые файлы и операции ввода-вывода

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

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

Ввод-вывод в бестиповые файлы осуществляется специальными процедурами BlockRead и BlockWrite. Кроме того, расширяется синтаксис процедур Reset и Rewrite. В остальном принципы работы остаются такими же, как и с типизированными файлами. Перед использованием файловая переменная f (логический файл)

VAR

f : File;

должна быть связана с конкретным физическим файлом через вызов оператора Assign. Далее файл должен быть открыт для чтения или записи с помощью вызова процедуры Reset ( f ) или Rewrite ( f ) соответственно. После окончания работы файл должен быть закрыт процедурой Close ( f ).

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

Reset (VAR f: File; BufSize: Word) и

Rewrite (VAR f: File; BufSize: Word) .

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