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

Модуль не представляет собой исполняемой программы, а только содержит набор средств для использования в исполняемой программе: типы данных, переменные, процедуры и функции. Исходный текст модуля имеет расширение.pas. Модуль компилируется отдельно от основной программы, откомпилированный модуль имеет расширение.tpu (Turbo Pascal Unit). Готовый откомпилированный модуль может быть использован в основной программе с помощью предложения uses, которое записывается сразуже после имени программы.

В Турбо Паскале имеются стандартные модули:DOS, CRT (Cathode Ray Tube, электронно-лучевая трубка), Printer, Graph, System и другие. Их не надо описывать, а можно сразу включать в программу предложением uses. Модуль System используется во всех программах, поэтому для него сделано исключение, его можно не включать в предложение uses, он будет подключен автоматически. Остальные модули требуют включения в предложение uses, если в программе используются ресурсы модуля, например, процедуры и функции.

Структура модулей

Модуль имеет следующую структуру:
Unit < имя >;
Interface
< интерфейсная часть >
Implementation
< исполняемая часть >
[ Begin < инициирующая часть > ]
End.

Здесь:
Unit - кодовое слово (англ. модуль); начинающее заголовок модуля;
<имя> - имя модуля (правильный идентификатор);
Interface - кодовое слово, начинающее интерфейсную часть модуля;
Implementation - кодовое слово (англ. реализация); начинает исполняемую часть;
Begin - кодовое слово, начинающее инициирующую часть;
(часть модуля Begin < инициирующая часть > необязательна);
End. - признак конца модуля.

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

Интерфейсная часть открывается кодовым словом Interface . В этой части содержатся объявления всех глобальных объектов модуля (типов, констант, переменных и подпрограмм), которые должны стать доступными основной программе и/или другим модулям.

Следует учесть, что все константы и переменные, объявленные в интерфейсной части модуля, равно как и глобальные объекты основной программы, помещаются компилятором Турбо-Паскаля в обилии сегмент данных (максимальная длина сегмента 65521 байт).

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

В интерфейсной части модулей нельзя использовать опережающее описание.

Исполняемая часть

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

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

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

Компиляция модулей

В среде Турбо-Паскаля имеются средства, управляющие способами компиляции модулей и облегчающие разработку крупных программных проектов. В частности, определены три режима компиляции: Compile, Make и Build, Режимы отличаются только способом связи компилируемого модуля или компилируемой основной программы с другими модулями, объявленными в предложении Uses.

При компиляции модуля или основной программы в режиме Compile все упоминающиеся в предложении Uses модули должны быть предварительно откомпилированы и результаты их компиляции должны быть помещены в одноименные файлы с расширением.TPU. Например, если в программе (в модуле) имеется предложение Uses Global, то на диске в каталоге, объявленном опцией Unit directories, уже должен находиться файл GLOBAL.TPU. Файл с расширением.TPU (от англ. Turbo-Pascal Unit) создается в результате компиляции модуля.

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

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

В режиме Build существующие TPU-файлы игнорируются, и система пытается отыскать (и компилировать) соответствующий PAS-файл для каждого объявленного в Uses модуля. После компиляции в режиме Build программист может быть уверен в том, что учтены все сделанные им изменения в любом из модулей.

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

6 вопрос

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

1). TextMode(режим: integer) - выбирает указанный текстовый режим Режимы CRT:

2).TextBackground (цвет: byte) - Выбирает фоновый цвет.

Параметр "цвет" представляет собой выражение целого типа, например:

  • 0- черный
  • 1-синий
  • 2-зеленый
  • 3-голубой

3). ClrScr - Очистка экрана. Все позиции символов заполняются пробелами. При этом используются текущий фоновый цвет, заданный в процедуре TextBackGround.

4). TextColor (цвет:byte) - Устанавливает цвет символов. { константы для установки цвета}

5). Window(x1,y1,x2,y2) - Определяет на экране текстовое окно. Параметры x1,y1 представляют собой координаты верхнего левого угла окна, параметры x2,y2 - координаты правого нижнего угла.Минимальный размер один столбец на одну строку. Максимальный - Х=80, У=25.Если координаты являются недопустимыми, то обращение к процедуре Window игнорируется. По умолчанию задается окно на весь экран.

6).GoToXY(x,y: byte) - Позиционирует курсор. Курсор перемещается в ту позицию внутри текущего окна, которая задана координатами x и y (x - задает столбец, y - задает строку).Верхний левый угол задается координатами (1,1) пример: Window(1,10,60,20); GoToXY(1,1); Это приведет к тому, что курсор уйдет в точку с абсолютными координатами (1,10).

7).WhereX и WhereY возвращают для текущей позиции курсора относительно текущего окна координаты X и Y соответственно. Тип результата Byte.

8).Delay(мсек: word) - Выполняет задержку на заданное число миллисекунд. Параметр "мсек" задает число миллисекунд интервала ожидания. Но данная процедура является приблизительной, поэтому период задержки не будет точно равнятся заданному числу миллисекунд.

9).READKey - Считывает символ с клавиатуры.

10).Sound - является процедурой включающей внутренний динамик; Описание: Sound(герц: word); где параметр "герц" задает частоту генерируемого сигнала в герцах.Звук будет звучать до тех пор пока не будет выключен посредством обращения к процедуре NoSound;

11).NoSound - Выключает внутренний динамик.

Пример использования Sound,Delay,NoSound

Sound(220); { включить звук }

Delay(300); { ждать 300 ms }

NoSound; { выключить звук }

7 вопрос.

Модуль Graph

ТР обладает достаточно разнообразными средствами для работы со стандартным VGA экраном.

VGA адаптер имеет разрешение 640х480 пиксел (точка (0,0) в левом верхнем углу экрана), 16 цветов.

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

Общая структура графической программы:

Uses crt, graph;
var Gd, Gm: Integer;
begin
Gd:= Detect;
InitGraph(Gd, Gm, "c:\bp\bgi");
...
{Здесь построение изображения}
...
ReadKey;
CloseGraph;
end.

Путь c:\bp\bgi указывает расположение файла egavga.bgi (драйвер графического адаптера). На разный компьютерах этот путь может быть разным. Если файл egavga.bgi поместить в каталог с программой, то путь можно не указывать.

Основные графические процедуры и функции:

Построение фигур

PutPixel(x,y,c)
- отображает на экране точку с координатами (x,y) и цветом c

Line(x1,y1,x2,y2)
- рисует линию с началом в точке (x1,y1) и концом - (x2,y2)

Rectangle(x1,y1,x2,y2)
- рисует контур прямоугольника с диагональю (x1,y1) - (x2,y2)

Bar(x1,y1,x2,y2)
- рисует закрашенный прямоугольник с диагональю (x1,y1) - (x2,y2)

Circle(x,y,r)
- рисует окружность с центром (x,y) и радиусом r

Ellipse(x,y,ba,ea,xr,yr)
- рисует дугу эллипса с центром в (x,y), горизонтальным и вертикальным радиусом xr и yr, и начальным и конечным углом ba и ea

FillEllipse(x,y,xr,yr)
- рисует закрашенный эллипс с центром в (x,y), горизонтальным и вертикальным радиусом xr и yr

Модуль (UNIT -модуль, единица) – автономно (отдельно) компилируемая программная единица, которая содержит компоненты раздела описаний (меток, констант, типов, переменных, процедур, функций), а также может содержать операторы инициализирующей части.
Сам модуль не является выполняемой программой, а предназначен для использования другими программами и модулями.

Структура модуля

Модуль имеет следующую структуру:
UNIT < имя модуля>
INTERFACE
< раздел интерфейсный>
IMPLEMENTATION
< раздел реализации>
BEGIN
< раздел инициализации>
END.

Заголовок модуля состоит из зарезервированного слова Unit (модуль) и имени модуля.

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

Имя модуля используется для его связи с основной программой с помощью предложения Uses.
Предложение Uses м.б. помещено после заголовка модуля или за словами

Interface и Implementation.

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

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

Раздел инициализации – заключается в словесные скобки BEGIN END .
и содержит операторы, которые будут выполнены до передачи управления основной программе. Это м.б. операторы инициализации данных (переменных) Например операторы присваивания, ввода а также процедуры связывания и открытия файлов. Раздел операторов м.б. пустымBEGIN END или отсутствовать простоEND.
В конце модуля ставится точка.

Компиляция и использование модулей

Оперативная память система имеет сегментную структуру (один сегмент равен 64К =65535 байт). Код программы м.б. не более одного сегмента, объем данных не может превышать один сегмент (если не использовать динамическую память) и для стека один сегмент. Размер стека задается директивой {$M <>}. Минимальный размер стека 1К максимальный один сегмент по умолчанию 16К. Значения локальных переменных при обращении к подпрограмме помещаются в стек, а при выходе извлекаются из стека.
Код модуля помещается в отдельный сегмент, т.к. он транслируется автономно от основной программы, а количество модулей используемых программой зависит только от доступной ОП. Это позволяет создавать большие программы.
Компилятор создает код модуля с тем же именем, но с расширением tpu (turbo pascal unit ).
Для использования модуля основной программой или другими модулями его имя (без расширения) помещается в списке предложенияUses
Если модуль является компактным и часто м.б. использован прикладными программами, то его можно поместить в библиотеку стандартных модулейTURBO.TPL (Turbo-Pasacal-library) с помощью утилитыTPUMOVER .
Но это необходимо делать только в случае крайней необходимости т.к. библиотека загружается в ОП и уменьшает место для программы.
При компиляции файла с исходным текстом модуля появляется одноименный файл с расширением tpu и помещается в каталоге указанном опцией

OPTIONS/DIRECTORIES/UNIT DIRECTORIES

или в текущем каталоге при отсутствии этой опции.
При компиляции основной программы используемые модули д.б. в каталоге указанном опцией
OPTIONS/DIRECTORIES/EXE & TPU DIRECTORIES

либо в текущем каталоге при отсутствии этой опции
Для получения EXE файла задачи в опции

COMPILE/DESTINATION/DISK(MEMORI)
установить DISK .
Существует три режима компиляции модулей:
- COMPILE
- BUILD
- MAKE

Режимы устанавливаются меню COMPILE

1. Режим COMPILE (вызывается Alt-F9 ) . При этом компилируется программа а используемые модули д.б. предварительно откомпилированы и храниться в соответствующих каталогах.
2. Режим BUILD (вызывается - F9 ) . При этом игнорируются ранее откомпилированные модули, а ищутся модули с расширением pas и перекомпилируются.
3. Режим MAKE (вызываетсяF9 ) . При этом перекомпилируется только модули, которые имели изменения в тексте.

Пример 16.1.

В файле inp.txt расположены три массива вещественных чисел

2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6

Вычислить функцию

где Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc - максимальный элемент, сумма и количество положительных элементов соответствующих массивов a, b, и c.
Результат вывести в файл out. txt и на экран.

Текст модуля

Unit UNMAS;
Interface
Const n=10;
Type vec=array of real;
Var z:vec;
i:integer;
f1,f2:text;

Procedure SK1(z:vec; num:byte; Var s:real; Var k:byte);
Function MAX(z:vec; num:byte):real;

Implementation
Procedure Vv(s:char; num:byte;Var z:vec);
Begin
Writeln("Mассив ",s);
For i:=1 to num do
Begin
Read(f1,z[i]); Write(z[i]:4:1," ":3);
End;
Readln(f1); Writeln;
End;

Procedure SK1(z:vec;num:byte; Var s:real; Var k:byte);
Begin
s:=0; k:=0;
for i:=1 to num do if z[i]>0 then
Begin
s:=s+z[i];
k:=k+1
End;
End;
Function MAX(z:vec;num:byte):real;
Var m:real;
Begin
m:=z;
for i:=1 to num do if z[i]>m then m:=z[i];
MAX:=m
End;

Begin
Assign(f1,"inp.txt"); Reset(f1);
Assign(f2,"out.txt"); Rewrite(f2)
End.

Текст программы

Program lr7_16;
Uses CRT,UNMAS;
Var
a,b,c:vec;
y,sa,sb,sc:real;
ka,kb,kc:byte;
Begin
clrscr;
Vv("a",8,a);
Vv("b",9,b);
Vv("c",n,c);
SK1(a,8,sa,ka);
SK1(b,9,sb,kb);
SK1(c,n,sc,kc);
y:=(MAX(a,8)+MAX(b,9)+MAX(c,n))+(sa+sb+sc+ka+kb+kc);
Writeln("Результат:":20);
Write ("Массив а: ");
Writeln("sa=",sa:5:1," ka=",ka);
Write ("Массив b: ");
Writeln("sb=",sb:5:1," kb=",kb);
Write ("Массив c: ");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
Readln;
Writeln(f2,"ђҐ§г«мв в:");
Writeln(f2," ":10,"y=",y:10);
Close(f1);
Close(f2)
End.

Результаты работы программы

Mассив a
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Mассив b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Mассив c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Результат:
Массив а: sa= 17.6 ka=4
Массив b: sb= 15.0 kb=5
Массив c: sc= 28.9 kc=5
y= 9.330E+01

Модули в Паскале по отношению к основной части программы напоминают подпрограммы (процедуры и функции). Но по определению они являются самостоятельными программами, ресурсы которых могут быть задействованы в других программах. Кроме того описание модулей происходит вне вызывающего приложения, а в отдельном файле, поэтому модуль – это отдельно компилируемая программа. Файл скомпилированного модуля (именно такой нужен для использования) будет иметь расширение предусмотренное средой программирования (например, .tpu, .ppu, .pcu).

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

Структура модуля выглядит так:

Unit <имя модуля>;
Interface
<интерфейсная часть>
Implementation
<исполняемая часть>
Begin
<инициализация>
End.

Имя модуля (Unit)

Имя модуля, следующее после ключевого слова Unit , должно совпадать с названием файла (без.pas), в котором находиться его код. Также с помощью имени, модуль подключается к другому модулю, либо к основной программе. Для этого необходимо указать служебное слово Uses , и перечислить через запятую список подключаемых модулей:

Uses <список имен модулей>;

Интерфейсная часть (Interface)

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

1
2
3
4
5
6

unit Search;
Interface

var s: string ;

Для объявления данного модуля, в программе нужно указать его имя:

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

Исполняемая часть (Implementation)

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

Инициирующая часть

Инициирующая часть начинает свою работу до начала выполнения основной программы. В ней (между Begin и End), как правило, описываются операторы, предназначенные для разного рода вспомогательной работы. Данная часть может отсутствовать, либо не иметь в себе никакого кода. В первом случае нужно указать End с точкой, во втором – оставить пустое место внутри Begin и End.

Компиляция модулей

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

Turbo Pascal

Итогом компиляции модуля в Turbo Pascal, будет файл с расширением .tpu (Turbo Pascal Unit ), хранящий его код.

Free Pascal

После компиляции модуля в среде Free Pascal, создаются два файла с разными разрешениями: .ppu и .o . Первый содержит интерфейсную часть модуля, а второй (необходим для компоновки программы) – часть реализаций.

Pascal ABC.NET

Pascal ABC.Net во время компиляции модуля не генерирует код на машинном языке. В случае, если компиляция выполнена успешна код сохраняется в файле с разрешением .pcu .

Для сред программирования Turbo Pascal и Free Pascal предусмотрены три режима компиляции: Compile, Make и Build . В режиме Compile все используемые в программе модули должны быть заранее скомпилированы. Приложение в режим Make-компиляции проверяет все подключенные модули на наличие файлов с соответствующим для среды программирования разрешением (.tpu или.o). Если какой-то из них не найден, то происходит поиск файла с названием ненайденного модуля и расширением.pas. Самый надежный из режимов – Build. Поиск и компиляция файлов (с расширением.pas) в данном режиме происходит даже тогда, когда модульные файлы уже имеются.

Пример

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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 ) ;
Implementation
var a, b, c, i: integer ;
procedure binary_search(x: integer ; Ar: arr; var s: string ) ;
begin
a:= 1 ; b:= 5 ; s:= ‘NO’ ;
while a<= b do
begin
c:= a+ (b— a) div 2 ;
if (x b:= c— 1
else if (x>Ar[ c] ) then
a:= c+ 1
else
begin s:= ‘YES’ ; break ; end ;
end ;
end ;
procedure line_search(x: integer ; Ar: arr; var s: string ) ;
begin
s:= ‘NO’ ;
for i:= 1 to 5 do
begin
if (Ar[ i] = x) then
begin
s:= ‘YES’ ; break ;
end ;
end ;
end ;
end .

Весь этот код должен находиться в отдельном файле. Теперь напишем основную программу, в которую подключим наш модуль Search.

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

Турбо-Паскаль обеспечивает Вам доступ к большому числу встроенных констант, типов данных, переменных, процедур и функций. Некоторые из них специфичны для Турбо-Паскаля; другие специфичны для персонального компьютера РС фирмы IBM (и совместимых с ним компьютеров) или для операционной системы MS-DOS. Их количество велико, однако, в своей программе Вы редко используете их все сразу. Поэтому они разделены на связанные группы, называемые модулями. В этом случае Вы можете использовать только те модули, которые необходимы в программе.

Структура модуля

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

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

unit <идентификатор>; interface uses <список модулей>; {Необязательный} {открытые описания} implementation {закрытые описания процедуры и функции } begin {код инициализации } end .

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

Модуль может использовать другие модули, для этого они определяются в предложении uses. Предложение uses, если имеет место, то следует сразу после ключевого слова interface. Отметим, что здесь выполняется общее правило использования предложения uses: если модуль, имя которого указано в предложении uses, использует другие модули, то имена этих модулей также должны быть указаны в предложении uses, причем до того, как они будут использованы.

Стандартные модули

Файл TURBO.TPL содержит все стандартные пакеты, кроме Graph и пакетов совместимости (Graph3 и Turbo3): System, Overlay, Crt, Dos и Printer. Эти пакеты загружаются в память вместе с Турбо-Паскалем и всегда вам доступны. Обычно файл TURBO.TPL хранят в одном каталоге с TURBO.EXE (или TPC.EXE). Вы можете хранить его и в другом каталоге, если он описан как каталог Турбо-Паскаля. Для этого необходимо с помощью TINST.EXE установить этот каталог в файле TURBO.EXE.

Используемые пакеты: нет

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

Используемые пакеты: нет

DOS определяет многочисленные паскалевские процедуры и функции, которые эквивалентны наиболее часто используемым вызовам DOS, как например, GetТime, SetТime, DiskSize и так далее. Кроме того, он определяет две программы низкого уровня МsDos и Intr, которые позволяют активизировать любой вызов MS-DOS или системное прерывание. Registers представляет собой тип данных для параметра в МsDos и Intr. Кроме того, определяются некоторые другие константы и типы данных.

Используемые пакеты: нет

Overlay - содержит инструменты для создания оверлейных программ. Программа OVERKAY - программа, которая загружается не вся, а по частям.

Используемые пакеты: нет

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

Используемые пакеты: Crt

В модуле Printer дано описание переменной текстового файла Lst, которая связывается с драйвером устройства, позволяющим направлять стандартный для Паскаля вывод на печатающее устройство с помощью Write и Writeln. Например, включив Printer в свою программу, Вы можете сделать следующее:

Write (Lst,"Сумма " ,A:4 ," и " ,B:4 ," равна " ) ; C:=A + B; Writeln (Lst,C:8 ) ;

Используемые пакеты: Crt

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

Используемые пакеты: Crt

Этот модуль содержит две переменные и несколько процедур, которые больше не поддерживаются Турбо-Паскалем. Они включают встроенную файловую переменную Кbd, булеву переменную CBreak и первоначальные целочисленные версии MemAvail и MaxAvail (которые возвращают размер свободной памяти в параграфах, а не в байтах, как это делают настоящие версии).

Используемые пакеты: Crt

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

Этот модуль реализует независимый от устройства графический драйвер фирмы "Борланд", позволяющий поддерживать графические адаптеры типа СGА, ЕGА, Hercules, АТТ 400, МСGА, 3270 РС и VGА.

Написание собственных модулей

Допустим, Вы написали модуль IntLib, записали его в файл INTLIВ.PAS и оттранслировали на диск; получившийся в результате код находится в файле INTLIВ.ТРU. Для использования этого модуля в программе необходимо включить в нее оператор uses, указывающий компилятору, какой модуль используется. Ваша программа может выглядеть следующим образом:

program MyProg; uses IntLib;

Отметим, что Турбо-Паскаль предполагает, что файл, в котором находится модуль, имеет такое же имя, что и сам модуль. Если имя Вашего модуля МyUtilities, то Турбо-Паскаль будет искать файл с именем МYUTILIТ.PAS.

Компиляция модуля

Модуль компилируется точно так же, как компилируется программа: он создается с помощью редактора, а затем вызывается команда Соmpile/Соmpile (Компилировать/ Компилировать) (или нажимаются клавиши Аlt-С). Однако, вместо файла с расширением.ЕХЕ Турбо-Паскаль создает файл с расширением.ТРU (Turbо Раscal Unit - модуль Турбо-Паскаля). После этого Вы можете оставить этот файл как есть или же вставить его в ТURВО.TPL с помощью TPUMOVER.ЕХЕ.

В любом случае имеет смысл переслать файлы с расширением *.ТРU (вместе с исходными файлами) в каталог модулей, который определен с помощью команды О/D/Unit directories (Каталоги модулей). В одном исходном файле может находиться только один модуль, поскольку компиляция прекращается, как только обнаружен завершающий оператор end.

Пример :

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

unit IntLib; interface procedure ISwap(var I,J: integer ) ; function IMax(I,J: integer ) : integer ; implementation procedure ISwap; var Temp: integer ; begin Temp:=I; I:=J; J:=Temp end ; {конец процедуры ISwap } function IMax; begin if I > J then IMax:=I else IMax:=J end ; {конец функции IMax } end . {конец модуля IntLib }

Введем эту подпрограмму, запишем ее в файл INTLIВ.PAS, а затем оттранслируем на диск. В результате получим код модуля в файле INTLIВ.ТРU. Перешлем его в каталог модулей. Следующая программа использует модуль IntLib:

program IntTest; uses IntLib; var A,B: integer ; begin Write ("Введите два целочисленных значения: " ) ; Readln (A,B) ; ISwap(A,B) ; Writeln ("A=" ,A," B=" ,B) ; Writeln ("Максимальное значение равно " ,IMax(A,B) ) ; end . {конец программы IntTest }

Все описания внутри модуля связаны друг с другом. Например, модуль Crt содержит все описания, необходимые для подпрограмм работы с экраном на Вашем персональном компьютере.

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

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

Модуль имеет следующую структуру:

Заголовок модуля на языке Паскаль состоит из служебного слова Unit и следующего за ним именем модуля. К имени модуля предъявляются жесткие требования и это имя должно совпадать с именем дискового файла с расширением.pas, в котором находится текст модуля.

Unit MyType; //файл MyType.pas

Имя модуля служит для связи модуля с программами и другими модулями. Программы и модули устанавливают связь с требуемым модулем в разделе Uses программы или модуля. Модули для своей работы могут вызывать другие модули, если модуль вызывает другой модуль, то раздел Uses должен следовать за служебным словом INTERFACE.

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

Unit Wodmass;

INTERFACE

USES MyType;

[имя_типа]:[тип];

[список_глобальных_переменых]:[тип];

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

Исполняемая часть языка Паскаль начинается служебным словом IMPLEMENTATION и содержит описание подпрограмм, объявленных в интерфейсной части, кроме того в исполняемой части могут быть объявлены локальные для модуля объекты (переменные, константы). Описание подпрограммы в исполняемой части должно начинаться с заголовка подпрограммы, при этом список формальных параметров опускается.

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

Компиляция модулей на языке Pascal

При работе с модулями необходимо выполнять компиляцию самих модулей и компиляцию программ, использующих модули. Как известно в среде Borland Pascal имеется три режима компиляции (Compile, Build, Make). При компиляции самого модуля обычно используется режим Compile, хотя можно и другими режимами, в том случае если модуль используется другие модули. При компиляции модуля не создается исполняемая программа, а создается специальный файл откомпилированного модуля с расширением.tpw. Файлы откомпилированных модулей помещаются в каталоги, обычно с именем Units (задается при настройках среды). При компиляции программ, содержащих модули, могут быть использованы все три режима компиляции. Компиляция разными режимами отличаются продолжительностью и надежностью.

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

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

В режиме Build все.tpw файлы игнорируются, компилятор перекомпилирует все используемые в головной программе модули и откомпилирует программу. Это самый надежный режим, но в тоже время самый длительный.



Понравилась статья? Поделиться с друзьями: