Какие типы файлов используются в языке delphi

Обновлено: 04.07.2024

Под словом файл в Delphi (и в любом языке программирования) понимается область внешней памяти ПК ( жесткий диск , дискета, компакт- диск и т.п.), которая имеет имя.

Файлы в Delphi могут обрабатываться различными способами, в том числе и через функции WinAPI . Файлы могут быть трех вариантов:

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

Файлы объявляются следующим образом:

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

После этой функции, мы можем обращаться с переменной f1 как с файлом filename.txt . Однако, если такого файла нет, мы получим ошибку, поэтому перед использованием связывания желательно делать проверку на наличие файла. Такая проверка проводится функцией FileExists() . Ее синтаксис следующий:

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

В дальнейшем, при работе с файлом, может возникнуть исключительная ситуация . Внимание! Такой термин мы встречаем в первый раз, однако он очень важен для понимания. Что такое исключительная ситуация ? Это любая ошибка программы, которая может произойти во время работы. Например, вы открыли какой-то сетевой файл и начали работу с ним. А другой пользователь в это время взял да удалил этот файл . При попытке чтения из несуществующего файла, или записи в него, произойдет ошибка и создастся исключительная ситуация . Если вы не обработаете эту ошибку, то компьютер , скорее всего, намертво повиснет.

Поэтому в любой ситуации, когда имеется риск возникновения исключительной ситуации , программист ВСЕГДА должен ее обработать. Для этого существует блок try-finally-end :

Если наша программа совершила непоправимую ошибку, то код, заключенный в блоке finally выполнится в любом случае. Таким кодом обычно делают закрытие файла . Если даже ошибка и совершится, файл все равно будет закрыт и программа не повиснет, а будет продолжать работу. Приучите себя ВСЕГДА использовать этот блок при работе с сомнительным кодом. Как бы хороша ни была программа , всегда найдется пользователь , который заставит ее сделать ошибку.

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

Создаем новый проект.

Устанавливаем на форму Edit , в поле которого будем писать, куда мы хотим копировать файл . Также над ним можно установить Label , в котором введем: "Укажите папку, куда мы будем копировать".

Устанавливаем на форму кнопку, на которой пишем "Копировать файл ".

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

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

Вот полный листинг этой процедуры:

Теперь разберем этот код и познакомимся с новыми функциями.

После того, как с помощью функций AssignFile() мы связали переменные с файлами, откуда мы собираемся копировать, и куда, мы пользуемся функциями Reset и Rewrite .

Reset открывает файл только для чтения. Все попытки изменить такой файл приведут к ошибке. При открытии файла указатель ( курсор ) устанавливается на начало файла. Эта функция работает немного по- разному с разными типами файлов. В случае нетипизированного файла , функция Reset имеет два параметра – файловую переменную и длину записи в байтах. Мы указали в примере, что наша запись – 1 байт . Так удобней для обработки кода.

Rewrite имеет такие же параметры, что и Reset , но она открывает файл для записи. Причем если файла нет, то он создается, а если есть – перезаписывается. Указатель также устанавливается в первую позицию.

Далее мы "обнулили" переменные типа Integer . Об этих переменных речь впереди, а пока нам нужно, чтобы они были равны друг другу и имели значение 0.

Дальше мы начинаем условный цикл while , где проверяется равенство этих двух переменных.

А вот дальше идет интересная функция BlockRead . Она предназначена для работы только с нетипизированными файлами, для работы с файлами другого типа используют функцию Read и Readln . Функция BlockRead считывает информацию сразу блоками, что значительно ускоряет процесс копирования файлов. Эта функция имеет четыре параметра, причем последний необязателен. Разберемся с этими параметрами.

Переменная файлового типа, ранее связанная с файлом функцией AssignFile() .
Буфер, куда будут записываться прочитанные данные. Поскольку файл нетипизирован, данные могут быть любого типа – символьные, как в текстовом файле, или двоичные, как в программе, то есть, исполняемом файле. В качестве буфера у нас служит массив символов, куда мы эти данные и считываем. Чем больше такой массив, тем больше данных запишется за один раз, и тем быстрее будет происходить копирование. Однако увлекаться увеличением буфера тоже не стоит. В данном случае мы использовали такой размер, какой указан в справочной системе самой Delphi по функции BlockRead . Дальнейшее увеличение размера буфера не приносит заметных преимуществ.
Количество байт, которые нужно прочитать. Здесь мы использовали функцию SizeOf() , которая возвращает размер массива. Тем самым мы указали, что нужно прочитать максимальное количество байт, которое поместится в этот массив.
Необязательный параметр – это переменная целого типа. После чтения данных, в эту переменную заносится количество реально прочитанных байт. Вообще-то количество реально прочитанных байт должно соответствовать количеству указанных байт, которые нужно прочитать. Однако есть несколько исключений. Во-первых, может произойти ошибка чтения данных. Во-вторых, размер реально прочитанных байт может быть меньше заявленного размера, если мы прочитали файл до конца, и последний прочитанный кусочек оказался меньше, чем размер буфера. И в-третьих, он может вовсе равняться нулю, если курсор (указатель) стоит на конце файла.

Итак, мы вызываем функцию BlockRead . Мы указываем файл , из которого нужно читать, буфер , куда нужно поместить прочитанные данные, указываем количество байт , которые нужно прочитать, и даем переменную, куда запишется количество реально прочитанных байт . И если мы прочитали 0 байт , это означает, что мы добрались до конца файла. В этом случае мы выполняем директиву break , которая заканчивает цикл while .

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

Вот и все премудрости копирования файлов! Не забываем, что работа с файлом нередко приводит к ошибке, поэтому ее нужно поместить в блок try..finally..end .

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

В нашем примере осталось пара недостатков. Как копирование файла выглядит с точки зрения пользователя? Он полагает, что, отдав программе команду копировать, он получает точную копию файла, равную оригиналу во всем. А как копирование файла выглядит с точки зрения программиста? Программист понимает, что он открывает исходный файл , откуда будет брать данные, и создает новый файл , куда эти данные он потом запишет. Все хорошо, вот только дата и время создания файла будут разные – копия будет иметь текущую дату. Особой роли это не играет, однако иногда нужно и дату присваивать ту, которую имеет исходный файл . Как это сделать, мы поговорим на "Записи" .

Второй недостаток: мы твердо полагаем, что пользователь ввел в поле Edit адрес в таком формате:

Затем к этому адресу мы добавляем обратный слэш ("\"). А если он сам уже поставил его?:

Delphi site: daily Delphi-news, documentation, articles, review, interview, computer humor.

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

F = file of А; F = Text; F = file,-

Эти три способа соответствуют трем видам файлов, которыми позволяет оперировать Delphi. Речь идет о типизированных, текстовых и нетипизированных файлах. В первом случае использованы ключевые слова file и of, где первое слово говорит о том, что переменная F будет иметь тип file, а второе слово of уточняет тип элементов файла. Если второго слова нет, то тип элементов файла считается неопределенным, и, соответственно, файл называется нетипизированным.

Если при объявлении использовано слово Text, то это говорит о том, что создается специальный текстовый файл. Text - это не зарезервированное слово, а идентификатор стандартного типз данных, как, например, Integer или Real.

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

TArrayl г array of Integer,-TDate=record

Year:1900..2010 end; var

Здесь объявлены пять файловых переменных. Это F1 - нетипизированный файл, F2 - текстовый файл, a F3, F4 и F5 - типизированные файлы. Причем если среди типизированных файлов элементы файла F3 относятся к стандартному типу integer, то элементы файлов F4 И F5 - к типам, объявленным пользователем (тип Tarrayl представляет собой массив целых чисел, а тип TDate - запись).

Хотя разные типы файлов имеют свои особенности, существует и нечто общее. Так, в файле в каждый момент может быть доступен только один элемент. Например, если вернуться к объявленным выше файловым переменным, то в файле F3 одновременно можно иметь доступ только к одному из целых чисел, которые составляют файл; в файле F4 - к единственному массиву; наконец, в файле F5 - к отдельно взятой записи. Кроме того, файлы всех видов завершаются маркером конца файла EoF (от английских слов ""End of File").

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

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

Вот как может выглядеть обращение к процедурам Reset и Rewrite для открытия нетипизированного файла. Reset(F,512); Rewrite(F,256)і

Здесь F - файловая переменная, имеющая тип file. А в качестве второго параметра процедур Reset и Rewrite указаны размеры блоков (в байтах), с помощью которых будет происходить считывание из файла или запись в файл данных. Поскольку этот параметр имеет тип word, его максимальная величина равна 65 535 байт. Если второй параметр процедур Reset и Rewrite не задан, то по умолчанию длина записи считается равной 128 байт.

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

Для работы с нетипизированкыми файлами используются те же процедуры, что и для типизированных, за исключением Read и write. Для обмена данными с нетипизирован-ными файлами применяются специальные процедуры: BlockRead и BlockWrite.

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

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

BlockRead (Var F:File; var Buf; Count.- Integer [; var Result: Integer] )

Здесь F - нетипизироваиная файловая переменная.

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

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

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

Количество считанных блоков (параметр Result) может быть меньше или равно значению параметра Count. Если при вызове процедуры параметр Result не определен и количество считанных блоков окажется не равно значению параметра count, будет зафиксирована ошибка ввода-вывода. При этом должна быть установлена директива компилятора , что обычно делается по умолчанию.

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

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

Здесь F - нет и пизирова иная файловая переменная.

Buf - переменная, ранее объявленная в программе и используемая в качестве рабочего буфера.

Count - выражение или значение, соответствующее количеству записей, которые следует добавить в файл.

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

Количество добавленных записей (параметр Result) может быть меньше или равно значению параметра Count. Если при вызове процедуры параметр Result не определен и количество добавленных записей окажется не равно значению параметра count, будет зафиксирована ошибка ввода-вывода.

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

AssignFile[FromF, inFileName); < Открыть входной файл. >Reset(FromF, 1); ( Размер блока = 1. >

begin AssignFile(ToF, outFileName) ,- < Открыть выходной файл. >Rewrite(ToF, 1);

BlockRead(FromF, Buf, SizieOf (Buf) , NumRead) ; BlockWrite(ToF, Buf, NumRead, NumWritten); until [NumRead - 0) or (NumWritten <> NumRead); CloseFile(FromF);

В разделе var этой программы объявляются две переменные типа file, счетчики NumRead и NumWritten, буфер Buf, представляющий массив символов И имена входного и выходного файлов inFileName и outFileName. Затем в блоке, где размешается программа, открывается входной файл, для чего имя файла, представляющее собой полный путь к файлу, связывается с переменной FromF типа file в процедуре AssignFile. Перед этим происходит ввод имени файла с помощью процедур Write (' inFileName= ' ) и Readln (inFileName 1, где сначала выводится запрос на ввод имени файла, на который нужно ввести полный путь файла. Те же самые действия необходимы для открытия выходного файла. Когда файлы открыты, в цикле repeat перезаписываются данные из одного файла в другой. При этом выход из цикла может произойти по двум причинам: или считан последний символ из входного файла (NumRead=0>, или нет места для записи на диске (NumWrittenoNumRead).

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

В каком виде сохраняются созданные программы? Этот вопрос возникает у любого начинающего программиста. Эта тема заслуживает отдельного внимания. Как известно, в Windows любая программа представляет собой exe-файл, который является исполняемым, т.е. может быть запущен как отдельное приложение. Понятно, что разрабатывая программу, в итоге нужно получить именно exe-файл, чтобы его можно было запустить на компьютере, где не установлена среда, в которой эта программа была создана. В языках программирования для DOS, в частности Turbo Pascal, всё довольно просто - весь программный код сохраняется в один-единственный файл, а в итоге получается exe-файл. Довольно просто и удобно. При переходе в Windows всё становится гораздо сложнее. Оконное приложение Windows не может быть сохранено в одном файле. Если в среде DOS программы можно называть именно программами, то в объектно-ориентированном программировании они называются проектами. Почему проектами? Всё достаточно просто - программа представляет собой совокупность некоторого числа файлов различного типа, определённым образом связанных между собой. Очевидно, что всю эту группу логично назвать проектом.
В этой статье мы познакомимся с самыми основными типами файлов, которые включены в любой проект, созданный на Delphi. На самом деле типов файлов гораздо больше, но эти - базовые.

*.dpr - файл проекта

Это главный файл всего проекта. Если этот файл отсутствует, запустить программу будет невозможно. В файле хранятся все основные параметры приложения, а также информация об окнах, которые в приложение включены. Файл представляет собой свободно читаемый код. Посмотреть содержимое этого файла можно командой меню Project -> View Source. В более новых версиях Delphi файл проекта имеет другое расширение - .bdsproj (в Borland Developer Studio 2006), .dproj (в Delphi 2007 и далее). Обратная совместимость поддерживается.

*.dfm - файл описания формы

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

*.pas - модуль (самостоятельный, либо модуль формы)

Именно этот файл больше всего похож на файл программ Turbo Pascal. В этом файле находится код программы. Модули могут быть отдельными от конкретных проектов - в этом случае их можно подключить к любому проекту и использовать. Как правило, в отдельных модулях находятся вспомогательные функции, либо какие-либо объекты. Помимо этого модуль есть у каждой формы. В результате *.pas-файл неразрывно связан с файлом *.dfm, а форма соответственно описывается этими двумя файлами - один содержит её состояние и объекты, а второй - код программы, относящийся к этой форме. Следует отметить, что модули значительно облегчают процесс написания программы и ориентацию в больших модулях - отдельные элементы большого модуля можно вынести в несколько модулей и просто подключить их к проекту.

*.res - файл ресурсов

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

.dof, .cfg - файлы конфигурации проекта

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

.dcu, .obj - объектные файлы

Эти файлы представляют собой уже скомпилированные модули. При очередной компиляции Delphi создаёт для каждого pas-файла соответствующий dcu-файл. Это существенно ускоряет компиляцию в дальнейшем, т.к. имеющиеся файлы просто включаются в конечный exe-файл, а не обрабатываются заново. OBJ-файлы - это тоже скомпилированные модули, но применяющиеся в С++. При работе в Delphi эти файлы не используются, но при необходимости их можно сформировать.

Файлы, расширение которых начинается со знака тильды ("

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

Работа с проектом

Ну а теперь пришло время рассказать о базовых операциях с проектом, так как ранее речь об этом не шла. Рассмотрим всё по порядку.

Создание нового проекта

Для создания "чистого листа" следует выбрать в меню File -> New -> Application. В разных версиях Delphi содержимое подменю New может немного отличаться, но всё основное присутствует всегда. После этого создаётся новый проект, такой, какой появляется при запуске Delphi.

Открытие существующего проекта (или файла)

Для этого существует команда File -> Open. Выбрав файл *.dpr, откроется проект, а выбрав какой-либо другой файл (например, *.pas или *.dfm) откроется что-либо другое (например, отдельная форма).

Сохранение

С сохранением есть несколько тонкостей. Исходя из того, что проект представляет собой совокупность нескольких файлов, можно сделать вывод, что сохранять нужно все эти файлы, а не какой-то в отдельности. Выбрав File -> Save, Вы сохраните только текущую форму, но не более того, а проект останется "висеть в воздухе". File -> Save As. - стандартный пункт, который делает то же самое, что и Save, только позволяет пересохранить файл (форму) под другим именем. Команда Save Project As. сохраняет файл проекта (*.dpr). Таким образом, чтобы сохранить проект полностью, нужно сохранить каждую из форм и сам проект. Делать это по отдельности достаточно неудобно, поэтому существует команда, облегчающая этот процесс: File -> Save All. При вызове этой команды сначала появится диалог для сохранения формы (если форм несколько, то и диалогов будет несколько), а затем диалог для сохранения проекта. После того, как все диалоги отработали, можно с уверенностью сказать, что проект сохранён полностью.

Меню File содержит все основные команды управления проектом

Железное правило: каждый проект должен быть сохранён в отдельном каталоге!

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

Запуск и остановка программы

Теперь, когда проект сохранён, программу можно и запустить и посмотреть, что же получилось. Ещё одно правило, которое желательно соблюдать: перед запуском программы проект нужно сохранить. Мгновенный вопрос: зачем? Конечно, делать это или нет - решать Вам, но бывают случаи, когда программа зависает (по вине самого программиста например), а с ней зависает и оболочка Delphi. В этом случае ничего не остаётся делать, как "убивать" Delphi через Диспетчер задач Windows. Понятно, что изменения, которые были внесены в проект, теряются. Однако не всё так плохо. Случаи зависания Delphi IDE достаточно редки. Как правило, если программа зависает, Delphi позволяет её просто уничтожить из памяти и продолжить работу. Процесс сохранения проекта перед запуском можно поручить оболочке: меню Tools -> Environment Options. , вкладка Preferences, блок Autosave options - опция Editor files.

Запомните следующие основные горячие клавиши:

Ctrl+F9 - компиляция программы. Что такое компиляция? Говоря простым языком - создание выходного (exe) файла программы. Следует отметить, что имя выходного файла совпадает с именем проекта, т.е. именем *.dpr-файла и не может быть изменено. Выходной файл создаётся в том же каталоге, где расположение *.dpr-файл. Однако компиляция просто "собирает" всю программу, но не запускает её.

F9 - запуск. В отличие от компиляции, это уже полноценный запуск программы из оболочки Delphi, однако не совсем такой, каким является запуск приложения из Windows. Запуск происходит под отладчиком. Но об этом позже.

Ctrl+F2 - остановка выполнения программы. Это именно то, о чём сказано чуть выше. Если нужно экстренно завершить работу программы, нужно активировать какое=-либо из окон оболочки Delphi и нажать это сочетание клавиш. Программа будет остановлена и можно будет безболезненно продолжить работу.

Все эти команды доступны и напрямую из меню: Run -> Run, Project -> Compile, Run -> Program Reset.

Все основные команды управления проектом вынесены также в виде кнопок на панели инструментов:

Свойства проекта

Для проекта можно установить множество разнообразных параметров. Все они находятся в окне Project -> Options. В частности, на вкладке Application можно указать заголовок проекта, который будет отображаться на кнопке программы на панели задач. Совет: всегда прописывайте заголовок своей программе, не оставляйте стандартного "Project1" - это резко бросается в глаза. На этой же вкладке можно выбрать иконку (значок) для приложения - файл *.ico размером 32х32 пикселя. В блоке Output settings можно указать расширение выходного файла. Заполнять это поле не обязательно - по умолчанию файлу присваивается расширение .exe. Однако в некоторых случаях эта настройка бывает полезной. Например, экранные программы-заставки представляют собой те же исполняемые exe-файлы, только имеют расширение .scr. Неудобно каждый раз после внесения изменений в программу, чтобы протестировать заставку, переименовывать файл. А прописав в указанное поле "scr" проблема мигом решится.

Вкладка Application в окне свойств проекта влияет на внешний вид кнопки программы на панели задач

Заключение

В этой статье рассмотрены все базовые навыки для управления проектами. Теперь можно приступить непосредственно к изучению языка и исследованию объектов.

Автор: Ерёмин А.А.

Статья добавлена: 14 апреля 2007

Рейтинг статьи: 4.71 Голосов: 14 Ваша оценка:

Зарегистрируйтесь/авторизируйтесь,
чтобы оценивать статьи.

Для вставки ссылки на данную статью на другом сайте используйте следующий HTML-код:

Ссылка для форумов (BBCode):

Поделитесь ссылкой в социальных сетях:

Комментарии читателей к данной статье

Пока нет комментариев к данной статье. Оставьте свой и он будет первым.

Учебно-методическое пособие с теорией, тестом и лабораторной работой.

Содержимое разработки

Учебно-методическое пособие по теме «Файлы в Delphi».

Аглиуллина Айгуль Ильнуровна

педагог дополнительного образования

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

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

Delphi — это среда быстрой разработки, в которой в качестве языка программирования используется язык Delphi. Язык Delphi — строго типизированный объектно-ориентированный язык, в основе которого лежит хорошо знакомый программистам Object Pascal.

В настоящее время программистам стала доступна очередная версия пакета Delphi - Borland Delphi 7 Studio. Она может работать в среде операционных систем от Windows 98 до Windows XP. Особых требований, по современным меркам, к ресурсам компьютера пакет не предъявляет.

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

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

1. Понятие файла

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

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

В зависимости от типа элементов различают три вида файла:

файл из элементов фиксированного размера (элементами такого файла чаще всего являются записи);

файл из элементов переменного размера (нетипизированный файл) - такой файл рассматривается просто как последовательность байтов;

текстовый файл; элементами такого файла являются текстовые строки.

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

Для работы с файлом, состоящим из типовых элементов переменная объявляется с помощью словосочетания file of, после которого записывается тип элемента:

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

Объявление переменной для работы с нетипизированным файлом выполняется с помощью отдельного слова file:

Для работы с текстовым файлом переменная описывается с типом TextFile:

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

2. Компоненты, работающие с файлами

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

Для начала необходимо упомянуть компоненты Delphi, которые умеют работать с файлами. Они читают и сохраняют своё содержимое, строки типа String, в файл текстового формата. Это компоненты ListBox, ComboBox и Memo, расположенные на первой же вкладке палитры компонентов.

Каждая строка компонентов ListBox и ComboBox является объектом Items[i], а Memo - Lines[i], где i - номер строки, который отсчитывается от нуля. Добавление строк в компоненты выполняется методами Add и Insert:

Рисунок №1. Добавление строк в компоненты

begin
Memo1.Lines.Add('Первая строка');
ComboBox1.Items.Add('Первая строка');
ComboBox1.Items.Add('Вторая строка');
ListBox1.Items.Add('Первая строка');
ListBox1.Items.Add('Вторая строка');
end ;

Метод Add добавляет новую строку в конец. Метод Insert имеет дополнительный параметр, указывающий, после какой строки разместить новую строку. Доступ к строкам осуществляется так:

ComboBox1.Items[0] := 'Первая строка изменилась' ;

ListBox1.Items[1] := 'Вторая строка изменилась' ;

У компонента ComboBox дополнительно есть свойство Text, где (как и у компонента Edit) находится вводимый текст:

ComboBox1.Text := ' Вводимый текст ';

На выделенную в данный момент строку компонента ComboBox указывает свойство ItemIndex типа Integer, то есть это номер выделенной строки. Следовательно, получить саму выделенную строку компонента ComboBox можно следующей конструкцией:

S:=ComboBox1.Items[ComboBox1.ItemIndex];
или, пользуясь оператором присоединения

With ComboBox1 do

Таким способом по нажатию клавиши Enter можно заносить в этот компонент вводимую в строку информацию и удалять нажатием Escape:
выделить на Форме ComboBox и перейти в Инспектор объектов, на вкладку Events. Щёлкните дважды по обработчику OnKeyPress. Система Delphi создаст заготовку обработчика.

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

Впрочем, расширение можно поставить любое, не обязательно .txt, как и вообще без него обойтись. Но расширение .txt позволит легко открыть файл стандартным Блокнотом, что бывает очень удобно на этапе написания программы.
Для загрузки служит метод LoadFromFile:

3. Классическая работа с файлами

Технология работы с файлами в системе Delphi требует определённого порядка действий:

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

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

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

В Delphi реализовано несколько способов работы с файлами. Рассмотрим классический способ. Файловая переменная вводится для указания на файл. Делается это с помощью ключевого слова File :

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

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

var F: File of тип_записи ;

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

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

Для текстовых файлов отдельно укажем, что тип файловой переменной в TextFile, а тип обычной - String.

Для открытия файла нужно указать, где он расположен. Для этого файловая переменная должна быть ассоциирована с нужным файлом, который определяется его адресом. Адрес файла может быть абсолютным, с указанием диска и каталогов ('C:\Мои документы\Мои рисунки\FileName.ini'), или относительным, тогда он создаётся в папке с .exe файлом программы. Для задания относительного адреса достаточно указать имя файла с нужным расширением. Делается это оператором AssignFile:

AssignFile(SaveF, 'C:\Мои документы\Мои рисунки\FileName.ini');

Теперь файл должен быть открыт.

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

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

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

Чтение файла производится оператором Read:

Запись в файл производится оператором Write:

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

then Read(SaveF, SaveV);

Принудительно установить указатель на нужную запись можно оператором Seek(SaveF, N), где N - номер нужной записи, который, как и почти всё в программировании, отсчитывается от нуля:

Seek(SaveF, 49); - установка указателя на 50-ю запись.

При последовательном чтении из файла рано или поздно будет достигнут конец файла, и при дальнейшем чтении произойдёт ошибка. Проверить, не достигнут ли конец файла, можно оператором EOF (аббревиатура End Of File), который равен true, если прочитана последняя запись и указатель находится в конце файла:

while (not EOF(SaveF)) do

Для текстовых файлов вместо Read и Write используются операторы Readln и Writeln, умеющие определять конец строки.

Оператор Truncate(SaveF) позволяет отсечь (стереть или удалить) все записи файла, начиная от текущей позиции указателя, и до конца файла.

В конце работы с файлом его необходимо закрыть. Это делается оператором CloseFile(SaveF) ;

4. Работа с текстовыми файлами

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

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

В результате этого действия поля файловой переменной F инициализируются начальными значениями. При этом в поле имени файла заносится строка 'MyFile.txt'.

Так как файла еще нет на диске, его нужно создать:

Теперь запишем в файл несколько строк текста. Это делается с помощью хорошо вам знакомых процедур Write и Writeln:

Writeln(F, 'Pi = ', Pi);

Writeln(F, 'Exp = ', Exp(1));

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

После работы файл должен быть закрыт:

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

Читайте также: