Модуль (unit) представляет собой набор констант, типов данных, переменных, процедур и функций. Каждый модуль аналогичен отдельной программе на Паскале: он может иметь основное тело, которое вызывается перед запуском Вашей программы и осуществляет необходимую инициализацию. Короче говоря, модуль представляет собой библиотеку описаний, которую можно вставить в свою программу и которая позволит разбить программу на части, компилируемые отдельно.
Турбо-Паскаль обеспечивает Вам доступ к большому числу встроенных констант, типов данных, переменных, процедур и функций. Некоторые из них специфичны для Турбо-Паскаля; другие специфичны для персонального компьютера РС фирмы IBM (и совместимых с ним компьютеров) или для операционной системы MS-DOS. Их количество велико, однако, в своей программе Вы редко используете их все сразу. Поэтому они разделены на связанные группы, называемые модулями. В этом случае Вы можете использовать только те модули, которые необходимы в программе.
Структура модуля
Модуль обеспечивает набор средств благодаря процедурам и функциям при поддержке констант, типов данных и переменных, однако действительная реализация этих средств скрыта в силу того, что модуль разделен на две секции: интерфейса и реализации. Если программа использует модуль, то все описания модуля становятся доступными этой программе, как если бы они были определены в ней самой.
Структура модуля аналогична структуре программы, однако есть несколько существенных различий. Например, рассмотрим модуль:
unit <идентификатор>; interface uses <список модулей>; {Необязательный} {открытые описания} implementation {закрытые описания процедуры и функции } begin {код инициализации } end.
Заголовок модуля начинается зарезервированным словом unit, за которым следует имя модуля (идентификатор) точно так же, как и в случае имени программы. Следующим элементом в модуле является ключевое слово interface. Оно обозначает начало секции интерфейса модуля — секции, видимой всем другим модулям или программам, в которых он используется.
Модуль может использовать другие модули, для этого они определяются в предложении uses. Предложение uses, если имеет место, то следует сразу после ключевого слова interface. Отметим, что здесь выполняется общее правило использования предложения uses: если модуль, имя которого указано в предложении uses, использует другие модули, то имена этих модулей также должны быть указаны в предложении uses, причем до того, как они будут использованы.
Стандартные модули
Turbo
Файл TURBO.TPL содержит все стандартные пакеты, кроме Graph и пакетов совместимости (Graph3 и Turbo3): System, Overlay, Crt, Dos и Printer. Эти пакеты загружаются в память вместе с Турбо-Паскалем и всегда вам доступны. Обычно файл TURBO.TPL хранят в одном каталоге с TURBO.EXE (или TPC.EXE). Вы можете хранить его и в другом каталоге, если он описан как каталог Турбо-Паскаля. Для этого необходимо с помощью TINST.EXE установить этот каталог в файле TURBO.EXE.
System
Используемые пакеты: нет
System содержит все стандартные и встроенные процедуры и функции Турбо-Паскаля. Любая подпрограмма Турбо-Паскаля, не являющаяся частью стандартного Паскаля и не находящаяся ни в каком другом модуле, содержится в System. Этот модуль присоединяется ко всем программам.
Dos
Используемые пакеты: нет
DOS определяет многочисленные паскалевские процедуры и функции, которые эквивалентны наиболее часто используемым вызовам DOS, как например, GetТime, SetТime, DiskSize и так далее. Кроме того, он определяет две программы низкого уровня МsDos и Intr, которые позволяют активизировать любой вызов MS-DOS или системное прерывание. Registers представляет собой тип данных для параметра в МsDos и Intr. Кроме того, определяются некоторые другие константы и типы данных.
Overlay
Используемые пакеты: нет
Overlay — содержит инструменты для создания оверлейных программ. Программа OVERKAY — программа, которая загружается не вся , а по частям.
Crt
Используемые пакеты: нет
Crt обеспечивает набор специфичных для РС описаний констант, переменных и программ для операций ввода/вывода. Последние можно использовать для работы с экраном (задание окон, непосредственное управление курсором, цвет текста и фона). Кроме того, Вы можете осуществлять «необработанный» ввод с клавиатуры и управлять платой генерации звукового сигнала персонального компьютера. Этот модуль обеспечивает множество подпрограмм, которые были стандартными в версии 3.0.
Printer
Используемые пакеты: Crt
В модуле Printer дано описание переменной текстового файла Lst, которая связывается с драйвером устройства, позволяющим направлять стандартный для Паскаля вывод на печатающее устройство с помощью Write и Writeln. Например, включив Printer в свою программу, Вы можете сделать следующее:
Write(Lst,'Сумма ',A:4,' и ',B:4,' равна '); C:=A + B; Writeln(Lst,C:8);
Graph3
Используемые пакеты: Crt
Graph3 поддерживает полный набор графических подпрограмм для версии 3.0 — для обычной, расширенной графики и графики, использующей относительные команды. Они идентичны по имени, параметрами функции подпрограммам версии 3.0.
Turbo3
Используемые пакеты: Crt
Этот модуль содержит две переменные и несколько процедур, которые больше не поддерживаются Турбо-Паскалем. Они включают встроенную файловую переменную Кbd, булеву переменную CBreak и первоначальные целочисленные версии MemAvail и MaxAvail (которые возвращают размер свободной памяти в параграфах, а не в байтах, как это делают настоящие версии).
Graph
Используемые пакеты: 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 содержит все описания, необходимые для подпрограмм работы с экраном на Вашем персональном компьютере.
В прошлом уроке мы рассматривали операторы сложения, вычитания, умножения и деления. Сегодня я предлагаю рассмотреть операторы квадрата, корня и модуля.
1. Оператор квадрата
Этот оператор возводит в квадрат заданное ему число или переменную. Обозначается, как «sqr» без кавычек. В программе пишется как sqr(a), где a — любая другая переменная или число.
Пример:
var a, c:integer;
begin
writeln ('Введите число');
readln (a);
c:=sqr(a);
writeln ('Квадрат равен ',c);
end.
2. Оператор корня
Этот оператор находит корень из переменной или числа. Обозначается, как «sqrt» , без кавычек. В программе пишется как sqrt(a), где a — любая другая переменная или число.
Пример:
var a, c:real;
begin
writeln ('Введите число');
readln (a);
c:=sqrt(a);
writeln ('Корень равен ',c);
end.
3. Оператор модуля
Данный оператор переводит число из обычного в число по модулю, то есть меняет его знак всегда на положительный. Обозначается, как «abs» без кавычек, в программе пишется, как abs(a), где a — любое число или другая переменная.
Пример:
var a, c:real;
begin
writeln ('Введите число');
readln (a);
c:=abs(a);
writeln ('Модуль равен ',c);
end.На сегодня урок окончен, с другими уроками вы можете познакомиться в категории «Уроки паскаль»
Дата: 2011-12-18 19:47:31 Просмотров: 137086
Теги: Паскаль уроки Pascal
Глава IV. Модули. Программирование под ОС DOS.
§17. Модули.
До сих пор мы писали программы в одном текстовом файле. Когда нам нужна была процедура из другой программы, то мы просто её копировали. Такой подход не всегда удобен. Для того, что бы не копировать подпрограмму из одной программы в другую, существуют модули. Модуль это отдельный файл, в котором описаны процедуры и функции, и которые можно использовать в другой программе. Так же модуль можно использовать для того, что бы сделать код более читаемым. Если у вас в программе очень много подпрограмм, то их можно поместить в отдельный модуль. Что бы процедуры и функции из модуля были доступны в программе, модуль необходимо подключить к программе.
В простейшем виде модуль выглядит так же как и программа, только в место слова Program пишется слово Unit. Так же как и в обычной программе в модуле могут быть разделы описания переменных, констант, процедур и функций. Так же есть слова begin и end, между которыми находится тело модуля. В конце модуля, после слова end, должна стоять точка. Далее пример простейшего модуля:
Unit M;
procedure vivod;
begin
writeln(‘Привет всем!’);
end;
begin
writeln(‘Модуль загрузился.’);
end.
Название модуля (то что находится после слова Unit) должно совпадать с названием файла, в котором хранится модуль. Расширение такого файла должно быть PAS. После компиляции модуль будет содержаться в файле с расширением PCU. Для того, что бы подключить модуль к программе и иметь доступ ко всем его процедурам, функциям, константам и переменным используется слово Uses, после которого следует имя нужного модуля. Если необходимо подключить несколько модулей, то их имена перечисляются через запятую. Для того, что бы эти модули автоматически были найдены, они должны находиться в той же папке, что и программа, или в папке Lib, которая находится там же, где и PascalABC.NET. Пример:
Program Privet;
uses M;
begin
vivod;
end.
__________________
Модуль загрузился.
Привет всем!
Обратите внимание, строчка «writeln(‘Модуль загрузился.’);», находящаяся в теле модуля, никак не вызывается из основной программы, тем не менее она выполняется. Это потому, что тело модуля выполняется при подключении его к программе. Здесь можно произвести какие-либо подготовительные действия, например: загрузить драйвера или определить параметры компьютера. Если вам подобных действий производить не нужно, то тело модуля можно опустить. В таком случае в конце модуля должно просто находиться слово end с точкой. Далее этот же пример, но без тела модуля:
Unit M;
procedure vivod;
begin
writeln(‘Привет всем!’);
end;
end.
==========================
Program Privet;
uses M;
begin
vivod;
end.
__________________________
Привет всем!
Здесь и далее строчка со знаками «равно» будет разделять тексты из различных файлов.
Один нюанс. Если получится так, что в модуле и в программе будут существовать две процедуры с одним и тем же именем (что вполне допустимо), то для обращения к определённой процедуре необходимо поступить следующим образом: вначале написать имя модуля или программы, поставить точку и написать имя процедуры. То же самое относится и к случаям, если у вас одинаковые имена функций, переменных или констант. Пример:
Unit M;
procedure vivod;
begin
writeln(‘Процедура из модуля. Привет всем!’);
end;
end.
==================================================
Program Privet;
uses M;
Procedure Vivod;
begin
writeln(‘Процедура из программы. Привет всем!’);
end;
begin
Privet.vivod;
M.vivod;
end.
__________________________________________________
Процедура из программы. Привет всем!
Процедура из модуля. Привет всем!
Структура модуля, которую мы изучили, называется упрощённым синтаксисом модуля. В учебных целях этого вполне достаточно. Для того, что бы писать свои модули, на первых порах, этого тоже достаточно. Однако на самом деле структура модуля несколько сложнее, и для изучения чужих модулей необходимо знать, как выглядит модуль в полном синтаксисе.
При полном синтаксисе модуля его структура выглядит следующим образом:
unit Imya_Modula;
interface
//раздел интерфейса
implementation
//раздел реализации
initialization
//раздел инициализации
finalization
//раздел финализации
end.
Здесь вы видите четыре зарезервированных слова, каждое из которых открывает свой раздел. Всего в модуле может содержаться четыре раздела, причём последние два могут быть опущены.
Раздел интерфейса. В данном разделе следует указывать заголовки всех подпрограмм, а так же имена переменных и констант, которые будут доступны в программе, к которой будет подключен этот модуль. Это очень удобно т.к. при изучении данного модуля вам достаточно будет просмотреть этот раздел. А так как в нём нет описания (реализации) подпрограмм, то он будет не так велик.
Раздел реализации. В этом разделе необходимо привести описание или другими словами реализацию подпрограмм. Так же здесь можно описать подпрограммы, константы и переменные, которые не указаны в разделе интерфейса, при этом они не будут доступны в программе, к которой будет подключен данный модуль.
Оба раздела интерфейса и реализации могут начинаться со слова uses. Т.е. к любому модулю можно подключить другие модули. При этом из программы, к которой будет подключён данный модуль, они будут не видны.
Раздел инициализации. Этот раздел подобен телу модуля в упрощённом синтаксисе. В нём происходит выполнение кода при загрузке модуля.
Раздел финализации. Этот раздел выполняется при закрытии модуля.
Разделы инициализации и финализации можно опустить. При этом в конце модуля должно стоять слово end с точкой.
Перепишем модуль М в полном синтаксисе:
Unit M;
interface
procedure vivod;
implementation
procedure vivod;
begin
writeln(‘Процедура из модуля. Привет всем!’);
end;
initialization
writeln(‘Модуль М загрузился’);
finalization
writeln(‘Модуль М выгрузился’);
end.
==================================================
Program Privet;
uses M;
Procedure Vivod;
begin
writeln(‘Процедура из программы. Привет всем!’);
end;
begin
Privet.vivod;
M.vivod;
readln;
end.
__________________________________________________
Модуль М загрузился
Процедура из программы. Привет всем!
Процедура из модуля. Привет всем!
Модуль М выгрузился
В конце данной программы я специально поместил процедуру readln для того, что бы было понятно, что раздел финализации выполняется при закрытии программы.
Один нюанс. В разделе реализации при описании процедур и функций можно не писать их передаваемые параметры, а просто указать имя и возвращаемый тип для функций. Это потому, что передаваемые параметры уже указаны в разделе интерфейса. Пример:
Unit Mat;
Interface
function summ(a,b:real):real;
implementation
function summ:real;
begin
summ:=a+b;
end;
end.
=============================
uses Mat;
begin
writeln(summ(2.3,3.4));
end.
____________________________
5.7
В первом абзаце данного параграфа было сказано о некоторых предназначениях модуля. Есть ещё одно, причём основное, это возможность передавать процедуры и функции не в исходном коде, а уже в откомпилированном виде. Это очень удобно т.к. вы случайно не сможете изменить код подпрограммы, и вам не нужно задумываться над тем как она работает, вы просто будете ей пользоваться. Так же в уже откомпилированном виде будет сохранён секрет кода, если это необходимо.
В Pascal существует ряд готовых модулей, без которых не возможно представить себе программирование. Так, например, все процедуры и функции, которыми мы уже умеем пользоваться, и которые не были написаны нами, находятся в модуле System. Этот модуль подключается автоматически к любой программе, и его нет необходимости подключать вручную.
Так же есть модуль CRT, который необходим для работы с консольным окном или как написано в нём самом «Модуль для работы с консолью». Данный модуль мы рассмотрим в следующем параграфе.
В данном параграфе мы изучили модули и научились ими пользоваться.
Задача.
Создать функцию округления вещественного числа до нужной степени. Создать модуль Mat и поместить в него данную функцию. Так же поместить в этот модуль подпрограммы, созданные при решении 3 и 4 задач 14-ого параграфа. Создать программу, использующую данный модуль, и демонстрирующую работу данных функций.
Решение.
Решите эту задачу самостоятельно. Думаю, вы с ней легко справитесь.
Применение готовых и разработанных
программистом модулей позволяет
эффективно решать задачу повторного
использования однажды написанного
кода.
23.1. Назначение и структура модулей
Модуляминазывают заранее
скомпилированные библиотеки подпрограмм,
которые программист может использовать
для создания новых программ. При
программировании на Паскале модули
подключаются из специальных библиотечных
файлов, имеющих тип *.tpu(TurboPascalUnit). Модуль сам по себене являетсявыполняемой программой,
но его подпрограммы используются
другими программами.
Для того, чтобы создать модуль, нужно
написать файл с расширением *.pas,
соблюдающий описанную далее структуру
модуля, затем в менюCompileоболочки Паскаля установить переключательDestinationв значениеDisk(как мы помним, это же нужно сделать,
если Вы собираетесь получить из своей
программы на Паскале приложение *.exe),
затемсобратьмодуль, выбрав в менюCompileпунктBuild.
После устранения ошибок компиляции
готовый модуль (файл с расширением
*.tpu) будет находиться в
папке Паскаля.
Структура модуля такова (новые ключевые
слова выделены жирным):
unit
Имя; {Это заголовок модуля, именующий
его. По этому имени модуль может быть
подключен из программы оператором uses}
interface
{Интерфейсная часть — здесь мы объявляем
константы,
типы данных, переменные, процедуры и
функции.
Тела
общих процедур и функций находятся в
разделе реализации.
Раздел
интерфейса является общим. В нем можно
определить то, что будет
видимо
и доступно для любой другой программы
(или модуля),
использующей
данный модуль. В интерфейсной части
может находиться раздел
Uses,
если модуль подключает другие модули.
В таком случае, слово Uses должно
следовать
сразу за словом Interface}
Implementation
{В
разделе реализации (Implementation) модуля
находятся тела процедур и функций,
объявленных
в интерфейсной части.
Раздел
реализации является частным. Все
объявления, сделанные здесь могут быть
видимы
только внутри данного раздела модуля.
Все
константы, типы, переменные, процедуры
и функции, объявленные в
интерфейсной
части видимы в разделе реализации.
В
разделе реализации могут находиться
ее собственные дополнительные объявления,
невидимые
любым программам, использующим модуль.
Раздел
Uses может находиться в части реализации
сразу после
зарезервированного
слова Implementation.
Заголовок
процедуры/функции в разделе реализации
должен быть идентичен
объявлению
в разделе интерфейса}
begin
{обычно
«главная программа» модуля пуста.
Здесь можно давать начальные
значения
данным модуля, открывать используемые
им файлы, если таковые есть,
и
т.п.}
end.
Для работы с координатами точек на
плоскости создадим простейший модуль
и вызовем его подпрограммы его при
написании новой программы:
unit Points;
interface
type point = array [1..2] of
real;
procedure put (var
p:point;x,y:real);
function distance
(p1,p2:point):real;
function corner
(p1:point):integer;
implementation
procedure put (var
p:point;x,y:real);
begin
p[1]:=x; p[2]:=y;
end;
function distance
(p1,p2:point):real;
begin
distance:=sqrt(sqr(p1[1]-p2[1])+sqr(p1[2]-p2[2]));
end;
function corner
(p1:point):integer;
begin
if p1[1]>0 then begin
if p1[2]>0 then corner:=1
else if p1[2]<0 then
corner:=4
else corner:=0;
end
else if p1[1]<0 then begin
if p1[2]>0 then corner:=2
else if p1[2]<0 then
corner:=3
else corner:=0;
end
else corner:=0;
end;
begin
end.
Наш модуль определяет тип данных Point(точка) как массив из 2 вещественных
чисел. Процедураputпозволяет задать для точки значенияx-
иy-координаты, функцияdistanceвозвращает расстояние между двумя
точками, а функцияcorner– номер координатной четверти, в которой
находится точка, или 0, если точка лежит
на одной из осей координат. Разумеется,
реальные модули могут включать сотни
функций, если предметная область, которую
они моделируют, достаточно сложна.
Теперь напишем маленькую тестовую
программу, использующую наш модуль:
uses Points;
var a,b:Point;
begin
put (a,1,1);
put(b,0,0);
writeln (‘Расстояние
от A до B=’,distance(a,b):8:3);
writeln (‘Номер
координатной четверти для A=’,corner(a));
end.
Оператор uses,
подключающий модуль, указан в первой
строке программы. Во время компиляции
этой программы в текущем каталоге должен
присутствовать файлpoints.tpu,
содержащий созданный ранее модульPoints.
При сборке сложной программы Паскаль
ищет модули только в тех папках, которые
перечислены в поле ввода Unit
directoriesокнаDirectoriesверхнего менюOptions,
поэтому все готовые модули следует либо
помещать в одну из этих папок, либо
дописать в поле ввода нужные пути к
папкам. В Приложении 4 приводится полный
листинг модуля для работы с «мышью»
из программы на Паскале и тесты для
него.
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]
- #
- #
- #
- #
- #
- #
- #
- #
- #
- #
- #