Программирование на языке Турбо Паскаль

readln;

end.

3. Запись данных в файл

А теперь перейдём к процедурам записи в файл. Перед тем как что-либо

записывать, нужно создать новый (пустой) файл или стереть содержимое

существующего. Для этого используется процедура

rewrite(TxtFile: text);

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

помощью assign. Если файл не существовал, то rewrite создаст его, если

существовал, то содержимое будет стёрто. В любом случае файл будет пустым,

а указатель записи стоит на начале файла.

Для записи используются процедуры

write(TxtFile: text, p1: type1, p2: type2, ... pN: typeN);

writeln(TxtFile: text, p1: type1, p2: type2, ... pN: typeN);

Здесь в качестве параметров p1, p2, ... pN можно использовать не только

переменные, но и выражения: числовых типов, строковые, символьные и

логические (boolean). В отличие от write, writeln после записи в файл

значений p1, p2, ... pN переводит указатель записи на начало новой строки;

writeln с одним параметром (текстовый файл) лишь переводит указатель на

новую строку.

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

записаны файл нужно закрыть с помощью close.

Пример 2 (запись в файл). Пусть дан произвольный текстовый файл,

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

соответствующей строки исходного файла:

program WriteLength;

var f1,f2: text;

s: string;

begin

assign(f1,'writelen.pas'); reset(f1);

assign(f2,'result.txt'); rewrite(f2);

while not eof(f1) do begin

readln(f1,s);

writeln(f2,length(s));

end;

close(f1); close(f2);

end.

Ещё один способ записи — это открытие для добавления информации в конец

файла. Для этого используется процедура

append(TxtFile: text);

Если файл открыт с помощью append, то всё его содержимое сохраняется.

При завершении дописывания в конец файла его также следует закрыть с

помощью close.

Лекция 13. Двоичные файлы

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

элементов, записанных на диске. В отличие от текстовых файлов, в двоичных

нет разбиения на строки, файл напоминает массив, с той лишь разницей, что

доступ к элементам может быть только последовательным. Для того, чтобы

определить, достигнут ли конец файла, по-прежнему используется функция eof.

Функция eoln, очевидно, здесь неприменима.

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

открытия, закрытия и привязки, что и для текстовых: Append, Assign, Close,

Reset, Rewrite. Кроме того, появляется процедура Truncate(var f: file),

которая уничтожает всё содержимое файла, находящееся после текущего

указателя чтения.

Двоичные файлы будем делить на типизированные и нетипизированные.

1. Типизированные файлы

Файлы этого вида состоят из элементов одинакового типа, то есть в них

нельзя записывать (или читать) значения переменных разных типов, в отличие

от текстовых файлов.

Объявляются типизированные файлы так:

var f: file of тип_элемента;

В качестве типа элемента можно использовать как простые типы, так и

структурированные (массивы, записи и т.п.).

2. Нетипизированные файлы

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

хранения разнородной информации, а не одинаковых элементов. В него можно

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

(простых типов, массивов, записей, и т. п.). Описываются переменные,

соответствующие нетипизированным файлам, следующим образом:

var f: file;

Для чтения и записи процедуры read и write не подходят. Используются

такие процедуры:

1. BlockRead(var f: file; var buf; count: word [; var result: word]); (

читает в переменную Buf count записей из файла, переменная result

показывает сколько записей было скопировано в действительности. Под

записью понимается «кусок» файла в несколько байт, размер записи можно

установить при открытии файла, например: reset(f,1).

2. BlockWrite(var f: file; var buf; count: word [; var result: word]); (

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

используется rewrite, то во втором её параметре также можно указать

размер записи.

Лекция 14. Модули в Турбо Паскале

В Турбо Паскале допускается разбивать программы на части и хранить эти

части в отдельных файлах на диске. Кроме основной программы появляются так

называемые модули, которые предоставляют основной программе или другим

модулям свои переменные, константы, типы, процедуры, функции и т. п. Чтобы

использовать модуль в программе, нужно указать его имя после uses.

При написании модуля сначала описывается то, что он предоставляет для

общего пользования (секция интерфейса), а затем ( как он устроен (секция

реализации). Иногда существует секция инициализации, где записаны действия,

которые выполняются при подключении этого модуля. Записывается это всё

следующим образом:

unit MyUnit;

interface

(*Интерфейсная секция*)

uses ...;

const ...;

type ...;

procedure ...; {Только

function ...; заголовки}

implementation

(*Секция реализации*)

uses ...;

const ...;

type ...;

procedure ...; {Реализация всех описанных

begin процедур и функций}

...

end;

function ...;

begin

...

end;

[begin]

(*Секция инициализации*)

end.

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

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

Процедуры и функции здесь только описываются, но не реализуются, то есть не

записываются тела процедур и функций (begin ... end;). В секции реализации

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

типы, процедуры и функции, которые «видны» только внутри этого модуля,

никакой другой модуль или программа на может ими пользоваться. Здесь же

обязательно должны быть записаны все процедуры и функции (полностью).

Параметры (в скобках) после имени процедуры и функции в секции реализации

можно не указывать.

Секция инициализации содержит те действия, которые должны выполняться

когда наш модуль подключается к программе, то есть до того как начнёт

работать сама программа. Модуль graph, например устанавливает в секции

инициализации значения по умолчанию цвета линий и фона, стиль линий, стиль

заливки т.п.

При сохранении модуля ему нужно дать такое же имя, как и после unit в

тексте модуля. Имена файлов, содержащих модули, должны иметь расширение

«pas», также как и программы.

Рассмотрим пример. Наш модуль предназначается для операций с трехмерными

векторами:

unit Vectors;

interface

type tVec3D = record

x,y,z: real;

end;

procedure VecAdd(a,b: tVec3D; var c: tVec3D);

procedure VecSub(a,b: tVec3D; var c: tVec3D);

procedure VecMultNum(k: real; a: tVec3D; var b: tVec3D);

function ScalarProduct(a,b: tVec3D): real;

implementation

procedure VecAdd(a,b: tVec3D; var c: tVec3D);

begin

c.x:=a.x+b.x;

c.y:=a.y+b.y;

c.z:=a.z+b.z;

end;

procedure VecSub(a,b: tVec3D; var c: tVec3D);

begin

c.x:=a.x-b.x;

c.y:=a.y-b.y;

c.z:=a.z-b.z;

end;

procedure VecMultNum(k: real; a: tVec3D; var b: tVec3D);

begin

b.x:=k*a.x;

b.y:=k*a.y;

b.z:=k*a.z;

end;

function ScalarProduct(a,b: tVec3D): real;

begin

ScalarProduct:=a.x*b.x+a.y*b.y+a.z*b.z;

end;

end.

В программе наш модуль можно использовать, например, так:

program xxx;

uses Vectors;

var v1,v2,res: tVec3D;

...

begin

...

VecMultNum(0.2,v1,res);

VecSub(v2,res,res);

{в результате res = v2-0.2(v1}

...

end.

В случаях, когда несколько модулей содержат объекты с одинаковыми

именами, обращаться к ним нужно с указанием имени модуля: . . Пусть, например, модули unit1 и unit2 содержат процедуры с

одинаковыми именами proc1, тогда обращаться к ним следует так: unit1.proc1;

и unit2.proc2; .

Преимущества модулей:

1. Средства, взятые из модулей позволяют не повторять в программах одни и

те же фрагменты.

2. Переменные, процедуры и другие объекты можно скрыть в секции

реализации, если их необдуманное выполнение может испортить программу.

3. Модули компилируются отдельно от главной программы, поэтому при

компиляции всей программы обрабатывается только главная программа

(меньшие затраты времени при отладке программ). Это особенно важно для

больших программ.

4. Большая программа становится более понятной, если разные её части

расположить в разных модулях, в соответствии с их назначением.

Лекция 15. Динамические переменные

Все известные нам на данный момент переменные являются статическими, это

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

течение всего времени её работы переменные занимают отведённые им участки.

Иногда такой подход может оказаться невыгодным. Например, при хранении

табличных данных в виде массива, приходится заводить массив большого

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

В результате часть памяти, занятая под массив, не используется. В подобных

задачах хотелось бы использовать столько памяти, сколько необходимо в

каждый конкретный момент времени, то есть распределять память динамически.

В Турбо Паскале есть возможность создания динамических переменных (то

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

по мере необходимости). Для этого в программе объявляют не саму переменную

нужного нам типа, а указатель на эту переменную, например:

var p: ^real;

здесь p ( имя переменной-указателя; знак "^" показывает, что p является не

обычной переменной, а указателем; real ( тип той переменной, на которую

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

места в памяти, где будет храниться сама динамическая переменная (в нашем

случае число типа real).

Для всех динамических переменных в памяти отводится пространство,

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

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

делается с помощью процедуры New, например:

New(p);

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

real, обратиться к ней можно, записав p^, например p^:=123.5.

Если потребуется изменить значение указателя, например, заставить его

указывать на другую переменную, то старую переменную следует уничтожить, то

есть объявить занимаемую старой переменной память свободной. Если этого не

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

памяти объявлено занятым, а получить к нему доступ уже невозможно).

Уничтожение динамической переменной выполняется процедурой Dispose:

Dispose(p);

Рассмотрим теперь операции, которые можно выполнять над указателями.

1. Присваивание. Указателю можно присваивать значение другого указателя

такого же типа, а также значение nil, которое означает «ни на что не

указывает». В указатель можно также положить адрес какой-либо

переменной, например: p:=Addr(a); или p:=@a; хотя необходимость в этом

возникает редко.

2. Сравнение. Два указателя можно сравнивать только на равенство (или

неравенство). Можно сравнивать указатель с nil, с адресами переменных.

С динамическими переменными можно выполнять все действия, разрешённые

для статических переменных, например:

if p^ >= q^ then p^ := q^;

Рассмотрим теперь несколько искусственный пример использования

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

статических переменных:

var pa,pb: ^real;

begin

new(pa); new(pb);

write('Введите a: '); readln(pa^);

write('Введите b: '); readln(pb^);

writeln('a+b=',pa^+pb^);

dispose(pa); dispose(pb);

readln;

end.

Кроме описанных указателей существуют ещё так называемые

нетипизированные указатели (тип pointer), которые могут служить указателями

на переменные любых типов, однако необходимость в них возникает редко,

поэтому рассматривать их подробно мы не будем.

Динамические структуры данных

Вернёмся теперь к вопросу об экономии памяти при хранении табличных

данных. С использованием указателей можно отказаться от массива и

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

который схематично изображается так:

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

( поле (или поля), содержащие полезную информацию (например фамилии и

номера телефонов), поле, которое изображено ниже Data ( это указатель на

следующую запись. Переменная List также является указателем на запись.

Жирная точка в поле «следующий элемент» в самой последней записи означает,

что там лежит значение nil, чтобы показать, что эта запись ( последняя в

списке.

Для описания списка на Паскале достаточно описать тип указателя на

запись и тип самой записи. Выглядит всё это так:

type tItemPtr = ^tItem; {указатель на элемент}

tItem = record

Data: tData; {полезные данные}

Next: tItemPtr; {указатель на следующий элемент списка}

end;

В первой строке этого объявления бросается в глаза использование

неопределённого типа tItem. Такое исключение из правил в Турбо Паскале

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

и другие связанные структуры из динамических переменных.

Объявить сам список можно как указатель на элемент: var List : tItemPtr;

пока наш список пуст, в List следует положить значение nil. При создании

первого элемента будем выполнять действия New(List); List^.Next:=nil.

В списках всегда хранится ровно столько элементов, сколько нужно; если

какой-либо элемент данных потерял свою ценность, то его всегда можно

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

элемент.

Напишем теперь модуль для работы со списками. В нём содержатся процедуры

первоначальной подготовки списка; добавления элемента в начало списка;

удаления элемента, следующего за указанным; нахождения элемента с заданным

номером; подсчета элементов и очистки списка.

unit Lists;

interface

type tData = record

Name: string[50];

Phone: longint;

end;

tItemPtr = ^tItem;

tItem = record

Data: tData;

Next: tItemPtr;

end;

procedure InitList(var l: tItemPtr);

procedure AddItemToHead(var l: tItemPtr; d: tData);

function DeleteItemAfter(var l: tItemPtr; num: word): boolean;

function Count(l: tItemPtr): word;

function GetItem(l: tItemPtr; num: word; var d: tData): boolean;

procedure ClearList(var l: tItemPtr);

{---------------------------------------------------------------}

implementation

procedure InitList(var l: tItemPtr);

begin l:=nil end;

procedure AddItemToHead(var l: tItemPtr; d: tData);

var p: tItemPtr;

begin

new(p);

p^.data:=d;

p^.next:=l;

l:=p;

end;

function DeleteItemAfter(var l: tItemPtr; num: word): boolean;

var p,q: tItemPtr;

i: word;

begin

i:=1;

p:=l;

while (i<>num)and(p<>nil) do begin

i:=i+1;

p:=p^.next;

end;

if p<>nil then begin

if p^.next<>nil then begin

q:=p^.next^.next;

dispose(p^.next);

p^.next:=q;

DeleteItemAfter:=true;

end

else DeleteItemAfter:=false; {не удалён}

end

else DeleteItemAfter:=false;

end;

function Count(l: tItemPtr): word;

var p: tItemPtr;

i: word;

begin

i:=0;

p:=l;

while p<>nil do begin

i:=i+1;

p:=p^.next;

end;

count:=i;

end;

function GetItem(l: tItemPtr; num: word; var d: tData): boolean;

var p: tItemPtr;

i: word;

begin

i:=1;

p:=l;

while (i<>num)and(p<>nil) do begin

i:=i+1;

p:=p^.next;

end;

if p<>nil then begin

d:=p^.data;

GetItem:=true;

end

else GetItem:=false;

end;

procedure ClearList(var l: tItemPtr);

var p: tItemPtr;

begin

Страницы: 1, 2, 3, 4, 5, 6