Бинарные файлы
Бинарные файлы хранят информацию в том виде, в каком она представлена в памяти компьютера, и потому неудобны для человека. Заглянув в такой файл, невозможно понять, что в нем записано; его нельзя создавать или исправлять вручную - в каком-нибудь текстовом редакторе - и т.п. Однако все эти неудобства компенсируются скоростью работы с данными.
Кроме того, текстовые файлы относятся к структурам последовательного доступа, а бинарные - прямого. Это означает, что в любой момент времени можно обратиться к любому, а не только к текущему элементу бинарного файла.
Доступ к полям
Обратиться к полю записи можно следующим способом:
<имя_записи>.<имя_поля>
Например:
month:= my_birthday.month +1;
Как уже было упомянуто, коллизий между переменной с именем month и полем записи my_birthday.month не возникает.
Доступ к полю двумерной таблицы осуществляется аналогичным образом (жирные скобки являются обязательным элементом синтаксиса):
<имя_таблицы>[<индекс>].<имя_поля>
Эту запись можно трактовать так:
(<имя_таблицы>[<индекс>]).<имя_поля>
Например:
birthdays[mother].day := 9;
Механизм использования записи с вариантной частью
Количество байтов, выделяемых компилятором под запись с вариантной частью, определяется самым "длинным" ее вариантом. Более "короткие" наборы полей из других вариантов занимают лишь некоторую часть выделяемой памяти.
В приведенном выше примере самым "длинным" является вариант 'b': для него требуется 23 байта (21 байт для строки и 2 байта для целого числа). Для вариантов 'n' и 'm' требуется 4 и 5 байт соответственно (см. таблицу).
| name, publisher | item | Вариантная часть | ||||||||||||||||||||
| ... | 'b' | author | year | |||||||||||||||||||
| ... | 'n' | data | ||||||||||||||||||||
| ... | 'm' | year | month | number | ||||||||||||||||||
| ... | 'b' | author | year | |||||||||||||||||||
Назначение нетипизированного файла
Содержимое этого раздела дословно повторяет все сказанное в разделе "Назначение типизированного файла".
Назначение типизированного файла
С этого момента и до конца раздела под словом "файл" мы будем подразумевать "бинарный типизированный файл" (разумеется, если специально не оговорено иное).
Команда assign(f,'<имя_файла>'); служит для установления связи между файловой переменной f и именем того файла, за работу с которым эта переменная будет отвечать.
Строка '<имя_файла>' может содержать полный путь к файлу. Если путь не указан, файл считается расположенным в той же директории, что и исполняемый модуль программы.
Нетипизированные файлы
Главное преимущество нетипизированных файлов - это высокая скорость их обработки. Открыть как нетипизированный можно и файл любой другой природы: текстовый или бинарный типизированный. В основном это применяется в тех случаях, когда нужно перекопировать довольно большой кусок одного файла в другой без изменений.
Оперирование несколькими полями
Если программе предстоит несколько раз подряд обращаться к полям одной и той же записи, может оказаться неудобным записывать это обращение полностью:
my_birthday.day:= 17; my_birthday.month:= 3; my_birthday.year:= 2004;
Для сокращения таких участков служит оператор with, позволяющий обращаться к полям, не указывая каждый раз имя всей записи:
with <имя_записи> do begin <операторы> {имена полей здесь используются как <имя_поля>, а не как <имя_записи>.<имя_поля>} end;
Например:
with my_birthday do begin day:= 17; month:= 3; year:= 2004; end;
Замечание. Для того чтобы внутри оператора with можно было обратиться не к полю записи, а к глобальной переменной с таким же именем, перед этой переменной нужно указать (через точку) имя программы: <имя_программы>.<имя_переменной>.
Например:
with my_birthday do begin day:= 17; month:= 3; {поле записи birthday.month} year:= 2004; programma.month:= 5; {глобальная переменная month} end;
Описание нетипизированных файлов
В разделе var файловые переменные, предназначенные для работы с нетипизированными файлами, описываются следующим образом:
var g: file;
Никакая файловая переменная не может быть задана константой.
Описание типизированных файлов
В разделе var файловые переменные, предназначенные для работы с типизированными файлами, описываются следующим образом:
var <файловая_перем>: file of <тип_элементов_файла>;
Никакая файловая переменная не может быть задана константой.
Описание записей
В разделе var переменную типа запись описывают так:
var <имя_записи>: record <имя_поля1>: <тип_поля1>; [<имя_поля2>: <тип_поля2>;] [...] end;
Имена полей должны подчиняться общим правилам построения идентификаторов. Повторение имен полей внутри одной записи не допускается.
Замечание: Имена полей могут совпадать с именами других переменных, поскольку на самом деле являются составными:
<имя_записи>.<имя_поля>.
Поэтому можно записать:
var x: real; r: record x: real; y: real end;
Поля могут относиться к любым стандартным (базовым или сконструированным) или определенным ранее типам, даже к файловому или процедурному (см. лекцию 8).
Если несколько подряд идущих полей принадлежат к одному типу данных, их описания можно объединить:
var <имя_записи>: record <имя_поля1>,_,<имя_поляN>: <тип_полей>; <имя_поляS>: <тип_поляS>; ... end;
Например:
var zap1: record x,y: real; i,j,k: integer; flag: boolean; s: set of 'a'..'z'; a: array[1..100] of byte; data: record day:1..31; month: 1..12; year: 1900..2100; end; end;
Эта запись содержит 9 полей, три из которых сами являются составными.
Наиболее распространенный способ использования записей - двумерная таблица, каждый столбец которой имеет свой тип. Такую структуру описывают, например, следующим образом:
var tabl: array[1..100] of zap1;
Описание записи с вариантной частью
В разделе var запись с вариантной частью описывают так:
var <имя_записи>: record <поле1>: <тип1>; [<поле2>: <тип2>;] [...] case <поле_переключатель>: <тип> of <варианты1>: (<поле3>: <тип3>; <поле4>: <тип4>; ...); <варианты2>: (<поле5>: <тип5>; <поле6>: <тип6>; ...); [...] end;
Невариантная часть записи (до ключевого слова case) подчиняется тем же правилам, что и обычная запись. Вообще говоря, невариантная часть может и вовсе отсутствовать.
Вариантная часть начинается зарезервированным словом case, после которого указывается то поле записи, которое в дальнейшем будет служить переключателем. Как и в случае обычного оператора case, переключатель обязан принадлежать к одному из перечислимых типов данных (см. лекцию 3). Список вариантов может быть константой, диапазоном или объединением нескольких констант или диапазонов. Набор полей, которые должны быть включены в структуру записи, если выполнился соответствующий вариант, заключается в круглые скобки.
Пример. Для того чтобы описать содержимое библиотеки, необходима следующая информация:
|
Автор Название Год издания Издательство |
Название Дата выхода (день, месяц, год) Издательство . |
Название Год и месяц издания Номер Издательство |
Графы "Название" и "Издательство" являются общими для всех трех вариантов, а остальные поля зависят от типа печатного издания. Для реализации этой структуры воспользуемся записью с вариантной частью:
type biblio = record name,publisher: string[20]; case item: char of 'b': (author: string[20]; year: 0..2004); 'n': (data: date); 'm': (year: 1700..2004; month: 1..12; number: integer); end;
В зависимости от значения поля item, в записи будет содержаться либо 4, либо 5, либо 6 полей.
Открытие и закрытие нетипизированного файла
В зависимости от того, какие действия ваша программа собирается производить с открываемым файлом, возможно двоякое его открытие:
reset(f[,size]); - открытие файла для считывания из него информации и одновременно для записи в него (если такого файла не существует, попытка открытия вызовет ошибку). Эта же команда служит для возвращения указателя на начало файла;
rewrite(f[,size]); - открытие файла для записи в него информации; если такого файла не существует, он будет создан; если файл с таким именем уже есть, вся содержавшаяся в нем ранее информация исчезнет.
Необязательная переменная size может задать количество байтов, единовременно считываемых из нетипизированного файла или записываемых в него. По умолчанию размер таких "кусков" принимается равным 128 байт.
Закрываются нетипизированные файлы процедурой close(f), общей для всех типов файлов.
Открытие и закрытие типизированного файла
В зависимости от того, какие действия ваша программа собирается производить с открываемым файлом, возможно двоякое его открытие:
reset(f); - открытие файла для считывания из него информации и одновременно для записи в него (если такого файла не существует, попытка открытия вызовет ошибку). Эта же команда служит для возвращения указателя на начало файла;
rewrite(f); - открытие файла для записи в него информации; если такого файла не существует, он будет создан; если файл с таким именем уже есть, вся содержавшаяся в нем ранее информация исчезнет.
Закрываются типизированные файлы процедурой close(f), общей для всех типов файлов.
Подпрограммы обработки директорий
Приведем здесь также несколько стандартных процедур, осуществляющих работу с директориями, а также с файлами, но внешним относительно самих файлов образом (без их открытия).
Процедура erase(f: file) удалит файл, связанный с файловой переменной f. Если такого файла нет, произойдет ошибка, реакцию на которую можно отрегулировать при помощи директивы компилятора {$I} (см. лекцию 6).
Процедура rename(f: file; s: string) даст файлу, связанному с файловой переменной f, новое имя, указанное в строке s. Если такого файла нет, произойдет ошибка.
Процедура chdir(s: string) сделает текущей директорию, указанную в строке s. Если такой директории нет, произойдет ошибка.
Процедура getdir(disk: byte; s:string) запишет в строку s имя текущей директории на указанном диске (0 - текущий диск, 1 - диск А , 2 - диск В и т.д.).
Процедура mkdir(s: string) создаст в текущей директории новую поддиректорию с указанным в строке s именем. Если в текущей директории уже существуют файл или директория с указанным именем, произойдет ошибка.
Процедура rmdir(s: string) удалит пустую директорию с заданным в строке s именем. Если такой директории нет, произойдет ошибка.
Поиск в нетипизированном файле
Все подпрограммы, описанные в разделе "Поиск в типизированном файле", будут работать и для нетипизированного файла. Но, поскольку тип элементов нетипизированного файла не определен, то размер одного "элемента" принимается равным 128 байт (по умолчанию) или указанному в переменной size во время открытия файла.
Поиск в типизированном файле
Уже знакомая нам функция eof(f:file):boolean сообщает о достигнутом конце файла. Все остальные функции "поиска конца" (eoln(), seekeof() и seekeoln()), свойственные текстовым файлам, нельзя применять к файлам типизированным.
Зато существуют специальные подпрограммы, которые позволяют работать с типизированными файлами как со структурами прямого доступа:
Функция filepos(f:file):longint сообщит текущее положение указателя в файле f. Если он указывает на самый конец файла, содержащего N элементов, то эта функция выдаст результат N. Это легко объяснимо: элементы файла нумеруются начиная с нуля, поэтому последний элемент имеет номер N-1. А номер N принадлежит, таким образом, "несуществующему" элементу - признаку конца файла.Функция filesize(f:file):longint вычислит длину файла f.Процедура seek(f:file,n:longint) передвинет указатель в файле f на начало записи с номером N. Если окажется, что n больше фактической длины файла, то указатель будет передвинут и за реальный конец файла.Процедура truncate(f:file) обрежет "хвост" файла f: все элементы начиная с текущего и до конца файла будут из него удалены. На самом же деле произойдет лишь переписывание признака "конец файла" в то место, куда указывал указатель, а физически "отрезанные" значения останутся на прежних местах - просто они станут "бесхозными".
Применимость подпрограмм обработки файлов
Сведем информацию о применимости процедур и функций работы с файлами в единую таблицу.
| append | + | ||
| assign | + | + | + |
| blockread | + | ||
| blockwrite | + | ||
| close | + | + | + |
| eof | + | + | + |
| eoln | + | ||
| filepos | + | + | |
| filesize | + | + | |
| read | + | + | |
| readln | + | ||
| reset | + | + | + |
| rewrite | + | + | + |
| seek | + | + | |
| seekeof | + | ||
| seekeoln | + | ||
| truncate | + | + | |
| write | + | + | |
| writeln | + |
Замечание: Реакция на ошибку, возникающую при выполнении любой из перечисленных здесь подпрограмм, зависит от состояния директивы компилятора {$I} (см. лекцию 6).
Считывание из типизированного файла
Чтение из файла, открытого для считывания, производится с помощью команды read(). В скобках сначала указывается имя файловой переменной, а затем - список ввода1):
read(f,a,b,c); - читать из файла f три однотипные переменные a, b и c.
Вводить из файла можно только переменные соответствующего объявлению типа, но этот тип данных может быть и структурированным. Cкажем, если вернуться к примеру, приведенному в начале п. "Типизированные файлы", то станет очевидным, что использование типизированного файла вместо текстового позволит значительно сократить текст программы:
type toy = record name: string[20]; price: real; age: set of 0..18; {задано границами} end; var f: file of toy; a: array[1..100] of toy; begin assign(f,input); reset(f); for i:=1 to 100 do if not eof(f) then read(f,a[i]); close(f); ... end.
Типизированные файлы
Переменные структурированных типов данных (кроме строкового) невозможно считать из текстового файла. Например, если нужно ввести из текстового файла данные для наполнения записи toy информацией об имеющихся в продаже игрушках (название товара, цена товара и возрастной диапазон, для которого игрушка предназначена):
type toy = record name: string[20]; price: real; age: set of 0..18; {в файле задано границами} end;
то придется написать следующий код:
var f: text; c: char; i,j,min,max: integer; a: array[1..100] of toy; begin assign(f,input); reset(f); for i:=1 to 100 do if not eof(f) then with a[i] do begin readln(f,name,price,min,max); age:=[]; for j:= min to max do age:=age+[j]; end; close(f); ... end.
Как видим, такое поэлементное считывание весьма неудобно и трудоемко.
Выход из этой ситуации предлагают типизированные файлы - их элементы могут относиться к любому базовому или структурированному типу данных. Единственное ограничение: все элементы должны быть одного и того же типа. Это кажущееся неудобство является непременным условием для организации прямого доступа к элементам бинарного файла: как и в случае массивов, если точно известна длина каждого компонента структуры, то адрес любого компонента может быть вычислен по очень простой формуле:
<начало_структуры> + <номер_компонента>*<длина_компонента>
Вложенные операторы with
Если возникает необходимость расположить один оператор with внутри другого, то любую переменную (если перед ней явно не указано имя записи), находящуюся под внутренним оператором with, компилятор пытается интерпретировать в такой последовательности:
если во внутренней записи есть поле с искомым именем, то поиск заканчивается; если во внутренней записи поля с таким именем нет, то поиск производится среди полей внешней записи (если вложенных операторов with больше, чем два, то поиск ведется последовательно во всех задействованных записях в направлении "изнутри наружу");если среди полей всех вложенных записей нет искомого идентификатора, компилятор считает его глобальной переменной.
Например:
type date = record day: 1..31; month: 1..12; year: 1900..2005; end; student = record name: string[100]; year: 1950..2005; {год поступления} gruppa: string[5]; birth: date; end; var ivanov: student;
begin ... with ivanov do begin ... with birth do begin ... year:= 2001; {birth.year} gruppa:= 'IT01'; {ivanov.gruppa} ... end; ... end; end;
Задание записей константой
Как и массивы, записи не могут быть заданы неименованной или нетипизированной константой.
Для того чтобы задать запись типизированной константой, следует вначале описать соответствующий тип в разделе type, а затем воспользоваться им в разделе const:
type <имя_типа> = record <имя_поля1>: <тип_поля1>; [<имя_поля2>: <тип_поля2>;] [...] end; const <имя_константы>: <имя_типа> = <начальное_значение>;
Начальное значение для переменной типа запись задается перечислением в круглых скобках начальных значений для всех полей (соответствующих типов!) с обязательным указанием имени задаваемого поля. Имя поля от его начального значения отделяется двоеточием, значения соседних полей разделяются точкой с запятой:
(<имя_поля1>: <значение_поля1>; _; <имя_поляN>: <значение_поляN>);
Например:
type data = record day: 1..31; month: 1..12; year: 1900..2100; end; const my_birthday: data = (day:17; month:3; year:2004);
Можно, конечно, не описывать тип константы отдельно, а объединить оба определения:
const my_birthday: record day: 1..31; month: 1..12; year: 1900..2100; end; = (day:17; month:3; year:2004);
Если описана двумерная таблица, то ее начальные значения задаются как вектор, каждый компонент которого является записью. Таким образом, правила задания типизированной константы-таблицы сочетают в себе правила задания массива и записи:
type family = (mother, father, child); const birthdays : array[family] of data = ((day: 8; month: 3; year: 1975), (day: 23; month: 2; year: 1970), (day: 1; month: 9; year: 2000));
Запись и чтение
Для осуществления записи в нетипизированный файл и считывания из него применяются две специальные процедуры blockread() и blockwrite().
Процедура blockread(f:file; buf,count:word [;result:word]) предназначена для считывания из файла f нескольких элементов разом (их количество указывается в переменной count, а длина устанавливается во время открытия файла) при помощи буфера обмена данными buf. Необязательная переменная result может хранить количество элементов, фактически считанных из файла.
Процедура blockwrite(f:file; buf,count:word [;result:word]) производит запись данных в нетипизированный файл при помощи буфера buf.
Запись с вариантной частью
Если заранее известно, что в массиве записей (таблице) некоторые поля могут оставаться пустыми (наборы пустых полей могут быть разными для разных записей), то вполне понятно желание как-то сократить неиспользуемый, но занимаемый объем памяти.
Специально для таких случаев существуют записи с вариантной частью.
Запись в типизированный файл
Сохранять переменные в файл, открытый для записи, можно при помощи команды write(). Так же как и в случае считывания, первой указывается файловая переменная, а за ней - список вывода:
write(f,a,b,c); - записать в файл f (предварительно открытый для записи командами rewrite(f) или reset(f)) переменные a,b,c.
Выводить в типизированный файл можно только переменные соответствующего описанию типа данных. Неименованные и нетипизированные константы нельзя выводить в типизированный файл.
Типизированные файлы рассматриваются как структуры одновременно и прямого, и последовательного доступа. Это означает, что запись возможна не только в самый конец файла, но и в любой другой его элемент. Записываемое значение заместит предыдущее значение в этом элементе (старое значение будет "затерто").
Например, если нужно заместить пятый элемент файла значением, хранящимся в переменной а, то следует написать следующий отрывок программы:
seek(f,5); {указатель будет установлен на начало 5-го элемента}
write(f,a); {указатель будет установлен на начало 6-го элемента}
Замечание: Поскольку и чтение из файла, и запись в файл сдвигают указатель на следующую позицию, то в случае, когда необходимо сначала прочитать значение, хранящееся в каком-то элементе, а затем вписать на это место новые данные, необходимо производить поиск дважды:
seek(f,5); {указатель - на начало 5-го элемента}
read(f,a); {указатель - на начало 6-го элемента}
seek(f,5); {указатель - на начало 5-го элемента}
write(f,b); {указатель - на начало 6-го элемента}
А что произойдет, если в файле содержится всего N элементов, а запись производится в (N+k)-й? Тогда начало файла останется прежним, затем в файл будет включен весь тот "мусор", что оказался между его концом и записываемой переменной, и, наконец, последним элементом нового файла станет записанное значение.
Записи
Продолжая изучение структурированных типов данных, переходим к записям.
Как и массивы, записи являются структурами прямого доступа, однако, в отличие от массивов, могут хранить элементы, относящиеся к разным типам данных.
Таким образом, запись - это вектор, компоненты которого (поля) могут относиться к разным типам данных.
