1. 13. Разработка модулей
Известно, что
откомпилированная программа размещается в
отдельном сегменте памяти,
т. е. не может
превышать 64 Кбайта. Для
создания больших программ в Турбо-Паскале предусмотрено
подключение к основной программе
откомпилированных модулей.
Модуль включает в себя,
как правило, большое
число процедур, выполняющих
однотипные операции, например,
работа с графикой, операции
с комплексными числами,
матричные операции и т. д. Модуль
определяется как программа,
начинающаяся со служебного слова "Unit"
и включающая в себя интерфейсную,
исполняемую и инициирующую части.
Интерфейсная
часть модуля начинается со служебного
слова "Interface" и
состоит из раздела описания глобальных
имен типов, меток, констант,
переменных, а
также заголовков процедур,
доступных основной программе.
Исполняемая часть модуля
начинается со служебного слова "Implementation"
и содержит полное описание процедур (заголовок, разделы описания и выполнения),
заголовки которых перечислены в
интерфейсной части, а
также локальных имен типов,
меток, констант
и переменных, используемых
в инициирующей части.
Инициирующая
часть модуля начинается со служебного
слова "Begin" и
содержит блок операторов,
выполняемых при подключении модуля к
основной программе. Инициирующая
часть вместе со словом "Begin" может отсутствовать или быть
пустой. Заканчивается
модуль служебным словом "End.
" с точкой.
Содержимое исполняемой и инициирующей
частей не доступно основной программе,
связь модуля с основной программой
осуществляется через интерфейсную часть
модуля.
Структура модуля имеет вид:
Unit Name_M;
{
Name_M - имя
модуля }
{-----------------------------------------------------------------}
Interface
{
Интерфейсная часть
модуля}
{------------------------------------ раздел описания
глобальных имен}
Type MM= array[1..10, 1..10] of real;
{ описание
типа}
Var
Max_F, Min_F: real;
{описание глобальных
переменных}
{-----------------------------------------------------------------}
Procedure
Name_P(p1: real; p2: MM);
{
описание заголовков процедуры}
Function Name_f(p3, p4: real):
real;
{ и
функции}
{-----------------------------------------------------------------}
Implementation
{Исполняемая часть
модуля}
{-------------------------------------- раздел описания локальных
имен}
Const
C = 'Подключен модуль Name_M'; {
задание локальной константы}
Procedure
Name_P;
{Полное
описание процедуры}
{ Раздел описания процедуры}
Begin
{ Раздел выполнения процедуры}
End;
Function
Name_f: real;
{Полное
описание функции}
{ Раздел описания функции}
Begin
{ Раздел выполнения функции}
End;
{----------------------------------------------------------------
}
BEGIN
{
Инициирующая часть модуля}
Writeln(C); {операторы
модуля}
END.
Отметим, что в
интерфейсной части модуля запрещается
делать опережающее описание процедур.
Запрещается также рекурсия модулей.
Модуль
записывается в файл с именем модуля,
например, Name_M.
pas. Затем файл
компилируется, при
этом получается файл с расширением ". tpu",
например, Name_M.
tpu, который
автоматически записывается в каталог,
указанный в опции Options,
Directories, EXE & TPU,
иначе -
в текущий каталог. При
запуске программы, использующей
модуль, файл с
расширением ". tpu" ищется в каталоге,
указанном в опции Options,
Directories, EXE & TPU
или Unit Directories, либо
в текущем каталоге.
Подключение модулей
осуществляется в начале основной программы
с помощью служебного слова "Uses" с
указанием имен модулей,
например:
Program Pr_1;
Uses Name_M1, Name_M2;
Если в основной программе
имя идентификатора совпадает с именем,
объявленным в интерфейсной части
подключенного модуля, то
используются значения,
присвоенные идентификатору в программе.
Если одинаковые имена встречаются в
интерфейсной части подключенных модулей (например
в Name_M1 и Name_M2),
то используются значения,
присвоенные идентификатору в последнем
описанном модуле, т.
е. в Name_M2.
Приведем пример разработки и
подключения модуля. В
модуле опишем процедуры работы с матрицами.
Unit MATR_1;
{-----------------------------------------------------------------}
Interface
{-----------------------------------------------------------------}
Type M = array[1..10, 1..10] of real;
M1
= array[1..10] of real;
Procedure MAT_1(a:M; var
b:M; n: word);
Procedure MAT_2(a:M; var
b:M1; n: word);
{-----------------------------------------------------------------}
Implementation
{-----------------------------------------------------------------}
Procedure MAT_1;
{создание матрицы "B", транспонированной
к
"A"}
var i, j: word;
begin for i:=1
to N do for j:=1 to N do b[i,j]:=a[j,i]
end;
{-----------------------------------------------------------------}
Procedure
MAT_2;
{расчет
квадратов диагональных элементов}
var i, j: word;
begin for i:=1
to N do b[i]:=a[i,i]*a[i,i]
end;
{-----------------------------------------------------------------}
END.
В основной программе PR_1 подключается
модуль MATR_1 и используются процедуры MAT_1 и
MAT_2.
Program PR_1;
Uses MATR_1;
Type MM = M; MM1
= M1;
Var a1,a2,a3: MM; b1,b2:
MM1; i,j,n: word;
Begin
Writeln('введите размерность матрицы N=');
Readln(n);
Randomize;
for
i:=1 to n do for j:=1 to n do a1[i,j]:=random(20)+1;
MAT_1(a1, a2, n); MAT_1(a2,
a3, n);
MAT_2(a1, b1, n); MAT_2(a2,
b2, n) end.
В результате двойного
транспонирования исходной матрицы "a1"
(из "a1" в "a2", из
"a2" в "a3") получается матрица
"a3" тождественная "a1" .
Матрицы "b1" и "b2"
содержат квадраты диагональных элементов
матриц "a1" и "a2".
Типы массивов фактических параметров
должны соответствовать типам массивов
формальных параметров, описанных в модуле MATR_1.
Можно использовать имена типов,
заданные в интерфейсной части модуля
или задавать новые имена типов.
