Обработка структур данных

BEGIN

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

Repeat {цикл будет работать, пока не введем имя существующего файла}

ClrScr;

Write('Вв.имя файла>'); Readln(fname); {Вводим имя файла, откуда читаем}

Assign(f,fname); {Связываем имя файла с файловой переменной}

{$i-} {Отключаем проверку ошибок}

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

{$i+} {Включаем проверку ошибок}

Until IoResult=0; {Если такой файл существует, цикл заканчивает работу}

Write('Вв.имя нового файла>');Readln(fname1);{Вводим имя файла, куда пишем}

Assign(f1,fname1);Rewrite(f1); {Открываем файл}

{Форматирование файла до заданной длины строки}

Write('Вв.длину строки>'); Readln(l); {Вводим длину строки форматирования }

st2:=''; {Чистим строку, которую будем использовать при форматировании}

Reset(f); {Устанавливаем курсор в начало файла}

While Not Eof(f) Do {Цикл по всему файлу }

Begin {Начало цикла}

Readln(f,st); {Читаем строку из файла}

st2:=st2+st; {Присоедоняем ее к строке форматирования}

While l<=Length(st2) Do{Пока размер "укладывается" в длину строки}

Begin {Начало цикла по строке}

st1:=Copy(st2,1,l); {В st1 копируем часть строк длиной в L}

Writeln(f1,st1); {Записываем эту часть в файл}

Delete(st2,1,l); {Удаляем часть строки длиной L}

End; {Конец цикла по строке}

End; {Конец цикла по файлу (Eof)}

If l>Length(st2) Then {Если осталась часть строки меньше, чем заданная,}

Writeln(f1,st2); {допишем ее в конец файла, что бы ни потерять}

Close(f);Erase(f); {Закрываем исходный файл и удаляем его}

Close(fl);Rename(fl,fname); {Закрываем и переименовываем}

END.

Задача №7. В файле определить максимальное кол-во идущих подряд одинаковых символов. Количество и сам символ вывести на экран.

Алгоритм:

- открыть файл;

- обнулить «стартовый» максимум;

- организовать цикл по файлу:

- читать строку;

- установить индекс строки в 1-у;

- в цикле по строке:

- счетчик повторений одинаковых символов установить в 1-у;

- пока рядом стоящие символы строки одинаковы, увеличить

счетчик и изменить позицию в строке;

- сравнить полученное кол-во с ранее заданным максимумом и, если оно больше, то запомнить его, как максимум и запомнить сам символ;

- изменить позицию в строке;

- после окончания работы цикла по файлу, вывести поученный результат на экран;

- закрыть файл.

Uses Crt;

Var

i,max,n:Byte; {i - позиция в строке}

{max - максимальное кол-во идущих подряд одинаковых символов}

{n - текущее кол-во идущих подряд одинаковых символов}

f:Text; {f - файловая переменная }

ch:Char;{ch - символ для наглядности вывода}

st,fname:String; {st - строка, которую читаем из файла; fname - имя файла}

BEGIN

{Открытие файла}

Repeat {Повторять}

ClrScr; {на чистом экране}

Writeln('введите имя файла:'); Readln(fname); {вводить имя файла}

Assign(f,fname); {связывать ф.п. с именем файла}

{$I-} {снимать проверку ошибок}

Reset(f); {пытаться открывать файл}

{$I+} {устанавливать проверку ошибок}

Until IoResult=0; { пока введем имя существуюющего файла}

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

max:=0; {Обнуляем max}

While Not Eof(f) Do {Пока не конец файла}

Begin {начало цикла по файлу}

Readln(f,st); {читаем строку из файла,}

i:=1; {установить индекс строки в 1-у}

While i<Length(st) Do {в цикле по строке}

Begin {начало цикла по строке}

n:=1; {устанавливаем счетчик "порции" одинаковых рядом стоящих

символов}

While st[i]=st[i+1] Do {и пока, рядом стоящие символы, равны, }

Begin {начало цикла по рядом стоящим символам}

inc(n); {считаем их}

inc(i); {и меняем позицию в строке.}

End; {конец цикла по рядом стоящим символам}

if st[i]<>' ' Then {Если это не пробелы}

If n>max Then {и их количество больше предыдущего,}

Begin max:=n; {запоминаем, как максимум}

ch:=st[i]; End; {запоминаем сам символ для наглядности вывода}

inc(i); {Меняем позицию в строке}

End; {конец цикла по строке}

End; {конец цикла по файлу}

Writeln('max кол.идущих подряд символов-',max,'(',ch,')');

Close(f);

Readkey;

END.

Задача №8. Из строк текстового файла сформировать массив строк, отсортировать его по возрастанию длин строк и вывести на экран до и после сортировки. Использовать процедуры.

Решение этой задачи можно условно разбить на 4 части, которые записать в виде

отдельных процедур:

- открытие файла;

- формирование массива строк;

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

- вывод массива строк на экран.

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

Для формирования массива строк нужно:

- задать начальный индекс массива равным 0;

- организовать цикл по файлу ;

- увеличивать индекс;

- читать из файла строку прямо в массив.

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

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

Справка:

1). Параметры процедуры могут быть входными и выходными, параметры - переменные и параметры - значения.

2). Если параметр задается вне процедуры, а используется в процедуре - ВХОДНОЙ.

Если параметр задается в процедуре, а используется вне процедуре - ВЫХОДНОЙ.

3). Если параметр формируется или изменяется в процедуре, он обязательно параметр - ПЕРЕМЕННАЯ (Var).

4). Формальные и фактические параметры процедуры должны строго соответствовать:

- по типу;

- по количеству;

- по место расположению.

Uses Crt;

Const

n1=100; {Максимальное кол-во строк в файле}

Type

m=Array [1..n1] Of String[80];{Массив на 100 строк}

Var

f:text; {Файловая переменная}

n:byte; {Кол-во строк в массиве}

mas:m; {Массив строк файла}

{Процедура открытия файла}

Procedure Open_File;

Var

fn:string; {Имя файла}

Begin

Repeat

ClrScr;

Writeln('Введите имя файла');

Readln (FN);

Assign(f,FN);

{$i-}

Reset(f);

{$i+}

until IoResult=0;

End;

{ Процедура формирования массива из строк файла.}

{Параметры (mas - сам массив и n - кол-во строк в масиве) выходные.}

Procedure Form_Mas(Var mas:m;Var n:Byte );

Begin

Reset(f); {Устанавливаем курсор в начало файла}

n:=0; {Начальное значение счетчика строк}

While Not Eof(f) Do {В цикле по файлу}

Begin

Inc(n); {увеличиаем индекс массива}

Readln(f,mas[n]); {читаем строку из файла в N элемент массива}

End;

End;

{Процедура вывода массива строк на экран.}

{Параметры ( mas - массив; n - размер массива; st- строка заголовка) входные.}

Procedure Write_Mas(mas:m; n:Byte; st:String);

Var

i:Byte; {Параметр цикла (индекс массива)}

Begin

ClrScr;

Writeln(st); {Выводим "шапку" перед выводом массива строк}

Writeln;

For i:=1 To n Do {Организуем цикл по эл. массива}

Begin

Writeln(mas[i]);{Выводим строку массива}

If (i MOD 24)=0 {После каждой страниц вывода, (число строк кратное 24),}

Then Begin

Readkey;{задерживаем вывод на экране,}

ClrScr; {чистим экран перед новой страницей вывода.}

End;

End;

End;

{Процедура сортировки массива по возрастанию длин строк.}

{Параметры: mas - массив (как входной, так и выходной)}

{ n - размер массива (входной).}

Procedure Sort(Var mas:m; n:Byte);

Var

j,i:Byte; {Параметры циклов}

buf:String; {Для временного обмена строк массива}

Begin

For j:=1 To n-1 Do{Цикл для повторной проверки пар}

for i:=1 To n-j Do {Цикл для сравнения рядом стоящих элементов массива}

If Length(mas[i])>Length(mas[i+1]) Then{Если одна будет больше другой}

Begin buf:=mas[i]; {Временно текущую строку сохраним в буфере}

mas[i]:=mas[i+1]; {Запомним следующую, как текущую}

mas[i+1]:=buf; {Вернем следующую из буфера}

End; {конец условия}

End;

BEGIN

ClrScr;

Open_File; {Открываем файл}

Form_Mas (mas,n); {Формируем массив из строк файла}

Write_Mas(mas,n,'ИСХОДНЫЙ ФАЙЛ'); {Выводим массив}

Readln;

Sort(mas,n); {Сортируем массив строк}

Write_Mas (mas,n,'ФАЙЛ ПОСЛЕ СОРТИРОВКИ'); {Выводим массив}

Readln;

END.

Задача №9. Разработать программу перевода текстовых файлов из английского на русский. Перевод разместить после английского слова в фигурных скобках и записать в новый файл. Использовать процедуры.

Справка:

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

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

3). Английские слова и перевод должны занимать абсолютно одинаковые позиции в "массивах-словарях".

Uses Crt;

Const

ks=5;

Engl:Array[1..ks] Of String=('CONST','VAR','STRING','BEGIN','END');

Russ:Array[1..ks] OF String=('константа','переменная','строка','начало', 'конец');

Var

f,f1:Text; {Файловые переменные}

Procedure openf(Var f:Text); {Процедура открытия существующего файла}

Var

fname:String; {Имя файла}

Begin

Repeat {Повторять}

ClrScr; {на чистом экране}

Write('Вв.имя файла>'); {выводить запрос на ввод имени файла,}

Readln(fname); {вводить имя файла,}

{$i-} {отключать проверку ошибок при попытке открыть не существующий

файл,}

Assign(f,fname);Reset(f); {пытаться открыть файл,}

{$i+} {включать проверку ошибок}

Until IoResult=0; {пока не введем имя существующего файла}

End;

Procedure openf(Var f1:Text); {Процедура открытия нового файла}

Var

fname1:String; {Имя файла}

Begin

Write('Вв.имя нового файла>'); Readln(fname1); {Вводим имя файла}

Assign(f1,fname1);

Rewrite(f1); {Открываем файл для записи}

End;{------------------}

Procedure Trans(Var f,f1:Text);{Процедура перевода и записи в новый файл}

Var

st,st1:String; {st - строка для чтения из файла и записи в файл,

st1 - временная строка для поиска слов перевода}

p,i:Byte; {p - позиция вхождения слова в строку}

{i - позиция в строке}

Begin

Reset(f); {Устанавливаем указатель в начало файла}

While Not EOF(f) Do {В цикле по файлу}

Begin {Начало цикла по файлу}

Readln(f,st); {читаем строку}

st1:=''; {чистим строку для заглавных букв}

For i:=1 To Length(st) Do{В цикле по строке}

st1:=st1+UpCase(st[i]); {формируем строку заглавных}

For i:=1 To ks Do {В цикле по словарю английских слов}

Begin {Начало цикла по словарю}

While Pos(Engl[i],st1)<>0 Do {до тех пор, пока слова из словаря}

Begin {будут встречаться в строке преобр. к заглавным}

p:=Pos(Engl[i],st1); {запоминаем позицию слова в строке преобраз.}

Insert('{'+(russ[i])+'}',st,p+Length(Engl[i])); {Вставляем перевод}

Insert('{'+(russ[i])+'}',st1,p+Length(Engl[i])); {в обе строки}

st1[p]:=' '; {Заменяем первую букву слова в строке поиска пробелом}

End; {Конец цикла поиска}

End; {Конец цикла по словарю}

Writeln(f1,st); {Выводим строку в новый файл}

End;{eof} {Конец цикла по файлу}

End;{----------------}

Procedure out(Var f1:Text); {Прцедура вывода из файла на экран}

Var

st:String; {Строка для чтения из файла и вывода}

n:Byte; {счетчик выведенных строк}

Begin

Reset(f1); {Устанавливаем курсор в начало файла}

n:=0; {Обнуляем счетчик}

While Not EOF(f1) Do {в цикле идем до конца файла}

Begin

Inc(n); {Увеличиваем счетчик строк }

Readln(f1,st); {Читаем строку из файла}

Writeln(st); {Выводим на экран}

If n=24 Then Begin {Если выведено 24 строки}

Readln; {Задержим вывод на экране}

n:=0; {обнулим счетчик строк для следующей порции}

End; {Конец условия}

End; {Конец цикла по файлу}

Readkey;

End;{---------------}

BEGIN

ClrScr;

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

trans(f,f1); {Переводим и записываем в новый файл}

out(f1); {Выводим на экран перевод}

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

Close(f1);

END.

5.2 Типизированные

5.2.1 Теоретические сведения

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

Основные правила работы с типизированными файлами:

1) Типизированные файлы можно создавать и просматривать только программным путем.

2) Файлы состоят из записей одинаковой длины, т.к. длина записи зависит от типа типизированного файла (Real- 6б; Integer -2б; Char -1б).

3) Тип записи, а так же и файла любой кроме файлового или структурного.

Var Var

F:File of Real; F:File of Text;

4) Размер записи любой, не превышающий 64 Кб.

5) Число записей не ограничено.

6) Для записи в файл и чтения из файла используется только переменные. Использование констант недопустимо.

7) Файловая переменная описывается:

Если Var

строка F: File of String;{Если файл строкового типа, то и}

не St: String; {переем. чтения или записи тоже стр.типа}

ограничена

Если Type

строка RecType=string[80];

ограничена Var

F: File of RecType;{и файл, }

St: RecType; {и строка одного типа RecType }

Если Type

файловую RecType=string[80];

переменную FF= File of RecType;

использовать Var

в параметрах F: FF;

процедуры St: RecType;

Procedure OPEN_F(Var F:FF); Procedure OPEN_F(Var F:File of RecType);

нельзя

8) Для чтения только Read(<ф.п.>,<переменная чтения>);

для записи только Write(<ф.п.>,<переменная записи>); с 2-мя параметрами, т.к. за одно обращение может быть записана или прочитана 1-а запись.

9) Нумерация записей типизированного файла начинается с 0 (нуля).

10) После выполнения чтения 1-ой записи указатель текущей позиции всегда перемещается на следующую запись.

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

Можно:

ѕ читать любую запись;

ѕ после редактирования возвращать на то же самое место;

ѕ заменять;

ѕ вставлять;

ѕ сдвигать;

ѕ сортировать;

ѕ дописывать и т.д.

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

Кроме Assign(<F,<>);Reset(F);Rewrite(F); Read(F,<>);Write(F,<>); EOF(F) при работе с типизированными файлами используются:

1) Процедура Seek(Var F;N:LongInt); - устанавливает текущий указатель на запись с номером N.

2) Процедура TrunCate(Var F); - удаляет часть заданного файла, находящуюся за позицией текущего указателя.

3) Функция FileSize(Var F):LongInt; - определяет размер заданного файла.

В текстовом В типизированном

№ записи Date.txt № записи Date. Dat

Функция FileSize(F) вернет 4, поэтому, если захотим дописать запись в конец типизированного файла, нужно установить указатель после записи с номером 3, тоесть на 4.

Assign(F,'Date. Dat'); Reset(F); {открываем типизированный файл}

Seek(F, FileSize(F)); {устанавливаем указатель текущей позиции}

Write(F,Rec); {выводим запись в указанную позицию}

4) FilePos (Var F):LongInt; - определяет позицию текущего указателя в заданном файле.

5.2.2 Задачи

Задача №1 Записать в файл 6-ть чисел, введенных с клавиатуры.

Справка.

1). Главное, что нужно помнить при работе с типизированными файлами, это то, что и тип файла, и тип переменной чтения-записи должен быть одинаковым.

2). Размер записи типизированного файла будет соответствовать размеру типа переменной.

3). Если количество записей взять, к примеру, равным 6-ти, а тип записи «слово», то размер типизированного файла будет 12б.

Uses Crt;

Const

N=6; {число записей}

Var

F:File of word;{файл типа слово}

A:Word; {переменная типа слово}

I:Byte; {параметр цила}

BEGIN

ClrScr;

Assign(F,'Data.txt'); Rewrite(F);

For I:=1 to N do

Begin

Write(`Введите число: ');Readln(A);{вводим число}

Write(F,A); {выводим его в файл}

End;

Close(F);

END.

Задача №2 Переписать информацию из текстового файла в типизированный файл.

Справка.

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

№ записи Текст.ф.Date.txt Date.txt



Readln(F,A); Read(F,A);

2). И в первом и во втором случае в текущем каталоге появится файл размером 12 байт (2б х 6 чисел), просмотрев который увидим набор символов, т.к. в файле числа записаны в двоичном формате; для записи числа отведено 2б, но!!! каждый байт интерпретируется как символ.

Введем	1111	2222
В памяти	0 0 0 0 0 1 0 0	0 1 0 1 0 1 1 1	0 0 0 0 1 0 0 0	1 0 1 0 1 1 1 0
В файле	символ #4	символ #87	символ #8	символ #174
№ записи	0	1

Каждый байт интерпретируется как символ с кодом 4,87,8,174

Uses Crt;

Var

F:Text; {для текстового файла}

F1:File of Word; {для типизированного файла}

A:Word: {переменная чтения и записи}

BEGIN

Assign(F,'Date.txt'); Reset(F); {открываем текстовый файл }

Assign(F1,'Date.dat'); Rewrite(F1);{открываем типизированный файл}

While Not Eof(F)do {пока не конец текстового файла}

Begin

Readln(F,A); {читаем из текстового}

Write(F1,A); {записываем в типизированный}

End;

Close(F);Close(F1); {закрываем файлы}

END.

Задача №3 .Просмотр типизированного файла.

Справка.

1) Просмотреть типизированный файл можно только программным путем.

2) Для чтения из типизированного файла используется только Read(F,a); , т.к. записи типизированного файла «идут строго друг за другом».

Uses Crt;

Var

F:File of Real;

A:Real;

BEGIN

ClrScr;

Assign(F,'Date.dat');Reset(F);

While Not EoF(F) do

Begin

Read(F,a);{читаем из типизированного файла}

Write(a:8);{выводим на экран по формату}

End;

Readkey; Close(F);

END.

Задача №4 Записать число в типизированный файл на место 6-ой записи.

Справка.

1). Так как нумерация записей типизированного файла начинается с 0 (нуля), то в данном случае нужно установить указатель на запись с номером 5.

2) Для установки указателя нужно использовать процедуру Seek(F,5), которая имеет 2 параметра: файловую переменную и номер записи.

Uses Crt; 'Date.dat'

Var

F:File of Real;{файл вещественного типа}

A:Real; {переменная вещ. типа}

BEGIN

Assign(F,'Date.dat');Rewrite(F);

A:=20.5; {задаем число}

Seek(F,5);{устанавливаем указатель}

Write(F,a);{выводим число в указанную позицию файла}

Close(F);

END.

Задача №5. Вставить новую запись на место, предположим, 2-ой.

Алгоритм:

ѕ открыть файл;

ѕ «освободить» место вставки путем сдвига на «ступеньку вниз» всех записей с учетом той, которую нужно освободить;

ѕ записать на освобожденное место новую запись.

Справка.

1). Для сдвига записей нужно построить цикл, в котором сдвиг начнем с последней записи до той, на место которой нужно вставить.

2). Нужно использовать в цикле Downto «от большего к меньшему».

2). Если вводить № записи вставки и число, которое нужно вставить, программа будет универсальной. Сделай сам.

№ записи 'Date.dat' № записи

Задача №6 Отсортировать текстовый файла чисел по убыванию с использованием типизированного файла.

Алгоритм:

ѕ открыть текстовый и типизированные файлы;

ѕ переписать информацию из текстового файла в типизированный;

ѕ построить циклы для отсортировки типизированного файла, где:

ѕ устанавливать указатели на две рядом стоящие записи;

ѕ читать из них информацию в две переменные;

ѕ сравнивать их и при выполнении условия, возвращать записи назад в типизированный файл, переустановив указатели наоборот;

ѕ вывести информацию типизированного файла на экран;

ѕ переписать из типизированного назад в текстовый;

ѕ файлы закрыть;

ѕ типизированный удалить.

Справка.

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

2) При обработке больших текстовых файлов нужно предусмотреть:

ѕ задержку вывода на экран;

ѕ формат вывода при выводе на экран и файл. Сделай сам.

Uses Crt;

Var Файл текстовый

F:Text; {файл. пер. текстового файла} № зап. 'Date.txt'

F1: File of Real; {файл. пер. типизированного файла}

Rec1,Rec2:Real; {переменные чтения - записи}

I,j:Byte; {параметры цикла}

BEGIN

{1 - открываем файлы}

Assign(F,'Date.txt');Reset(F); {текстовый}

Assign(F1,'Date.dat');Rewrite(F);{типизированный}

{2 - переписываем из текстового в типизированный}} № зап. 'Date.dat'

While Not Eof(F) do) {в цикле по текстовому файлу Rec1

Begin Rec2

Readln(F,Rec1); {читаем из текстового }

Write(F1,Rec1); {записываем в типизированный}

End;

Reset(F1);{устанавливаем указатель на начало файла} посл.

пара

{3 - сортируем типизированный файл}

For i:=1 to FileSize(F)-1 do

For j:=0 to FileSize(F)-i-1 do {цикл по № записи}

Begin

Seek(f,j); Read(F1,Rec1); {читаем из двух рядом стоящих записей}

Read(F1,Rec2); {в разные переменные}

If Rec1<Rec2 Then {сравниваем и, если Rec1<Rec2,}

Begin

Seek(F1,j); Write(F1,Rec2);{меняем их}

Write(F1,Rec1);{местами}

End;

End; {конец сортировки}

{4 - контрольный вывод из типизированного файла на экран}

Reset(F1); {обязательно}

While Not Eof(F) do

Begin

Read(F1,Reac1);{читаем}

Writeln(Rec1); {выводим}

End;

{5 - перезаписываем текстовый файл}

Reset(F1); {устанавливаем указатель на начало типизированного файла}

Rewrite(F);{открываем текстовый файл для перезаписи}

While Not Eof(F1) do {в цикле по типизированному файлу}

Begin

Read(F1,Reac1);{читаем из типизированного}

Writeln(F,Rec1);{записываем в текстовый}

End;

Close(F); {закрываем текстовый файл}

Close(F1); {закрываем типизированный файл}

Erase(F1); {удаляем типизированный файл}

END.

Задача №7 Разработать программу просмотра файла с использованием клавиш управления курсором (стрелки вверх - вниз). Выход с режима просмотра по клавише ESC.

Алгоритм:

- открытие файла;

- запись информации из текстового файла в типизированный файл;

- в цикле по файлу организовать:

- вывод из файла на экран "порции" записей;

- активизация клавиш управления курсором для просмотра;

- закрытие файла.

Вывод из файла на экран "порции" записей сводится к тому, что:

ѕ на экран вначале выводятся первые 24 строки файла;

ѕ устанавливается курсор в первую позицию строки экрана;

ѕ номер записи вывода пересчитывается, и выводятся 24 строки, но уже с нового номера записи.

Активизация стрелки вниз предполагает:

ѕ увеличение координаты (Y);

ѕ переустановку курсора на экране;

ѕ контролировать, если курсор опуститься вниз (на 24 строку), а пользователь продолжает нажимать стрелку вниз:

ѕ увеличивать номер записи вывода (n);

ѕ зафиксировать при этом курсор в 24 строке.

Справка:

1). При решении этой задачи обязательно нужно использовать типизированный

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

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

3). Размер файла возвращает функция FileSize(f1).

4). #80 - стрелка вниз; #72 - стрелка вверх.

5). Выбор строки для удаления клавиша ENTER #13; для выхода с режима удаления клавиша ESC#27; .

Uses Crt;

Type

ff=File Of String; {Файловая переменная типа строка}

Var

f1:ff; {f1 - файловая переменная типизированного файла}

f:Text; {f - файловая переменная текстового файла}

ch:Char; {ch - переменная управления курсором}

y:Byte; {y - координата перемещения курсора;}

n:Integer; {n - номер записи файла для вывода}

Procedure Open_File(Var f:Text; Var f1:ff); {Процедура открытия файла}

Var

fname:String; {fname - имя текстового файла}

Begin

Repeat

ClrScr;

Writeln('Вв.имя файла:'); {Выводим запрос на ввод имени файла,}

Readln(fname); {Вводим имя файла,}

Assign(f,fname); {Связываем его с файловой переменной,}

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

Until IOresult=0;

Assign(f1,'fname1'); {'fname1' - имя типизированного файла}

Rewrite(f1); {Открываем новый типизированный файл}

End;{-------------------Конец процедуры Open_File----------------------}

Procedure Text_Type(Var f:Text; Var f1:ff); {Создает типизов.файл}

Var

st:String; {Строка для перезаписи из файла в файл}

Begin

Reset(f); {Устанавливаем указатель в начало файла}

While Not Eof(f) Do {Пока не конец файла}

Begin

Readln(f,st); {читаем из текстового}

Write(f1,st); {пишем в типизированный}

End;

End;{-------------------Конец процедуры Text_Type----------------------}

{Вывод на экран порции из 24 строк файла, начиная с N-той записи }

Procedure Write_Con(Var f1:ff;Var n:Integer);

Var

st:String; {Строка для чтения из файла}

i:Integer; {Параметр цикла}

Begin

ClrScr;

For i:=n To 23+n Do {Цикл вывода записей файла, количество которых}

Begin {поместятся на одной странице экрана}

If i< FileSize(f1) Then {Условие ограничения вывода файла размером

меньше страницы}

Begin

Seek(f1,i); {Устанавливаем указатель}

Read(f1,st); {Читаем запись из файла в строку}

Writeln(st); {Выводим строку на экран}

End;

End;

End;{---------------------Конец процедуры Write_Con-----------------------}

{Процедура просмотра файла}

Procedure Survey(Var f1:ff;Var y:Byte;Var n:Integer;Var ch:Char);

{ y - координата курсора; n - номер записи; ch - символ управления}

Begin

GoToXY(1,y); {Устанавливаем курсор}

ch:=Readkey; {Вводим управляющий символ}

If ch=#0 Then ch:=Readkey

Case ch Of {В зависимости от выбранной стрелки}

#80: Begin {(стрелка вниз)}

Inc(y); {Увеличиваем координату курсора}

If y>FileSize(f1) {Если координата курсора станет больше размера}

{файла,что может быть, если файл размером меньше}

{страницы,}

Then y:=FileSize(f1){то курсор не должен передвигаться дальше вниз}

{по экрану.}

Else Begin {Если курсор в самом низу экрана}

If (y>24 {(если файл размером больше страницы)}

Then Begin

y:=24; {"Удерживаем" его внизу}

Inc(n); {Увеличиваем номер записи для вывода (скроллинга).}

If n>(FileSize(f1)-24) {Если номер записи больше последней "порции"}

Then n:=FileSize(f1)-24; {оставляем равным номеру записи, с которого}

{выводится на экран последняя "порция" вывода.}

End; End;

End;

#72: Begin {стрелка вверх}

Dec(y); {Уменьшаем координату курсора}

If y<1 {Если координата курсора < 1}

Then Begin {начало условия}

y:=1; {"Удерживаем" его в самом верху}

dec(n); {Уменьшаем номер записи для вывода (скроллинга)}

If n<0 Then n:=0; {Фиксируем номер записи}

End; {конец условия}

End;

End;{case}

End;{-----------------Конец процедуры Survey------------------}

BEGIN

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

Text_Type(f,f1); {Переписываем из текстового файла в типизированный

n:=0; {Устанавливаем исходный номер записи}

y:=1; {Устанавливаем начальную координату курсора}

Repeat {Повторяем}

Write_Con(f1,n); {выводить на экран с n-ой записи}

Survey(f1,y,n,ch);{пересчитывать номер записи}

Until ch=#27; {пока не выберем клавишу Esc}

Readkey; Close(f); Close(f1);

END.

Задача №8 Разработать программу удаления записи из файла . Для выбора записи на удаление использовать клавиш управления курсором (стрелки вверх - вниз). Выход с режима удаления по клавише ESC.

Алгоритм:

- открытие файла;

- запись информации из текстового файла в типизированный файл;

- в цикле по файлу организовать:

- вывод из файла на экран "порции" записей;

- активизация клавиш управления курсором для просмотра и выбор удаляемой записи;

- удаление записи;

- уплотнение файла;

- закрытие файла.

Вывод из файла на экран "порции" записей сводится к тому, что:

ѕ на экран вначале выводятся первые 24 строки файла;

ѕ устанавливается курсор в первую позицию строки экрана;

ѕ номер записи вывода пересчитывается, и выводятся 24 строки, но уже с нового номера записи.

Активизация стрелки вниз предполагает:

ѕ увеличение координаты (Y) и номера записи для удаления (n1);

ѕ переустановку курсора на экране;

ѕ контролировать,если курсор опуститься вниз (на 24 строку), а пользователь продолжает нажимать стрелку вниз:

ѕ увеличивать номер записи вывода (n);

ѕ увеличивать номер записи удаления (n1);

ѕ зафиксировав при этом курсор в 24 строке.

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

Справка:

1). См. справку предыдущей задачи.

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

3)Добавляя в оператор выбора другие клавиши управления -Home, End, PageUp,

PageDown, можно расширить просмот Нужно предусмотреть и то, что файлы могут быть не всегда больше страницы вывода. Сделай сам.

Uses Crt;

Type

ff=File Of String; {Файловая переменная типа строка}

Var

f1:ff; {f1 - файловая переменная типизированного файла}

f:Text; {f - файловая переменная текстового файла}

ch:Char; {ch - переменная управления курсором}

y:Byte; {y - координата перемещения курсора;}

p,n,n1:Integer; {n - номер записи файла для вывода}

{n1 - номер удаляемой записи файла}

{р - кол-во удаленных записей файла вывода}

Procedure Open_File(Var f:Text; Var f1:ff); {Процедура открытия файлов}

Var

fname:String; {fname - имя текстового файла}

Begin

Repeat

ClrScr;

Writeln('Вв.имя файла:'); Readln(fname); {Вводим имя файла}

Assign(f,fname); {Связываем его с файловой переменной,}

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

Until IOresult=0;

Assign(f1,'fname1'); {'fname1' - имя типизированного файла}

Rewrite(f1); {Открываем новый типизированный файл}

End;{-------------------Конец процедуры Open_File----------------------}

Procedure Text_Type(Var f:Text; Var f1:ff); {Создает типизов.файл}

Var

st:String; {Строка для перезаписи из файла в файл}

Begin

Reset(f); {Устанавливаем указатель в начало файла}

While Not Eof(f) Do {Пока не конец файла}

Begin

Readln(f,st); {читаем из текстового}

Write(f1,st); {пишем в типизированный}

End;

End;{-------------------Конец процедуры Text_Type----------------------}

Procedure Type_Text(Var f:Text; Var f1:ff);{Из типизов. файла в текст.}

Var

st:String; {Строка для перезаписи из файла в файл}

Begin

Reset(f1); {Устанавливаем указатель в начало файла}

While Not Eof(f1) Do {Пока не конец файла}

Begin

Read(f1,st); {читаем из типизированного}

Writeln(f,st); {пишем в текстовый}

End;

End;{-------------------Конец процедуры Type_Text----------------------}

{Вывод на экран порции из 24 строк файла, начиная с N-той записи }

Procedure Write_Con(Var f1:ff;Var n,p:Integer);

Var

st:String; {Строка для чтения из файла}

i:Integer; {Параметр цикла}

Begin

ClrScr;

For i:=n To 23+n Do {Цикл вывода записей файла, количество которых}

Begin {поместятся на одной странице экрана}

If i< FileSize(f1)-p {Условие вывода записей для}

Then Begin { файла меньше страницы}

Seek(f1,i); {Устанавливаем указатель}

Read(f1,st); {Читаем запись из файла в строку}

Writeln(st); {Выводим строку на экран}

End;

End;

End;{---------------------Конец процедуры Write_Con-----------------------}

{Процедура просмотра файла}

Procedure Survey(Var f1:ff;Var y:Byte;Var n,n1:Integer;Var ch:Char);

{y - координата курсора; n - номер записи вывода;

n1 - номер удаляемой записи; ch - символ управления}

Begin

GoToXY(1,y); {Устанавливаем курсор}

ch:=Readkey; {Вводим символ, код которого соответствует}

If ch=#0 Then ch:=Readkey;{клавишам управления курсором}

Case ch Of {В зависимости от выбранной стрелки}

#80: Begin {стрелка вниз}

Inc(y); {увеличиваем координату курсора}

Inc(n1); {Увеличиваем номер записи}

If y>FileSize(f1)-p {Если координата курсора станет больше размера файла}

Then Begin {что может быть после удаления записей, или просто}

y:=FileSize(f1)-p; {файл размером меньше страницы, то курсор не должен}

Dec(n1); {передвигаться дальше вниз по экрану и номер удал.}

End {записи не должен увеличиваться}

Else Begin

If y>24 {Если курсор в самом низу экрана (если файл размером}

Then Begin {больше страницы), то}

y:=24; {"Удерживаем" его внизу}

Inc(n); {Увеличиваем номер записи для вывода (скроллинга)}

If n>(FileSize(f1)-24) {Если номер зап. больше последней "порции" вывода}

Then n:=FileSize(f1)-24; {оставляем равным номеру записи, с которого}

End; {выводится на экран последняя "порция" вывода}

End;

End;

#72: Begin {стрелка вверх}

Dec(y); {Уменьшаем координату курсора}

Dec(n1); {Уменьшаем номер записи}

If y<1 {Если координата курсора < 1}

Then Begin {(начало условия)}

y:=1; {"Удерживаем" его в самом верху}

dec(n); {Уменьшаем номер записи для вывода (скроллинга)}

If n<0 Then {Если номер записи < 0}

Begin n:=0; {Фиксируем номер записи вывода}

n1:=0; {Фиксируем номер удаляемой записи }

End;

End; {(конец условия)}

End;

End;{case}

End;{-----------------Конец процедуры Survey------------------}

Procedure Delzap(Var f1:ff;Var n1:Integer);{Процедура удаления записей}

Var

st:String; {Строка перезаписи}

Size,i:Integer; {Размер файла без удаленных}

Begin

i:=n1; {Запоминаем номер удаленной записи}

Reset(f1); {Устанавливаем указатель в начало файла}

size:=filesize(f1)-p; {Находим размер файла без удаленных записей}

While i< size-2 Do {Т. к. читаем с последующей записи, а пишем}

Begin {в предыдущую, то ограничиваем цикл до последней допустимой}

seek(f1,i+1); read(f1,st); {Читаем с последующей записи}

seek(f1,i); write(f1,st); {Пишем на предыдущую, имитируя удаление}

inc(i); {Переходим на следующую запись}

End;

End;{-----------------Конец процедуры Delzap------------------}

BEGIN

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

Text_Type(f,f1); {Переписываем из текстового файла в типизированный файл}

n:=0; {Устанавливаем исходный номер записи}

y:=1; {Устанавливаем начальную координату курсора}

p:=0; {Начальное значение счетчика удаленных записей}

Repeat {Повторяем}

Write_Con(f1,n,p); {выводить на экран с n-ой записи}

Survey(f1,y,n,n1,ch); {пересчитывать номер записи в зависимости}

{от выбора направления просмотра}

If ch=#13 Then {Если нажали клавишу ENTER для удаления}

Begin

Delzap(f1,n1); {Удаляем запись из файла}

Inc(p); {Подсчитываем кол-во удаленных записей файла}

End;

Until ch=#27; {пока не выберем клавишу Esc - условие выхода}

Rewrite(f);

Type_Text(f,f1); {из типизов. файл в текст.}

Close(f);

Close(f1);

END.

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

5.3.1 Теоретические сведения.

Нетипизированные файлы относятся к двоичным файлам и представляют простую линейная зависимость.

Нетипизированные файлы используются, если:

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

2) Обработка файла не зависит от характера хранящейся информации. Например, при создании копии файла.

Структура нетипизированного файла:

1) Определяется программистом путем указания размера записи.

В процедуре Reset (<ф.п.>,<размер записи в байтах>):

ѕ Reset(F,1); размер записи 1 байт

ѕ Reset(F); по умолчанию - 128б

ѕ Reset(f,RecSize); RecSize - задается ранее

2) Так как нетипизированный файл - последовательность байт, то минимальный размер записи - 1б.

3) Размер не обязательно должен быть кратен размеру файла, т.к. за одно обращение к процедуре чтения или записи можно записать или прочитать любое число записей, т.е. блоком <=64б.

4) Никаких специальных символов конца записи нет.

Основные правила работы с нетипизированными файлами:

1) Тип данных файла может не соответствовать типу переменной, в которую читаются данные. (Компилятор не контролирует)

2) Нумерация записей начинается с 0.

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

4) Доступ к записям последовательный и прямой.

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

6) При прямом доступе к записям, используя Seek(F,N), запись и считывание выполняется, начиная с текущей позиции указателя.

Алгоритм обработки нетипизированных файлов:

1). Описание файловой переменной Var F:File;

2). Связывание файловой переменной с именем файла Assign(F,'Fname');

3). Открытие файла: Reset(F,1), Reset(F); Reset(F,RecSize);

4). Закрытие файла Close(F);

Чтение из нетипизированного файла.

Для чтения из нетипизированного файла используется процедура

BlockRead(<ф.п.>, типа File

<переменная чтения> , любого типа

<число считываемых записей>, последние 2 -

<число фактически считанных записей >); типа Word

BlockRead(F, Buf, Count, Result);

Запись в нетипизированный файл.

Для записи в нетипизированный файл используется процедура

BlockWrite(<ф.п.>,<Переменная чтения (любого типа)> ,

<Число записываемых записей>,

<Число фактически записанных записей >);

BlockWrite(F,Buf, Count, Result);

Нужно помнить:

1) При записи на диск, если Result< Count, значит на диске нет свободного места. Если Result опустить, то произойдет ошибка ввода- вывода.

2) При создании жесткой копии файла часто используют такую пару: BlockRead(F,Buf, Count, Result); BlockWrite(F,Buf, Result ,Result1); - в файл записывается не предполагаемое, а истинное количество прочитанных записей.

3) При прямом доступе, если используется Seek(F,10) - указывается на 11-ый блок (нумерация с 0), где размер блока (Count * RecSize) или SizeOf(Buf)).

5.3.2 Задачи.

Задача №1 Прочитать информацию из текстового файла как нетипизированного.

Справка.

1) Не всегда нужно использовать 4-ый параметр.

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

3) Для полной комфортности работы с программой нужно предусмотреть:

ѕ проверку наличия файла;

ѕ задержку вывода на экран. Сделай сам.

Uses Crt;

Var

F: File; {файловая переменная}

Fname, St: String; {имя файла, переменная чтения}

BEGIN

ClrScr;

Write(`Введите имя файла: ');Readln(Fname);

Assign(F, Fname); Reset(F,1); {открываем файл с размером записи 1б}

While not Eof(F) do

Begin

BlockRead(F,St,SizeOf(st));{читаем в строку}

Writeln(st); {выводим на экран}

End;

Close(F);

END.

Задача №2 Переписать информацию из любого файла как нетипизированного в другой.

Справка.

1) За одно обращение в переменную Buf считывается (Count * RecSize) байт. Поэтому Buf >=Count * RecSize, но не больше 64кБ. Все зависит от размера записи, числа записей и буфера. Если размер буфера равен 2000, размер записи -20, число записей 100, то за одно чтение считывается (100*20) =2000 б.

2)

2000б 2000б 2000б <2000

Сколько заказали, Count= Заказали Count, а осталось меньше и столько и прочитали Result в Result записался остаток.

(Count<> Result)

3) В данном случае параметр Result обязательный потому что, если будет попытка прочесть больше, чем осталось в файле (Count > Result ), а Result отсутствует, то произойдет ошибка ввода- вывода. Поэтому, нужно избирательно относиться к этому параметру:

ѕ в 1-ой задаче его можно опустить;

ѕ во 2-ом без него «лучше не рисковать».

3) Обычно Buf описывается как строка или одномерный массив типа Byte или Char.

Uses Crt;

Const

RecSize=20;

Var

F,F1: File; {Файловst переменнst}

Fname, Fname1: String; {Им файла}

...