Краткие теоретические сведения. Организация работы с файлом

Организация работы с файлом

С файловой системой Паскаля связано понятие буфера ввода-вывода.

Ввод и вывод информации с диска и на диск осуществляется через буфер. Буфер ввода-вывода – это область памяти, отводимая при открытии файла. Буфер будет заполняться информацией, пока не заполнится весь, и только тогда произойдет «сброс» информации на диск. Аналогично при чтении из файла считывается не столько, сколько запрашивается, а сколько уместится в буфер.

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

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

Организация работы с файлом

Структурно файл организован как последовательность элементов.

									…
1

Последовательный файл

Файл – это линейная структура, элементы в нем лежат один за другим. В файле не может быть «дыр».

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

После работы с последним элементом файла логическая функция

EOF (Имя_Формального_Файла) выдает значение True.

Каждый цикл работы с файлом содержит, как правило, четыре действия:

1. Связывание формального и фактического файлов.

2. Открытие файла (для записи или для чтения).

3. Непосредственно работа с файловыми данными (запись в файл или

чтение из файла).

4. Закрытие файла.

Запись в файл

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

Элементы могут добавляться только к концу последовательности

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

Запись в файл

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

Rewrite (Имя_Формального_Файла).

Эта операция одновременно уничтожает всю информацию, имеющуюся в файле.

Запись в файл осуществляется поэлементно с помощью процедуры

Write (Имя_Формального_Файла, Переменная_Для_Записи).

Записать в файл можно только весь элемент (компонент) целиком

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

Var
F: Text;	{ Объявляем файловую переменную f } { вводим формальный файл типа «Текст»}
Ch: Char;	{ Объявляем переменную символьного } { типа для записи в файл }
Begin
Assign (f, ‘C:\Data.txt’);	{ Связываем формальный файл f с } {фактическим, имеющим имя Data.txt и } {расположенном на диске С }
Rewrite(f);	{ Открываем файл для записи }
Ch:= Readkey;	{ Вводим символ с клавиатуры }
Write (f, ch);	{ Записываем в файл f значение } { переменной ch }
Close (f);	{ Закрываем файл f }
End.

Чтение из файла

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

Reset (Имя_Формального_Файла).

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

0

Если файл, который мы открываем для чтения пуст (не содержит ни одного элемента), то логическая функция EOF (Имя_Формального_Файла) выдаст значение True.

Чтение из файла осуществляется поэлементно с помощью процедуры

Read (Имя_Формального_Файла, Переменная_Для_Чтения).

................

Var
F: Text;	{ Объявляем файловую переменную f } { вводим формальный файл типа «Текст» }
Ch: Char;	{ Объявляем переменную символьного } { типа для записи в файл }
Begin
Assign (f, ‘C:\Data.txt’);	{ Связываем формальный файл f с } { фактическим, имеющим имя Data.txt } { и расположенном на диске С }
Reset(f);	{ Открываем файл для чтения }
Read (f, ch);	{ Читаем из файла f элемент в } { переменную ch }
... Close (f);	{ Закрываем файл f }
End.

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

Файловые типы языка Паскаль

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

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

типизированные (компонентные) файлы (типа File of <Тип>...);

нетипизированные файлы (типа File).

Работа с этими типами файлов отличается друг от друга.

Обычно все файлы считаются файлами последовательного доступа. Однако, к типизированным файлам (File of <Тип>...) и файлам без типа (File) помимо процедур, обеспечивающих последовательный доступ, можно применить процедуры прямого доступа

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

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

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

Для всех типов файлов минимальной единицей хранения данных в них является байт

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

Общие процедуры работы с файлами

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

Процедура или функция	Назначение
Assign (Var f; FileName: String)	Предназначена для связывания файловой переменной f (формальный файл) с физическим файлом на диске, путь к которому хранится в переменной FileName
Close (Var f)	Предназначена для закрытия файла f
Reset (Var f)	Открывает файл f для чтения, устанавливает указатель на начало файла
Rewrite (Var f)	Открывает файл f для записи, устанавливает указатель на начало файла, стирает предыдущее содержимое файла, если оно было
Erase (Var f)	Предназначена для удаления файла f, файл при этом должен быть закрытым
Rename (Var f; NewName: String)	Предназначена для переименования файла f, файл при этом должен быть закрытым. В NewName записывается новое имя файла
EOF (Var f): Boolean	Функция выдает результат True, если достигнут конец файла f, т.е. при прочтении последней записи

Процедура связывания

Assign (Var f; FileName: String)

Assign (Имя_Формального_Файла, Имя_Фактического_Файла)

устанавливает связь между формальным файлом (файловой переменной f заданного типа) и фактическим файлом (физическим файлом MS DOS), имя которого хранится в строковой переменной FileName. Строка FileName содержит имя файла, или полный путь к этому файлу и имя, или имя стандартного устройства.

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

Assign (f, ‘Data.txt’);	{ Связываем файл f с файлом Data.txt, } { расположенном в текущем каталоге}
Assign (f, ‘A:\ MyProg.pas’);	{ Связываем файл f c файлом } { MyProg.pas, расположенном на } { диске А: }
FileName:= ’D:\Gr614\Inanov.doc’;
Assign (f, FileName);	{ Связываем файл f c файлом } { Ivanov.doc, расположенном на диске D} { в каталоге Gr614. Имя файла и путь } { к нему хранятся в строковой } { переменной FileName }
Assign (f, ‘PRN’);	{ Связываем файл f с принтером }

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

Assign (f, ‘Data.txt’);	{ Связываем файл f с файлом Data.txt, } { расположенном в текущем каталоге }
Rewrite (f);	{ Открываем файл f для записи }
Write (f, v);	{ Пишем в файл f данные через переменную v}
Close (f);	{ Закрываем файл f }
Reset (f);	Открываем файл f для чтения }
Read (f, v);	{ Читаем из файла f данные через } { переменную v }
Close (f);	{ Закрываем файл f (Обязательное } { закрытие) }
Rename (f, ‘New.dat’);	{ Даем файлу f новое имя «New.dat» }
Erase (f);	{ Уничтожаем файл (удаляем с диска) }

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

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

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

Процедура открытия

Процедура открытия

Reset (Var f)

Reset (Имя_Формального_Файла)

открывает формальный файл для чтения.

Процедура открытия

Rewrite (Var f)

Rewrite (Имя_Формального_Файла)

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

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

Работа с файлом (запись в него или чтение) может производиться только после выполнения процедуры открытия (и только после нее!). Открытие одного и того же файла в программе может производиться сколько угодно раз. При этом закрытия файла не требуется.

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

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

Процедура закрытия

Процедура

Close (Var f)

Close (Имя_Формального_Файла)

закрывает открытый формальный файл f.

Попытка закрыть уже закрытый файл приведет к ошибке

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

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

Закрытие файла гарантирует сохранность и полноту заполнения файла

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

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

Процедура переименования

Процедура

Rename (Var f; NewName: String)

Rename (Имя_Формального_Файла, Новое_Имя_Файла)

переименовывает фактический файл, связанный с формальным файлом f, и присваивает ему новое имя NewName.

Новое имя файла хранится в строковой переменной, должно быть уникальным и не должно содержать символов шаблонов «*» и «?»

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

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

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

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

Var f: file of String;	{ Объявляем файловую переменную f } { типа File of }
S: String;	{ Объявляем переменную S строкового} { типа для чтения в нее из файла }
Begin
Assign (f,'Ivanov.pas');	{ Связываем формальный файл f с } { фактическим, имеющим имя Ivanov.pas}
Reset (f);	{ Открываем файл f для чтения }
Read (f, S);	{ Читаем из файла f элемент (строку) в } { переменную S }
Close (f);	{ Закрываем файл f }
Rename (f,'Petrov.pas');	{ Переименовываем файл. Даем файлу } { новое имя Petrov. pas }
End.

Если в имени файла указывается путь к нему, то и у нового файла (в новом имени) должен быть указан этот же путь, т.к. процедура Rename предусматривает только переименование, но не перенос файла на новый диск.

Таким образом, если формальный файл f был связан с фактическим, имеющим имя ‘Ivanov.pas’ и расположенным на диске С:, то попытка переименовать его в ‘Petrov.pas’ и расположить на диске А: приведет к ошибке.

Процедура удаления

Процедура

Erase (Var f)

Erase (Имя_Формального_Файла)

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

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

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

Конструкция Assign (f, FileName); Erase (f); позволит удалить с диска фактический файл с именем FileName. Если файл с таким именем не существует, произойдет ошибка выполнения.

Функция анализа состояния файла

Логическая функция анализа состояния файла

EOF (Var f): boolean

EOF (Имя_Формального_Файла): boolean

проверяет закончился ли файл и возвращает True, если при чтении был достигнут конец файла и False в противном случае. Функция возвращает True, если открываемый файл пуст или прочитан последний элемент файла. Состояние EOF автоматически обновляется при каждом обращении к процедуре ввода данных. Для получения своего значения функция должна работать только с открытым файлом.

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

While not EOF(f)do	{ Пока не конец файла f }
Read(f,...)	{ Читаем из файла f }

Эта конструкция гарантирует, что как только будет прочитан последний элемент файла, т.е. будет достигнут конец файла, чтение из него прекратится, чего не гарантирует конструкция с использованием цикла Repeat Until. Для пустого файла такая конструкция вызовет ошибку.

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

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

Текстовые файлы организованы по строкам, в конце строки всегда находится специальный символ EOLN (End Of LiNe) - #13 (код 13 – CR – возврат каретки). Этот код может быть объединен с символом «прогона строки» #10 (код 10 – LF). Доступ к каждой строке возможен лишь последовательно, начиная с первой (см. рис. 4.4).

В конце текстового файла всегда находится специальный символ, называемый маркер конца файла (EOF - End Of File) - #26 (код 26 – обозначается символом ^Z). Пустой файл содержит только код 26.

Для указания типа таких файлов в языке Паскаль существует заранее определенный стандартный идентификатор Text.

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

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

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

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

#13#10 Пример текстового файла #13#10 В файле могут храниться символьные строки #13#10 Или числа #13#10

Матрица #13#10

123 281 371 99 #13#10 4567 777 328 67 #13#10 15.44 821 3.14 10 #13#10 -0.456 #13#10

Конец текстового файла#13#10

#26

Коды #13, #10, #26 – управляющие, они занимают в файле по одному символу, на экран и принтер они не выводятся, но управляют процессом вывода.

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

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

Var
F: Text;	{Объявляем файловую переменную f типа Text }
Ch: Char;	{ Объявляем вспомогательную переменную Ch } {символьного типа, для чтения в нее из файла }
Begin
Assign (f,‘Data.txt’);	{ Связываем формальный файл f с } {фактическим, имеющим имя Data.txt
Reset(f);	{Открываем файл для чтения }
Read (f, Ch);	{Читаем из файла f первый символ в} {переменную Ch }
Close (f);	{Закрываем фай }
End.

Текстовые файлы в Паскале - это не File of Char. Равенство между этими файлами можно поставить лишь со значительными оговорками.

Чтение и запись в текстовых файлах

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

Чтение

Read (Var f; Список ввода)

Read (f, Сh); или Read (f, a,b,c,d,...); и

ReadLn (f, S); или ReadLn (f, a,b,c,d,...);

Запись

Write (Var f; Список вывода)

Write (f, Сh); или Write (f, a,b,c,d,...); и

WriteLn (f, S); или WriteLn (f, a,b,c,d,...);

Имеются две стандартные файловые переменные для текстового файла: Input и Output. Переменная Input по умолчанию связана с клавиатурой, а Output – с экраном дисплея. Эти устройства ввода-вывода автоматически открываются при запуске программы и закрываются после окончания ее работы. Если при работе с файлами типа Text в процедуре или функции не указана файловая переменная, считается, что используется файловая переменная Input или Output.

Список ввода – это перечисленные через запятую имена переменных, в которые помещается введенные значения. Количество элементов в списке ввода или вывода может быть любым, в том числе и пустым.

Оператор Read (a, b) полностью эквивалентен оператору Read (Input, a, b), а оператор Write (a,b) – оператору Write (Output, a,b).

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

Данные сложных структур (массивы, записи, множества и др.) вводятся только по элементам или по полям, если это запись.

В текстовый файл нельзя записать весь массив или всю запись целиком. Попытка записать Read (f, Vector) или Read (f, Rec) приведет к ошибке!

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

При чтении из файла строк можно воспользоваться процедурой ReadLn. При вводе строки с клавиатуры в конце ввода пользователь нажимает клавишу ввода, и в файл записывается сначала вся строка и затем код конца строки (#13). Процедура ReadLn (f, S) позволит прочитать из файла f в строковую переменную S всю строку целиком и распознает «разделитель», т.е. признак конца строки. Сам разделитель в строку не считывается. Если же в файл вводились строки одинаковой длины последовательно одна за другой без использования кода #13 в качестве разделителя, то процедура Read(f, S) прочитает в строку S количество символов, равное объявленной длине строки S.

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

Так, при попытке чтения строки из текстового файла, содержащей числовые значения

333 444 555 777,

оператор ReadLn(f, a, b); поместит в числовые переменные a и b первые два числа и переведет позицию в начало следующей строки. Два последних числа (555 и 777) прочитаны не будут.

Вызов ReadLn (f) вообще пропустит строку в файле. Вызов ReadLn без указания файла будет ждать нажатия клавиши ввода.

Процедуры Write / WriteLn

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

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

Процедура WriteLn выводит данные в текущую строку и закрывает ее, при этом вывод другой строки будет происходить с первой позиции следующей строки. В конец строки дописывается символ конца (#13, объединенный с #10).

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

Чтение и запись в компонентном файле

Для компонентных файлов обе процедуры и Reset и Rewrite устанавливают режим «чтение/запись» в соответствии со значением предопределенной системной переменной FileMode (оно по умолчанию равно 2), т.е. независимо от выбора процедуры открытия, файл открывается и для чтения и для записи.

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

Этот порядок нарушится только в том случае, если значение FileMode будет равно 0, что соответствует режиму «чтение», или равно 1, что соответствует режиму «запись».

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

Read (Var f; Переменные типа содержимого файла)

Процедура чтения очередного компонента из файла f.

Write (Var f; Переменные типа содержимого файла)

Процедура записи очередного компонента в файл f.

Reset(f);	{ Открываем файл для чтения }
Read (f, V);	{ Читаем из файла f первый элемент в } { переменную V }
Read (f, a,b,c,d);	{ Читаем из файла f четыре первых элемента в { переменные a, b, c, d } { Переменные V, a, b, c, d должны быть } { такого же типа, как компонент файла }
Rewrite(f);	{ Открываем файл для записи }
Write (f, V);	{ Пишем в файл f элемент, хранящийся в } { переменной V }
Write (f, a,b,c,d);	{ Пишем в файл f четыре элемента, xранящиеся} { в переменных a, b, c, d } { Переменные V, a, b, c, d должны быть } { такого же типа, как компонент файла }

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

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

При считывании из файла действие буферной переменной подобно окошку, через которое мы смотрим на файл. Процедуры Read и Reset передвигают его вперед-назад по файлу. Read сдвигает вперед на один элемент, Reset - в начало файла.

Если компонентом файла является сложная структура (массив, запись), то чтение и запись происходит целиком всего компонента

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

В типизированном файле нет понятия (символа) конца строки или конца файла, как в текстовом файле, поэтому для записи или чтения не имеют смысла процедуры WriteLn и ReadLn

Их использование приведет к ошибке

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

Типизированный файл, компонентом которого является строка: File Of String [ 30 ] также не похож на текстовый файл, т.к. даже если строки будут содержать меньше, чем 30 символов, все равно для каждой выделится память в 31 байт (30 - на хранение символов строки и 1 - на хранение ее истинной длины). Часть строки будет заполнено нужными символами, в остальной части будет «мусор».

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

Лабораторная работа №15 (2 часа)

Тема: Компиляция и тестирование программы (См. лаб. раб. №14) с использованием файловых типов данных.

Цель: Приобрести навыки проведения компиляции и тестирования программы.

Задание: Провести компиляцию и тестирование программы, разработанной в ходе выполнения лабораторной работы №14.

Рекомендуемая литература

Основная

Канцедал С.А. Алгоритмизация и программирование. М.: форум – Инфра – М, 2008 – 352 с.

Дополнительная

Попов И.И., Партыка Т.Л. Языки программирования. М.: форум – Инфра-М, 2008 – 4 - с.

Голицына О.П., Попов И.И. Основы алгоритмизации и программ-

мирования. М.: форум, 2008 – 432 с.

Попов И.И., Партырка Т.Л. Языки программирования. М.: Инфра, 2008-300 с.

Семакин И.Г., Шестаков А.П. Основы программирования: Учебник. – М.: Мастерство, 2006.

Грызлов В.И., Грызлова Т.П. Турбо Паскаль 7.0. – М.: ДМК, 2007.

Немнюгин С.А. Тurbo Pascal. – CПб.: Питер, 2006.

КОРОЛЁВСКИЙ КОЛЛЕДЖ