Объявление файловой переменной и привязка к файлу на диске

Для того чтобы программа могла работать с текстовым файлом, нам потребуется переменная специального файлового типа text:

var f: text;

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

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

assign(TxtFile: text, name: string);

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

assign(f,'Z:\SCHOOL\text1.txt');

Чтение данных из файла

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

Чтобы открыть для чтения файл, который был указан при вызове assign, нужно использовать процедуру

reset(TxtFile: text);

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

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

read(TxtFile: text, v1: type1, v2: type2,... vN: typeN);

readln(TxtFile: text, v1: type1, v2: type2,... vN: typeN);

Первая процедура читает последовательно из файла значения и помещает их в переменные v1, v2,... vN. После каждого прочитанного значения указатель файла («читающая головка») смещается к началу следующего значения. Процедура readln делает то же самое, после чего перемещает указатель на начало следующей строки; readln с одним лишь первым параметром переводит указатель на начало новой строки.

 

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

1 -2 4

В этом случае два оператора Read(f,m); Read(f,n); поместят в целочисленные переменные m и n соответственно значений 1 и -2, а два оператора ReadLn(f,m);ReadLn(f,n); считают значения 1 и 4.

 

В качестве параметров для процедур read и readln можно использовать переменные следующих типов:

*  целые: integer, byte, shortint, word, longint;

*  вещественные: real, single, double, extended, comp;

*  строковые (string);

*  символьные (char).

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

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

Пример использования процедуры чтения:

var f: text; s: string; n: integer;

...

readln(f,n,s);

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

Довольно часто в программе бывает необходимо определить, дошёл ли указатель файла до конца строки или до конца файла. В этом случае полезно использовать такие функции:

eoln(TxtFile: text): boolean;

eof(TxtFile: text): boolean;

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

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

close(TxtFile: text);

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

 

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

program ShowFile;

var f: text;

c: char;

Begin

assign(f,'showfile.pas');

reset(f);

while not eof(f) do begin

while not eoln(f) do begin read(f,c); write(c); end;

readln(f);

writeln;

end;

close(f);

readln;

end.

Запись данных в файл

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

rewrite(TxtFile: text);

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

Для записи используются процедуры

write(TxtFile: text, p1: type1, p2: type2,... pN: typeN);

writeln(TxtFile: text, p1: type1, p2: type2,... pN: typeN);

Здесь в качестве параметров p1, p2,... pN можно использовать не только переменные, но и выражения: числовых типов, строковые, символьные и логические (boolean). В отличие от write, writeln после записи в файл значений p1, p2,... pN переводит указатель записи на начало новой строки; writeln с одним параметром (текстовый файл) лишь переводит указатель на новую строку.

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

 

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

program WriteLength;

var f1,f2: text;

s: string;

Begin

assign(f1,'writelen.pas'); reset(f1);

assign(f2,'result.txt'); rewrite(f2);

while not eof(f1) do begin

readln(f1,s);

writeln(f2,length(s));

end;

close(f1); close(f2);

end.

 

Ещё один способ записи — это открытие для добавления информации в конец файла. Для этого используется процедура

append(TxtFile: text);

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

 

Лекция 13. Двоичные файлы

Двоичный файл представляет собой последовательность одинаковых элементов, записанных на диске. В отличие от текстовых файлов, в двоичных нет разбиения на строки, файл напоминает массив, с той лишь разницей, что доступ к элементам может быть только последовательным. Для того, чтобы определить, достигнут ли конец файла, по-прежнему используется функция eof. Функция eoln, очевидно, здесь неприменима.

Для всех обсуждаемых ниже файлов можно выполнять те же процедуры открытия, закрытия и привязки, что и для текстовых: Append, Assign, Close, Reset, Rewrite. Кроме того, появляется процедура Truncate(var f: file), которая уничтожает всё содержимое файла, находящееся после текущего указателя чтения.

Двоичные файлы будем делить на типизированные и нетипизированные.

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

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

Описывают подобный файл словосочетанием file of с последующим указанием типа компонентов файла, число которых (длина файла) не фиксируется:

var имя файла: file of тип_компонентов;

В качестве типа элемента можно использовать как простые типы, так и структурированные (массивы, записи и т.п.).

Чтобы можно было работать с типизированным файлом, необходимо, как и для текстовых файлов, сначала связать имя файловой переменной с внешним именем файла (оператор Assign). Затем нужно открыть его (используются операторы Reset и Rewrite, но не Append). Операторы Reset и Rewrite открывают файл и для чтения, и для записи (а не только для чтения или только для записи, как при использовании текстовых файлов). Отличие их в том, что оператор Reset открывает только существующий файл (если такого файла нет, будет сгенерирована ошибка времени выполнения). С другой стороны, оператор Rewrite создает новый файл (если файл с таким именем уже имеется, то он будет уничтожен и создан заново). При открытии файла с ним связывается текущий указатель файла, который позиционируется на его первый элемент. Оперировать можно только тем элементом файла, на который ссылается указатель файла. При чтении или записи элемента файла происходит автоматическое перемещение указателя на следующий элемент. Чтение из типизированного файла производится оператором Read (но не ReadLn), а запись в него — оператором Write (но не WriteLn). Однако следует помнить, что в списке вывода оператора Write могут быть только переменные. Типы элементов файла и типы переменных в списках ввода-вывода должны быть согласуемы по присваиванию. Элементами типизированных файлов могут быть числовые, символьные, булевы, строковые значения, массивы, записи, но не файлы или структуры с файловыми элементами.

Узнать количество элементов типизированного файла (размер файла) можно с помощью функции FileSize, для которой используется следующий синтаксис: FileSize(имя_файла)

Например, если переменная k имеет тип LongInt, а f – файловая переменная типизированного файла, то оператор k:= FileSize(f), записывает в переменнуюk размер файла f.

 

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

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

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

var имя_файла: file;

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

Открываются файлы без типа теми же операторами Reset и Rewrite, но в этом случае имеется второй параметр — размер записи (элемента файла), заданный в байтах. Предварительно нужно с помощью оператора Assign связать внутреннее имя файла с внешним:

Assign(FileOneType, 'f.dat'); Reset(fileOneType, 1);

Второй параметр операторов Reset и Rewrite может быть опущен, что означает задание размера записи в 128 байт. Наибольшая скорость обмена данными обеспечивается при длине записи, кратной 512 байт (размеру сектора на диске).

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

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

BlockRead(var f: file; var buf; count: word [; var result: word]); – читает в переменную Buf count записей из файла, переменная result показывает сколько записей было скопировано в действительности. Под записью понимается «кусок» файла в несколько байт, размер записи можно установить при открытии файла, например: reset(f,1).

 

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

 

Запись данных в нетипизированный файл производится только после его открытия с помощью процедуры Rewrite. Для записи данных используется процедура BlockWrite, которая имеет те же три (или четыре) параметра, что и BlockRead.

BlockWrite(var f: file; var buf; count: word [; var result: word]); – записывает указанное количество записей в файл. Если для открытия используется rewrite, то во втором её параметре также можно указать размер записи.

 

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

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