1. 11. Текстовые файлы
В прикладных программах,
как правило, имеется
большое число входных и выходных данных,
причем часто возникает необходимость
передачи данных из одной программы в другую.
Поэтому данные хранятся в файлах и при
необходимости считываются,
а также записываются в файлы
операторами программы.
Напомним, что файлом
называется именованная область внешней
памяти ЭВМ, содержащая
различные данные. Доступ
к данным в файле может быть прямым или
последовательным в
зависимости от типа файла.
Рассмотрим работу с данными текстовых
файлов.
Текстовые файлы представляют
совокупность строк
переменной длины с последовательным
доступом к данным, т. е. данные
записываются на диск и считываются только
последовательно. Информация
в текстовых файлах хранится в символьном (текстовом)
виде. При записи
числовых или логических значений
происходит автоматическое преобразование
данных в символьный тип,
а при считывании данные автоматически
преобразуются в машинные коды.
Строки текстового файла заканчиваются
символом #13- Enter и #10-
возврат каретки. В
конце файла устанавливается код #26.
При записи в файл данные записываются
подряд, а
управляющие символы устанавливаются
автоматически оператором Writeln. Управляющие символы работают при
просмотре/редактировании файла на экране
или при печати, но
при этом, как
правило, не
показываются.
Файловая переменная
" f "
описывается оператором
Var f: Text;
В программе файловая переменная "
f " связывается с именем файла на диске,
оператором:
Assign(f,
'Name_f');
где Name_f
-
имя файла.
Например, переменная
"f"
связывается
с файлом "file.
dat"
оператором Assign(f,
'file. dat'); если
файл находится в текущем каталоге,
иначе к нему указывает дорожка,
например:
'C:\Pascal\Work\file.dat'. Связывание файловой переменной "f"
с именем файла на диске аналогично
присвоению "f" значения.
Для записи данных в файл его необходимо
открыть оператором ReWrite(f);
При этом на диске создается
новый файл.
Имя файла указано в
операторе Assign(f,‘Name_f’); Данные записываются в файл
оператором Write(f,"сп");
или Writeln(f,"сп");
Причем,
оператор Writeln(f,"сп");
устанавливает в конце данных управляющие
символы: #13, #10.
Здесь обозначено "сп"
- список переменных.
Повторное применение оператора ReWrite(f);
стирает содержимое файла и устанавливает
указатель на начало файла.
Для
считывания данных из файла его необходимо
открыть оператором
Reset(f);
При этом указатель
устанавливается на начало файла.
Данные считываются с начала
файла оператором Read(f, "сп");
или Readln(f, "сп"); Причем,
оператор Readln(f,
"сп"); после считывания данных
для переменных, указанных
в "сп" переводит указатель за
управляющие символы: #13,
#10, игнорируя
возможно оставшиеся в строке данные. Следовательно оператор Readln(f);
пропускает все данные записанные до
управляющих символов #13,
#10. Повторное
применение оператора Reset(f);
устанавливает указатель на начало файла
для считывания данных, содержимое
файла при этом не меняется.
После окончания
работы с файлом его необходимо закрыть
процедурой Close(f);
иначе файл закрывается автоматически
при окончании работы программы,
но при этом может произойти потеря
данных в конце файла.
Для записи данных в конец закрытого
файла применяется
процедура Append(f);
при этом на диске должен существовать файл
с именем, указанным
в операторе Assign(f,’Name_f’);.
Напомним, что
если переменная "f" в операторах ввода/вывода
не указывается, то
происходит запись данных на экран и
считывание данных с клавиатуры с
отображением на экране.
Данные, записанные
в файл в одной программе часто используются
(считываются) в другой программе. При этом
данные, записанные
в файл операторами Write(f,
"сп"); и Writeln(f, "сп");,
необходимо считывать соответственно
операторами Read(f,
"сп"); и Readln(f, "сп");
Причем тип и длина считываемых данных
должны соответствовать записанным данным.
Если записывать данные подряд (длина
записи ограничена длиной сегмента,
например до 1024 символов),
то при просмотре редактором текста
будет выдаваться сообщение об усечении
данных по ограничителю длины строки
редактора. Рекомендуется
в текстовых файлах ограничивать длину
строки размерами экрана для удобного
просмотра данных. Запись
данных в файл позволяет избежать
использования массивов,
занимающих большую часть оперативной
памяти. При этом необходимо сразу после
расчета записывать значения переменных в
файл. При
считывании данных из файла можно
использовать массив или переменные того же
типа.
При работе с
числовыми данными необходимо учитывать,
что числа в файле должны отделяться
друг от друга хотя бы одним пробелом.
Следовательно при записи числовых
данных в файл необходимо использовать
формат с достаточным количеством позиций
для вывода.
Приведем примеры операторов
записи и считывания данных.
Assign(f1,'File1.dan');
{ назначить переменой f1, имя файла: File1. dan }
ReWrite(f1);
{
открыть файл для записи в первой программе }
Writeln(f1,'Значения "X","Y"'
);
{ начать запись }
For i:= 1 to N do begin
X:=
0.5*i;
Y:= Ln(X); { пример расчета значений переменных }
write(f1, X:6:2, Y:10:4);
{
записать данные в файл File1. dan }
If i mod 5 = 0 then writeln(f1)
{
записать
символ #13 }
end;
Close
(f1);
{ закрыть файл в первой
программе }
Assign(f2,'File1.dan');
{------------------------------------}
Reset(f2);
{
открыть файл для чтения во второй программе
}
Readln(f2); {
пропустить первую строчку }
For i:= 1 to N do begin
read(f2,
a[i], b[i]);
{
считать данные в массивы "A" и "B" }
If i mod 5 = 0 then readln(f2)
{
считать
символ #13 }
end;
Close
(f2);
{ закрыть файл во
второй программе }
При обновлении файла с выходными
данными во время повторных запусков
программы на экране появляется
предупреждение (Warning) о перезаписи новых
данных с диска в оперативную память,
т. е. в окно редактора: Reload from disk?, на что следует ответить -
Yes.
При работе со
строковыми данными необходимо указывать
длину переменной типа String в операторе
описания типов переменных,
иначе оператором Read(f,
S); в строковую переменную "S"
считывается до 255 символов,
а оператором Readln(f, S);
считываются все символы до #13,
но не более 255, причем пробелы в конце строки
игнорируются. Приведем
пример программы для считывания строковых
и числовых данных из файла и записи их в
другой файл.
var c: char;
j, i: word;
s: array[1..10]
of string[12];
a: array[1..10,
1..6] of word;
f1, f2: text;
BEGIN
assign(f1, 'F1.txt');
reset(f1);
assign(f2, 'F2.txt');
rewrite(f2);
for i:= 1 to 10 do
begin read(f1, s[i]); {
считывание строки }
for j:= 1 to 6 do read(f1, a[i,j]); { считывание шести чисел }
readln(f1)
{
считывание символа конца строки }
end;
for
c:= 'А' to 'Я' do
{
цикл по перебору символов }
for i:= 1 to 10 do
if s[i,1] = c then begin
write(f2,
s[i]); {
запись строк в алфавитном порядке первых
символов }
for j:= 1 to 6 do
write(f2, a[i,j]:2); {
запись шести
чисел }
writeln(F2)
end;
close(f1); close(f2);
END.
Здесь полагается что в файле F1. txt
записаны данные, которые в редакторе текста имеют
вид:
Леонтьев 5
4 4 5 4
3
Ивлев
4 5
3 4 3
4
и т. д.
После считывания данных в программе
происходит их сортировка перебором и
запись в файл F2. txt в алфавитном порядке
первой буквы фамилии.
Примечание: Линейный массив "S"
строкового типа можно представить как
двумерный массив "S" символьного типа. Здесь первый индекс
соответствует номеру элемента одномерного
массива "S", а
второй - номеру символа в элементе
одномерного массива "S".
При считывании данных из файла
неопределенной длины можно использовать
функцию EoF(f);
возвращающую признак конца файла,
а именно: EoF(f)
равен True если указатель стоит на признаке
конца файла (код #26), иначе
EoF(f) равен False. Приведем
пример операторов для считывания текста из
файла FF1. t, кодировки
текста и записи в файл FF2. t с сохранением
кода #13.
assign(f1, 'FF1. t'); reset(f1);
assign(f2, 'FF2. t'); rewrite(f2);
while not EoF(f1) do begin read(f1,c);
{считываем
переменную
типа
Char }
if c
<> #13 then c:=pred(c); write(f2,c) {кодируем и
выводим на экран }
end;
