Файлы прямого и последовательного доступа
| Файл: | текстовый | бестиповой | компонентный |
| Преобразование | + | – | – |
| Прямой доступ | – | + | + |
Независимо от того, какой файл будет использован в программе программист должен соблюдать следующие этапы при работе с файлами:
1. Описание файловой переменной.
2. Установка связи файловой переменной с физическим файлом.
3. Открытие файла для чтения или записи.
4. Выполнение операций ввода-вывода (чтение из файла или запись).
5. Закрытие файла.
Файловый указатель
С каждым файлом связан так называемый файловый указатель. Это неявно описанная переменная, которая указывает на некоторый элемент файла. Все операции производятся с элементом, который определен файловым указателем.
| (0) | (1) | … | (k) | (k+1) | … | |
Рис 33. Файловый указатель
Связь переменной файлового типа с файлом на диске
Для установления связи между файловой переменной и файлом на диске имеется стандартная процедура Assign.
Assign(<имя файловой переменной>, '<имя файла на диске>');
Например, Assign (F1,'D:\INT.DAT');
После установления такого соответствия все операции, выполняемые над переменной F1, будут выполняться над физическим файлом, хранящимся в корневом каталоге на диске D и имеющим имя INT.DAT.
Открытие файла
Файл в каждый момент времени может находиться в одном из двух состояний: либо он открыт только для записи, либо только для чтения.
|
|
|
Под записью в файл понимается вывод результатов программы из оперативной памяти ЭВМ в файл на диске.
Для записи в файл необходимо открыть файл для записи посредством процедуры Rewrite (<имя файловой переменной>).
Для чтения из файла необходимо открыть файл для чтения посредством процедуры Reset (<имя файловой переменной>).
Кроме этих процедур только к текстовым файлам применяется процедура Арреnd (<имя файловой переменной текстового файла>).
Она открывает файл для "дозаписи", помещая файловый указатель в конец файла.
Чтение из файла
Под чтением из файла понимается пересылка данных из внешнего файла, находящегося на диске, в оперативную память.
Собственно чтение данных из файла выполняется процедурой
Read (<имя файловой переменной>, <имя переменной>);
Переменная должна иметь тот же тип, что и компоненты файла. Вам знаком оператор ввода вида Read(<имя переменной>), при этом данные вводятся с клавиатуры, а если Read (<имя файловой переменной>, <имя переменной>), то данные вводятся из файла, хранящегося на диске.
Запись в файл. Под записью в файл понимается вывод результатов программы из оперативной памяти ЭВМ в файл на диске.
Собственно запись данных в файл выполняется процедурой
|
|
|
Write (<имя файловой переменной>,<значение>);
Если оператор вывода имеет вид Write(<значение>), то данные выводятся на экран дисплея, а если Write(<имя файловой переменной>, <значение>), то данные записываются в файл.
Закрытие файла
После того как данные из файла прочитаны, его необходимо закрыть посредством процедуры
Close (<имя файловой переменной>).
Если файл не будет закрыть при повторном запуске программы работать с ним будет невозможно.
Признак конца файла
Так как число элементов файла не известно заранее, необходимо уметь определять, что файл кончился. Для этого используется логическая функция EOF(<имя файловой переменной>) (EOF - End Of file). Она принимает истинное значение (True), если достигнут конец файла, и ложное (False) − в противном случае.
Пример 1.
Прочитаем из файла целые числа и выведем их на экран:
Program Example_1;
Var F1: File of Integer; n: Integer;
Begin
Assign(F1, 'A:INT.DAT'); {связываем файловую переменную с файлом на диске}
Reset(F1); {открываем файл для чтения}
While Not EOF(F1) Do {пока не достигнут конец файла F1}
Begin
Read(F1, n); {считываем очередное число}
Write(n,' '); {выводим его на экран}
End;
Close(F1); {закрываем файл}
End.
Кстати, компонентой файла может быть массив целиком. За одну операцию записывается или считывается столько компонент, сколько перечислено в процедурах write или read.
|
|
|
Прямой доступ к элементам файла
Компилятор Паскаля содержит процедуры и функции для более эффективной работы с файлами. В частности, имеется возможность осуществлять прямой доступ к элементам файла.
Установка указателя
Процедура Seek (<имя файловой переменной>, N) устанавливает файловый указатель на N-й элемент. Например, Seek (F1, 3). Напомним, что элементы файла нумеруются с нуля.
Определение номера элемента
Функция FilePos (<имя файловой переменной>) возвращает номер элемента, на который "смотрит" файловый указатель.
Определение количества элементов в файле
Функция FileSize (<имя файловой переменной>) возвращает количество элементов в файле.
Удаление и переименование файлов. Удаление файлов. Процедура Erase (<имя файловой переменной>) удаляет файл на внешнем носителе, с которым связана файловая переменная.
Переименование файлов. Процедура Rename (<имя файловой переменной>,'<новое имя на диске>') переименовывает файл, связанный с данной файловой переменной.
Текстовые файлы
Текстовые файлы состоят из символьных строк. Строки могут иметь различную длину, и в конце каждой строки стоит признак конца строки. Для описания текстовых файлов используется служебное слово Text: Var A: Text.
|
|
|
Для обработки текстовых файлов используются те же процедуры и функции, что и для обработки обычных типизированных файлов. Assign, Reset, Rewrite, Read, Write, Close.
Если необходимо после чтения данных перейти на следующую строку, то используется процедура Readln. Если необходимо просто перейти к следующей строке, то можно использовать процедуру Readln (<имя файловой переменной текстового файла>), которая устанавливает файловый указатель на первый элемент.
Если надо записать данные и перейти к следующей строке, то можно использовать процедуру Writeln. Если требуется только перейти для записи на новую строку, то применяется процедура
Writeln (<имя файловой переменной текстового файла>), которая записывает в файл признак конца строки и устанавливает файловый указатель на начало следующей строки.
Так как в строках может быть разное количество символов, имеется логическая функция ЕОLN (<имя файловой переменной текстового файла>), которая принимает значение True, если достигнут конец строки.
В отличие от типизированных, к текстовым файлам применяется процедура Арреnd (<имя файловой переменной текстового файла>). Она открывает файл для "дозаписи", помещая файловый указатель в конец файла.
Пример 2
Дан текстовый файл, содержащий только целые числа, в каждой строке может быть несколько чисел, которые разделяются пробелами. Вывести на экран все числа с учетом разбиения на строки и подсчитать количество элементов в каждой строке.
Решение
Пусть в файле содержится следующая информация:
| -32 | 16 | 0 | 8 | 7 | ||
| 4 | 5 | 9 | 13 | 11 | -5 | -8 |
| 6 | -8 | 0 | -12 | |||
| 5 | 4 | 3 | 2 | 1 | 12 | |
| 1 | 2 | |||||
| -1 | -2 | -4 | ||||
| -1 | -2 | 4 |
Этот файл можно создать в среде Паскаль следующим образом:
1. Создайте новый файл посредством команды New меню File;
2. запишите все числа, разделяя их пробелами, и разбейте на строки, как указано в задании;
3. сохраните файл, например, под именем INT1.DAT.
Этот файл используется в программе, которая приведена ниже.
Program Example_2;
Var F: Text; х, k: Integer;
Begin
Assign(F, 'INT1.DAT'); {Связываем файловую переменную с файлом на диске}
Reset(F); {Открываем файл для чтения}
While Not Eof (F) Do {Пока не достигнут конец файла}
Begin k:=0; {Счетчик элементов строки}
While Not Eoln(F) Do {Пока не достигнут конец строки}
Begin Read(F, x); {Считываем очередное число}
Write(х, ' '); {Выводим его на экран}
Inc(k); {Увеличиваем счетчик }
End;
Writeln('В строке ', k,' элементов');
Readln(F); {Переходим к следующей строке файла}
End;
Close(F); {Закрываем файл}
End.
Модульное программирование
4.2.1. Понятие подпрограммы. Механизм вызова. Виды подпрограмм.
Нередко в программах встречаются повторяющиеся или похожие фрагменты. Имеется возможность оформлять такие фрагменты специальным образом – выделять их в подпрограммы.
Подпрограмма (англ. subroutine) – это повторяющаяся группа операторов, оформленная в виде самостоятельной программной единицы. Подпрограмме дается имя, по которому к ней можно обращаться (вызывать подпрограмму).
Подпрограмма – это самостоятельный алгоритм, который может многократно использоваться при решении более общей задачи.
Подпрограмма может быть многократно вызвана из разных частей программы. Механизм вызова подпрограмм показан на рисунке.
Рис 34. Механизм вызова подпрограммы
Строка программы, содержащая команду вызова подпрограммы, называется точкой вызова подпрограммы. После выполнения программного кода подпрограммы происходит возврат в основную программу и продолжение выполнения её команд с оператора следующего за вызовом подпрограммы.
Подпрограммы позволяют:
1. Упростить структуру программы (повышение степени абстракции).
2. Избежать избыточности кода (не повторять одно и то же в разных частях).
3. Уменьшить вероятность ошибок и упростить процесс отладки программы.
В Паскале имеются два вида подпрограмм − процедуры и функции. Их структура очень похожа на структуру основной программы. Процедура – подпрограмма, которая может не возвращать в основную программу значения переменных. Функция – подпрограмма, которая обязана возвращать в основную программу значения переменных.
4.2.2. Подпрограммы - процедуры
Описание процедуры
Описание процедуры начинается с заголовка, который является обязательным (в отличие от заголовка программы). Заголовок состоит из служебного слова Procedure, за которым следуют имя процедуры и, в круглых скобках, список формальных параметров. В конце заголовка ставится точка с запятой. После заголовка могут идти те же разделы, что и в программе. Общий вид описания процедуры (в квадратные скобки заключена часть, которая может отсутствовать):
Procedure Имя [Список формальных параметров];
Описательная часть
Begin
Тело процедуры
End;
При вызове процедуры ее формальные параметры заменяются соответствующими фактическими.
Фактические параметры − это параметры, которые передаются процедуре при ее вызове.
Количество и типы формальных и фактических параметров должны в точности совпадать.
Формальные параметры описываются в заголовке процедуры и определяют тип и место подстановки фактических параметров, формальные параметры делятся на два вида: параметры − переменные и параметры − значения.
Параметры − переменные отличаются тем, что перед ними стоит служебное слово Var. Они используются тогда, когда необходимо, чтобы изменения значений формальных параметров в теле процедуры приводили к изменению соответствующих фактических параметров.
Параметры − значения отличаются тем, что перед ними слово Var не ставится. Внутри процедуры можно производить любые действия с параметрами-значениями, но все изменения никак не отражаются на значениях соответствующих фактических параметров, то есть какими они были до вызова процедуры, такими же и останутся после завершения ее работы.
Все переменные программы делятся на глобальные и локальные. Глобальные переменные объявляются в разделе описаний основной программы. Локальные переменные объявляются в процедурах и функциях. Таким образом, локальные переменные "живут" только во время работы подпрограммы.
Пример 1
Составить программу для вычисления an: целые числа a и n (n≥0) вводятся с клавиатуры.
Решение
Для решения задачи используется подпрограмма – процедура Stepen.
Program Example_1;
Var a, n: Integer; s: Longint;
Procedure Stepen(x,y: Integer; Var st: Longint);
Var i:Integer;
Begin
st:=1; For i:=1 To у Do st:=st*x;
End;
Begin {основная программа}
Writeln('Введите два числа – основание и показатель степени');
Readln(a,n);
Stepen(а,n,s); {обращение к процедуре}
Writeln('Результат ',s);
End.
Процедура вызывается как оператор, состоящий из имени процедуры. В круглых скобках записываются фактические параметры. В нашем примере формальные параметры х, у и st принимают значения фактических параметров а, n и s соответственно. После завершения работы процедуры переменные а и n сохранят те же значения, что и при вызове, а s получит новое значение.
4.2.3. Подпрограммы - функции
Общий вид описания функции следующий:
Function Имя[(Список формальных параметров)]: Тип результата;
Описательная часть
Begin
Тело функции
End;
Внимание! В теле функции обязательно должен быть хотя бы один оператор присваивания, в левой части которого стоит имя функции, а в правой − ее значение. Иначе значение функции не будет определено.
Пример 2
Составить программу, подсчитывающую число сочетаний без повторения из n элементов по k.
Число сочетаний без повторения вычисляется по формуле: 
Обозначим через n и k переменные для хранения введенных чисел; c − переменную для хранения результата.
Чтобы подсчитать количество сочетаний без повторения, необходимо вычислить n!, (n-k)!, k!
Будем использовать функцию для вычисления факториала числа n (n!= 1•2•...•n).
В тексте программы описания функций всегда следуют за разделом описания переменных и до начала основной части, как и описания процедур. После того как функция описана, ее можно использовать в программе.
Program Example_2;
Var n, k: Integer; a1, a2, a3, c: Longint;
Function factorial (n:Integer): Longint;
Var i: Integer; rez: Longint;
Begin
rez:=1;
For i:=1 To n Do rez:=rez*i;
factorial:=rez;
End;
Begin Writeln('Ввод n и k:');
Readln(n,k) ; a1:=factorial(n); {вычисление n!}
a2:=factorial(k); {вычисление k!}
a3:=factorial(n-k);{вычисление(n-k)!}
c:=a1 div (a2*a3) ; {результат}
Writeln(c);
End.
Пусть n=5, k=3. Когда в программе встречается оператор a1:=factorial(n), выполняются следующие действия:
1. Выделяется память для переменных, описанных в функции factorial.
2. Формальному параметру присваивается значение фактического: n:=n (n=5).
3. Выполняется функция, вычисляется факториал числа 5;
4. Значение функции передается в место обращения к этой функции, то есть присваивается переменной а1.
В операторах a2:=factorial(k) и a3:=factorial(n-k) еще дважды вызывается функция factorial с параметрами k=3 и n-k=2. Всего в программе имеется 3 обращения к функции factorial, столько же раз выполняются и описанные выше действия.
Еще раз подчеркнем, что функция − это самостоятельная часть программы, имеющая собственные переменные, которым отводится отдельное место в памяти ЭВМ. Этим объясняется тот факт, что переменные с одинаковыми именами, используемые в функции и в основной программе, являются разными (в рассмотренном примере - переменная n основной программы и параметр n функции). При выполнении программы машина "не путает" имена этих переменных, так как области их действия не совпадают.
Это особенно важно при написании больших программ.
4.2.4. Примеры рекурсивного программирования
Рекурсия — частичное определение объекта через себя, определение объекта с использованием ранее определённых. Рекурсия используется, когда можно выделить самоподобие задачи. Это метод, сводящий общую задачу к некоторым задачам более узкого простого типа.
Алгоритм, который в процессе работы обращается сам к себе, называется рекурсивным. Для иллюстрации понятия рекурсия часто приводят пример с телевизором, на экране которого изображен этот же телевизор, на экране второго − опять телевизор и так далее.
Рекурсия бывает прямая и косвенная. При прямой рекурсии внутри подпрограммы происходит обращение самой к себе, но с другими параметрами. Косвенной называется рекурсия, когда две или более процедуры или функции вызывают друг друга. Пример косвенного вызова процедуры или функции: процедура A вызывает процедуру B, а процедура B вызывает процедуру A .
Суть рекурсии в том, что при каждом вызове создается новая копия со своими переменными, но как только она заканчивает работу, память занятая локальными переменными освобождается, а полученные результаты передаются в точку вызова.
Рекурсивный алгоритм в процессе работы обращается сам к себе.
Структура описания рекурсивных процедур (функций) имеет следующий вид:
<действия на входе в рекурсию>;
If <условие> then <команды выхода из рекурсии>
else <вызов процедуры (функции) с другими параметрами>
<действия на выходе из рекурсии>
В качестве <условие> выступают граничные случаи параметров, при которых результат работы рекурсии известен.
Это условие завершения процесса вхождения в рекурсию.
Механизм работы рекурсии
1. Со входом в рекурсию осуществляется вызов процедуры (функции), а для выхода необходимо помнить, откуда пришли, т.е помнить точки возврата (адреса).
2. Место хранения точек возврата называется стеком вызова и для него отводится определенная область оперативной памяти.
3. В стеке запоминаются также значения всех локальных переменных, т.е. создается копия параметров процедур (функций).
4. Стек ограничен. Возможно его переполнение – это главный недостаток рекурсии.
Каждый рекурсивный вызов порождает новый "экземпляр" формальных параметров и локальных переменных, причем старый "экземпляр" не уничтожается, а сохраняется в стеке по принципу вложенности. Здесь имеет место единственный случай, когда одному имени переменной в процессе работы программы соответствуют несколько ее экземпляров.
Глубина рекурсии определяется как максимальная вложенность рекурсии, т.е. максимальное число подпрограмм, завершение которых не произошло.
Войдя в рекурсивную функцию, мы "движемся" по ее тексту до тех пор, пока не встретим ее вызов, после чего мы опять начнем выполнять ту же самую функцию сначала. При этом следует отметить самое важное свойство рекурсивной функции - ее первый вызов еще не закончился.
Например, рекурсивная функция описана следующим образом:
function FTR(n:byte):longint;
Begin
if (n = 0) or (n = 1) then FTR := 1
else FTR := FTR(n - 1) * n;
end;
Затем в программе происходит вызов: A := FTR(4);
При этом, на 1-ом шаге нужно вычислять FTR := FTR(3) * 4, но для вычисления FTR(3), необходимо вычислить FTR(2) * 3, далее для FTR(2) вычислить FTR(1)*2. На этом вызове достигаем условия выхода из рекурсии (n=1), т.е. FTR(1) получает значение 1. Далее «поднимаемся» вверх: FTR(2)=1*2=2, FTR(3)=2*3 и, наконец, FTR(4)=6*4=24, т.е. А=24.
Можно разбить все рекурсивные задачи на 4 вида.
1. Задачи с рекурсивной формулировкой
Некоторые объекты являются рекурсивными по определению, поэтому рекурсивные алгоритмы их получения буквально повторяют соответствующие определения.
Пример 3
Вычисление факториала натурального числа. Для того чтобы вычислить N!, надо значение (N-1)! умножить на N, при этом 1!=1. В общем виде это можно записать так:
Для вычисления факториала опишем функцию.
Program Example_3;
Function factorial (n: Integer): Longint;
Begin
if n=1 Then factorial:=1 Else factorial:=n*factorial(n-1);End;
2. Задачи, из постановки которых можно извлечь рекурсию
В формулировках некоторых задач рекурсия не присутствует в явном виде, но их можно свести к рекурсивным.
Например, сложение двух чисел.
Пусть надо сложить два целых числа a и b, а можно только прибавлять или вычитать 1. Тогда:
· если b=0, то a+b=a;
· если b>0, то a+b=(a+1)+(b-1);
· если b<0, то a+b=(a-1)+(b+1).
3. Задачи, которые можно решить как частный случай обобщенной
Если нельзя извлечь рекурсию из постановки задачи, то можно расширить задачу, обобщить ее (например, ввести дополнительный параметр). Удачное обобщение может помочь увидеть рекурсию. После этого возвращаемся к частному случаю и решаем исходную задачу.
4. Задачи, в которых можно использовать характеристику или свойство функции
Например, для заданного натурального числа N≥1 определить натуральное число a, для которого выполняется неравенство: 2a-1≤N≤2a.
Заметим, что значение a зависит от N следующим образом:
Рассмотрим пример. Пусть N=34.
2a-1≤34<2a, прибавим 1 и переходим к 34 div 2
2a-1≤17<2a +1
2a-1≤8<2a +1
2a-1≤4<2a +1
2a-1≤2<2a +1
2a-1≤1<2a получим a=1
А теперь возвращаемся назад, к последней единице прибавляем все предыдущие.
Попробуйте написать программы для 2, 3 и 4-го вида рекурсии самостоятельно.
4.2.5. Модули
Модуль – это подключаемая к программе библиотека ресурсов (описания типов, констант, переменных и подпрограмм. Обычно это связанные между собой ресурсы.)
Модули применяются как библиотеки, которые могут использоваться различными программами, и для разбиения сложной программы на составные части.
Чтобы использовать модуль, достаточно знать только его интерфейс: детали реализации модуля скрыты от его пользователя. Это позволяет успешно создавать программы большого объема, поскольку мозг человека может хранить одновременно довольно ограниченный объем информации. Кроме того, использование модулей позволяет преодолеть ограничение в один сегмент на объем кода исполняемой программы, поскольку код каждого подключаемого к программе модуля содержится в отдельном сегменте.
Модули можно разделить на стандартные, которые входят в состав системы программирования, и пользовательские, то есть создаваемые программистом.
Стандартные модули позволяют после их подключения использовать в программе константы, типы, переменные и подпрограммы описанные в них. Например, всем начинающим известный модуль CRT, позволяет использовать процедуру ClrScr - очистка экрана.
К любой программе автоматически подключается стандартный модуль System, который содержит библиотеку исполняющей системы Паскаля, т.е. содержащиеся в нем ресурсы доступны в любой программе.
В Turbo Pascal входит восемь стандартных модулей. Шесть из них System, Overlay, Graph, Dos, Crt и Printer - осуществляют поддержку программ на Turbo Pascal; все они сохранены в TURBO.TPL. Программные ресурсы, сосредоточенные в стандартных модулях, образуют мощные пакеты системных средств, которые обеспечивают высокую эффективность и широкий спектр применений. Каждый модуль хранится в одноименном TPU-файле в системном каталоге Pascal.
Чтобы подключить модуль к программе, его требуется предварительно скомпилировать. Результат компиляции каждого модуля хранится на диске в отдельном файле с расширением .tpu.
Особенно важно умение создавать и анализировать модули в преддверии изучения визуального объектно – ориентированного программирования в среде Delphi.
Общая схема написания программ с использованием модулей:
1. Создать файл модуля (описать модуль и сохранить его в соответствии с правилами).
2. Выполнить компиляцию модуля (конкретный способ зависит от среды программирования).
3. Подключить модуль к программе, в которой будут использоваться структуры данных, процедуры и функции, описанные в модуле (оператор uses).
Описание модулей
Исходный текст каждого модуля хранится в отдельном файле с расширением .pas. Модуль состоит из секций (разделов).
Общая структура модуля:
unit имя; {заголовок модуля}
interface {интерфейсная секция модуля}
{описание глобальных элементов модуля (видимых извне)}
implementation {секция реализации модуля}
{описание локальных (внутренних) элементов модуля}
begin {секция инициализации}
{может отсутствовать}
end.
Далее мы поочередно рассмотрим каждый из данных разделов.
Имя модуля (Unit)
Имя модуля, следующее после ключевого слова Unit, должно совпадать с названием файла (без .pas), в котором находиться его код. Также с помощью имени, модуль подключается к другому модулю, либо к основной программе. Для этого необходимо указать служебное слово Uses, и перечислить через запятую список подключаемых модулей: Uses <список имен модулей>.
Интерфейсная секция (Interface)
В интерфейсной секции описываются заголовки объектов, к которым будут иметь доступ другие модули и программы. Это константы, типы данных, переменные и заголовки процедур и функции. Полностью же подпрограммы описываются в секции реализации, скрытой от пользователя модуля. Это естественно, поскольку для применения подпрограммы требуется знать только информацию, которая содержится в ее заголовке.
Например, так может выглядеть интерфейсная часть модуля Search, содержащего в себе алгоритмы поиска элементов в массиве.
unit Search;
Interface
type arr = array[1..5] of integer;
var s: string;
procedure binary_search(x: integer; Ar: arr; var s: string);
procedure line_search(x: integer; Ar: arr; var s: string);
Для объявления данного модуля, в программе нужно указать его имя: Uses Search.
После чего станет возможным использование всех описанных в интерфейсной части объектов.
Секция реализации (исполняемая часть - Implementation)
Именно здесь нужно описать подпрограммы заголовки которых приведены в интерфейсной части. Заголовок подпрограммы должен или быть идентичным указанному в секции интерфейса, или состоять только из ключевого слова procedure или function и имени подпрограммы. Для функции также указывается ее тип. При этом в их заголовках разрешается не указывать формальные параметры, иначе они должны полностью совпадать с таковыми в интерфейсной части. Кроме этого, интерфейсная часть может содержать локальные (недоступные вызывающей программе) для модуля объекты.
Секция инициализации
Инициирующая часть начинает свою работу до начала выполнения основной программы. В ней (между Begin и End), как правило, описываются операторы, предназначенные для разного рода вспомогательной работы. Обычно здесь выполняется присваивание начальных значений переменным, используемым в модуле или в программе, к которой он подключен. Операторы, расположенные в секции инициализации модуля, выполняются перед операторами основной программы. Если к программе подключено более одного модуля, их секции инициализации вызываются на выполнение в порядке, указанном в операторе uses.
Данная часть может отсутствовать, либо не иметь в себе никакого кода. В первом случае нужно указать End с точкой, во втором – оставить пустое место внутри Begin и End.
Компиляция модулей. Использовать в программе можно лишь скомпилированные модули, имеющие расширение, предусмотренное средой разработки приложения.
Пример описания модуля. В качестве примера оформим в виде модуля подпрограмму вычисления среднего арифметического значения элементов массива.
unit Srednee;
Interface
const n = 10;
type mas = array[1 .. n] of real;
procedure average(x : mas; var av : real);
Implementation
procedure average(x : mas; var av : real);
var i : integer;
begin
av := 0; for i := 1 to n do av := av + x[i];
av := av / n;
end;
end.
Чтобы использовать в программе величины, описанные в интерфейсной части модуля, имя модуля следует указать в разделе uses. Можно записать несколько имен модулей через запятую, например:
program example;
uses Srednee, Graph, Crt;
После этого все описания, расположенные в интерфейсных секциях модулей, становятся известными в программе, и ими можно пользоваться точно так же, как и величинами, определенными в ней непосредственно. Поиск модулей выполняется сначала в библиотеке исполняющей системы, затем в текущем каталоге, а после этого — в каталогах, заданных в диалоговом окне Options/Directories.
Если в программе описана величина с тем же именем, что и в модуле, для обращения к величине из модуля требуется перед ее именем указать через точку имя модуля. Например, пусть в программе определена процедура Circle, а в разделе uses подключен модуль Graph, в котором также есть процедура Circle. Для обращения к процедуре Circle из модуля Graph следует записать ее имя Graph.Circle.
Дата добавления: 2018-09-22; просмотров: 619; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!