Здавалка
Главная | Обратная связь

Var k: Integer; Func_2



Begin

………

k := Func_1(y); обращение к функции Func_1

………

End;

Function Func_1; описание функции

Var n: Integer; Func_1 без списка формальных

Begin параметров

……….

n := Func_2(x); обращение к функции Func_2

……….

End;

Begin основная программа

……..

i := Func_1(i); обращение к функции Func_1

…….. в основной программе

End.

Примеры:

1. Составить функцию, рекурсивно определяющую значение биномиального коэффициента при 0<m<n по формулам:

= = 1, = +

Function Binom(m, n: Word): Word;

Begin

If (m=0) Or (m=n)

Then Binom := 1 выход из рекурсии

Else Binom := Binom(m, n-1) + Binom(m-1, n-1) рекурсия

End;

2. Составить функцию, рекурсивно определяющую максимальный элемент в заданной части целочисленного массива An , начиная с k-го и до n-го элемента:

Const n = 100;

Type TArray = Array [1..n] Of Integer;

………………………………………..

Function Max_element(a: TArray; k,n: Word): Integer;

Var temp : Integer;

Begin

If (k=n)

Then Max_element := a[n]

Else

Begin

temp := Max_element(a, k+1, n);

If (a[k] > temp)

Then Max_element := a[k]

Else Max_element := temp

End;

End;

Особенности рекурсии:

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

· недостатки рекурсии состоят в следующем:

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

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

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

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

В целях повышения безопасности работы рекомендуется:

· для включения проверки переполнения стека необходимо использовать директиву компилятора {S+},

· для включения проверки диапазона необходимо использовать директиву компилятора {R+},

· в начале каждой рекурсивной процедуры или функции поместить строку
If KeyPressed Then Halt.Она позволяет при зависании программы выйти из нее без перезагрузки компьютера, просто нажав любую клавишу.

 

 

Процедуры

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

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

Как и функция, процедура располагается в вызывающей программе после раздела описания переменных Var и состоит из заголовка, блока описаний и блока операторов.

Заголовок записывается как первая строка процедуры и начинается словом Procedure, за которым следует ее имя. После имени процедуры в скобках перечисляются имена и типы формальных параметров (аргументов процедуры). Заголовок заканчивается точкой с запятой:

Procedure Proc(n,m: Integer; a: Real; Var k: Integer; Var s, d: Real);

Описан заголовок процедуры Proc, зависящей от двух аргументов (входных параметров) целого типа n, m и аргумента a вещественного типа. Выходные (вычисляемые) параметры: переменная k целого типа и переменные s и d вещественного типа.

Допускаются процедуры без списка формальных параметров:

Procedure Zagolovok;

Begin

WriteLn(‘Группа ИС-09’);

WriteLn(‘Студент Иванов Иван’);

End;

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

В остальном структура процедуры не отличается от структуры программы на Паскале и может включать в себя следующие разделы:

· описания меток Label

· определения констант Const

· определения типов Type

· описания переменных Var

· описания процедур и функций Function, Procedure

· операторов процедуры Begin … End;

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

Пример: описать процедуру, обменивающую значениями две переменных целого типа:

Procedure Swap(x, y: Integer);x и y – входные параметры-значения

Var temp: Integer; temp – локальная переменная

Begin

temp := x; реализация алгоритма

x := y; циклического обмена

y := temp;

End;

Эта процедура ничего не делает: в списке формальных параметров указаны параметры-значения. Правильное описание с использованием параметров-переменных:

Procedure Swap(Var x, y: Integer);x и y – входные параметры-

Var temp: Integer; переменные

Begin

temp := x;

x := y;

y := temp;

End;

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

Program Primer;

Uses CRT;

Var a, b: Integer; a и b – переменные основной программы (глобальные)

Procedure Swap(Var x, y: Integer);x и y – входные параметры-

Var temp: Integer; переменные

Begin

temp := x;

x := y;

y := temp;

End;

Begin

ClrScr;

a := 3;

b := 5;

Swap(a, b); обращение к процедуре

WriteLn(‘a=’,a);

WriteLn(‘b=’,b);

ReadLn;

End.

На экран будет выведено:

a=5

b=3

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

Как уже отмечалось в правилах формирования подпрограмм-функций, для передачи в подпрограмму массива необходимо предварительно определить его в разделе описания типов, то есть явно задать количество его элементов и их тип. Значит, подпрограмма, формальным параметром которой является массив из десяти чисел, не сможет работать с массивом из пятнадцати чисел. Это неудобно, поэтому в списке формальных параметров подпрограмм разрешается определять открытые массивы.

Открытые массивы – это вектора, состоящие из элементов любого типа, кроме файлового. На место открытого массива в качестве фактического параметра можно передавать вектор любого размера, состоящий из элементов того же типа, что и элементы открытого массива:

Procedure Summ(a: Array Of Integer; Var summa: Integer);

Var i: Word;

s: Integer;

Begin

s:= 0;

For i:=0 To High(a) Do нумерация элементов начинается с нуля!

s:= s + a[i]; номер последнего элемента определяетсяс

summa:= s; помощью функции High

End;

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

Примеры: задать целочисленный вектор a длиной n элементов случайным образом с элементами от m_min до m_max..

1. Определить минимальный min и максимальный max элементы вектора и их индексы i_min, i_max. Результаты сохранить в текстовом файле out_min_max.txt:

 

Program Primer_1;

Uses CRT;

Const n = 10; размер вектора

m_min = -50; диапазон значений

m_max = 50; элементов вектора

Type TVector = Array [1..n] Of Integer;

Var i, i_min, i_max: Word;

min, max: Integer;

a : TVector;

out_min_max: Text; файловая переменная

Procedure Init(elem_min, elem_max: Integer; Var Vector: Array Of Integer); используется открытый массив Vector

Var i: Word;

Begin

Randomize; запуск генератора случайных чисел

For i:=0 To High(Vector) Do задание элементов массива случайными числамив диапазоне от elem_min до elem_max

Vector[i]:=elem_max - Random(elem_max - elem_min +1);

End;

Procedure Min_max(m: Word; vector: TVector; Var min, max: Integer; Var i_min, i_max: Word); используется массив vector типа TVector

Var i: Word;

Begin

min:=vector[1]; перед поиском минимального и максимального элементов

max:=vector[1]; массива за таковые принимается первый элемент i_min:=1; массива

i_max:=1;

For i:=2 To m Do поиск начинаем со второго элемента

Begin

If (vector[i] < min) Then

Begin

min:=vector[i];

i_min:=i;

End;

If (vector[i] > max) Then

Begin

max:=vector[i];

i_max:=i;

End;

End;

End;

Begin

ClrScr;

Assign(out_min_max,’d:\User\out_min_max.txt’);

ReWrite(out_min_max); открытие текстового файла для записи

Init(m_min, m_max, a); инициализация массива

Writeln(out_min_max, ‘Исходный вектор:’);

For i:=1 To n Do

Write(out_min_max, a[i]:5);

WriteLn(out_min_max);

Min_max(n, a, min, max, i_min, i_max); поиск элементов массива

WriteLn(out_min_max, ‘min=’, min);

WriteLn(out_min_max, ‘i_min=’, i_min);

WriteLn(out_min_max, ‘max=’, max);

WriteLn(out_min_max, ‘i_max=’, i_max);

Close(out_min_max); закрытие текстового файла

ReadLn;

End.

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

Исходный вектор:

-1 -19 -19 -35 50 26 -47 17 1 -7

min=-47

i_min=7

max=50

i_max=5

2. Отсортировать элементы массива методом простого выбора: в массиве отыскивается минимальный элемент и меняется с первым элементом массива, из оставшихся элементов снова находится минимальный и меняется со вторым элементом, и так далее. Последний, самый большой элемент, сам станет на свое место. Результаты сохранить в текстовом файле out_sort.txt:

Program Primer_2;

Uses CRT;

Const n = 10; размер массива

m_min = -50; диапазон значений

m_max = 50; элементов массива

Type TVector = Array [1..n] Of Integer;

Var i: Word;

a : TVector;

out_sort: Text; файловая переменная

Procedure Init(m: Word; elem_min, elem_max: Integer; Var vector: TVector);

Var i: Word;

Begin

Randomize; запуск генератора случайных чисел

For i:=1 To m Do задание элементов массива случайными числами
в диапазоне от elem_min до elem_max

vector[i]:=elem_max - Random(elem_max - elem_min +1);

End;

Procedure Sort_vybor(m: Word; Var vector: TVector);

Var i, j, k: Word;

temp: Integer;

Begin

For i := 1 To m-1 Do

Begin

k := i;

temp := vector[i];

For j := i + 1 To m Do

If (vector[j] < temp) Then

Begin

temp := vector[j];

k:= j;

End;

vector[k] := vector[i];

vector[i] := temp;

End;

End;

Begin

ClrScr;

Assign(out_sort,’d:\User\out_sort.txt’);

ReWrite(out_sort); открытие текстового файла для записи

Init(n, m_min, m_max, a); инициализация массива

Writeln(out_sort, ‘Исходный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Sort_vybor(n, a); сортировка элементов массива

Writeln(out_sort, ‘Отсортированный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Close(out_sort); закрытие текстового файла

ReadLn;

End.

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

Исходный вектор:

-15 -31 12 -10 50 -27 36 -29 2 5

Отсортированный вектор:

-31 -29 -27 -15 -10 2 5 12 36 50

3. Отсортировать элементы массива методом простого обмена (методом пузырька): сравниваются попарно два очередных рядом стоящих элемента и при необходимости переставляются по возрастанию. После первого прохода массива его максимальный элемент становится на последнее место, после второго прохода максимальный из оставшихся становится на предпоследнее место и так далее. Таким образом, после каждого очередного прохода по массиву максимальный элемент из оставшихся как бы всплывает наверх – к концу массива. Всего необходимо n – 1 прохода. Результаты сохранить в текстовом файле out_sort.txt:

 

Program Primer_3;

Uses CRT;

Const n = 10; размер массива

m_min = -100; диапазон значений

m_max = 100; элементов массива

Type TVector = Array [1..n] Of Integer;

Var i: Word;

a : TVector;

out_sort: Text; файловая переменная

Procedure Init(m: Word; elem_min, elem_max: Integer; Var vector: TVector);

Var i: Word;

Begin

Randomize; запуск генератора случайных чисел

For i:=1 To m Do задание элементов массива случайными числами
в диапазоне от elem_min до elem_max

vector[i]:=elem_max - Random(elem_max - elem_min +1);

End;

Procedure Sort_obmen(m: Word; Var vector: TVector);

Var i, j, k: Word;

temp: Integer;

Begin

For i := m DownTo 2 Do

For j := 1 To i – 1 Do

If (vector[j] > vector[j+1]) Then

 

Begin

temp := vector[j];

vector[j] := vector[j+1];

vector[j+1]:= temp;

End;

End;

Begin

ClrScr;

Assign(out_sort,’d:\User\out_sort.txt’);

ReWrite(out_sort); открытие текстового файла для записи

Init(n, m_min, m_max, a); инициализация массива

Writeln(out_sort, ‘Исходный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Sort_obmen(n, a); сортировка элементов массива

Writeln(out_sort, ‘Отсортированный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Close(out_sort); закрытие текстового файла

ReadLn;

End.

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

Исходный вектор:

47 -14 58 -69 9 -19 -72 24 97 -32

Отсортированный вектор:

-72 -69 -32 -19 -14 9 24 47 58 97

4. Отсортировать элементы массива методом простых вставок: в уже отсортированной части элементов массива a1, a2, a3,…,ak отыскивается место для следующего элемента ak+1 . Результаты сохранить в текстовом файле out_sort.txt:

Program Primer_4;

Uses CRT;

Const n = 10; размер массива

m_min = -150; диапазон значений

m_max = 150; элементов массива

Type TVector = Array [1..n] Of Integer;

Var i: Word;

a : TVector;

out_sort: Text; файловая переменная

Procedure Init(m: Word; elem_min, elem_max: Integer; Var vector: TVector);

Var i: Word;

Begin

Randomize; запуск генератора случайных чисел

For i:=1 To m Do задание элементов массива случайными числами
в диапазоне от elem_min до elem_max

vector[i]:=elem_max - Random(elem_max - elem_min +1);

End;

Procedure Sort_vstavka(m: Word; Var vector: TVector);

Var i, j, k: Word;

temp: Integer;

Begin

For i := 2 To m Do

Begin

temp := vector[i];

j := i – 1;

k := 1;

While (j > 0) Do

If (vector[i] > vector[j]) Then

Begin

k := j + 1;

j := 0;

End

Else j := j – 1;

For j := i DownTo k + 1 Do

vector[j] := vector[j - 1];

vector[k] := temp;

End;

End;

Begin

ClrScr;

Assign(out_sort,’d:\User\out_sort.txt’);

ReWrite(out_sort); открытие текстового файла для записи

Init(n, m_min, m_max, a); инициализация массива

Writeln(out_sort, ‘Исходный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Sort_vstavka(n, a); сортировка элементов массива

Writeln(out_sort, ‘Отсортированный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Close(out_sort); закрытие текстового файла

ReadLn;

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

Исходный вектор:

115 -45 20 -39 91 75 44 138 -72 -63

Отсортированный вектор:

-72 -63 -45 -39 20 44 75 91 115 138

 

5. Отсортировать элементы массива методом быстрой сортировки К.Хоара: сравниваются элементы ai и aj , причем i = 1, j = n. Если ai < aj , то эти элементы уже отсортированы по возрастанию, поэтому значение правого индекса уменьшается на единицу, и алгоритм повторяется. Если ai > aj , то они меняются местами, останавливается правый индекс, и начинает увеличиваться левый. Обмен значениями с изменением направления движения после каждого обмена продолжается до тех пор, пока левый и правый индексы не встретятся друг с другом: i = j. В этом случае элемент ai будет стоять на своем месте в массиве: слева от него стоят элементы меньше его, а справа – больше. После этого алгоритм рекурсивно повторяется для левой и правой частей массива. Результаты сохранить в текстовом файле out_sort.txt:

Program Primer_6;

Uses CRT;

Const n = 10; размер массива

m_min = -100; диапазон значений

m_max = 100; элементов массива

Type TVector = Array [1..n] Of Integer;

Var i: Word;

a : TVector;

out_sort: Text; файловая переменная

Procedure Init(m: Word; elem_min, elem_max: Integer; Var vector: TVector);

Var i: Word;

Begin

Randomize; запуск генератора случайных чисел

For i:=1 To m Do задание элементов массива случайными числами
в диапазоне от elem_min до elem_max

vector[i]:=elem_max - Random(elem_max - elem_min +1);

End;

Procedure Sort_Hoar(m, bottom, top: Word; Var vector: TVector);

Var i, j: Word;

Str: Boolean;

temp: Integer;

Begin

i := bottom;

j := top;

str := False;

While (i < j) Do

Begin

If (vector[i] > vector[j]) Then

Begin

temp := vector[i];

vector[i] := vector[j];

vector[j] := temp;

str := Not(str);

End; {If}

If (str)

Then i := i + 1

Else j := j – 1;

End; {While}

If (i > 1) And ((i – 1) > bottom)

Then Sort_Hoar(m, bottom, i – 1, vector);

If (j < (m – 1)) And ((j + 1) < top)

Then Sort_Hoar(m, j + 1, top, vector);

End;

 

Begin

ClrScr;

Assign(out_sort,’d:\User\out_sort.txt’);

ReWrite(out_sort); открытие текстового файла для записи

Init(n, m_min, m_max, a); инициализация массива

Writeln(out_sort, ‘Исходный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Sort_Hoar(n, 1, n, a); сортировка элементов массива

Writeln(out_sort, ‘Отсортированный вектор:’);

For i:=1 To n Do

Write(out_sort, a[i]:5);

WriteLn(out_sort);

Close(out_sort); закрытие текстового файла

ReadLn;

End.

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

Исходный вектор:

-62 18 -48 46 -44 -58 -95 76 4 -65

Отсортированный вектор:

-95 -65 -62 -58 -48 -44 4 18 46 76

Метод К.Хоара считается одним из самых быстрых методов сортировок.

 

 

Программные модули

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

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

Прежде чем приступить к рассмотрению модульного программирования, разберемся, как происходит обработка исходного текста программы (кода программы) в системе программирования Turbo Pascal (Borland Pascal).

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

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

Другими словами, исходный код (текст) программы перед выполнением должен быть преобразован в исполняемый код. Это перевод английского слова executable , от него же и произошло известное расширение имен исполняемых файлов – .exe. Исходный же текст программы на Паскале имеет расширение имени - .pas. Обратное преобразование невозможно – из исполняемых файлов уже нельзя восстановить исходный текст программы на Паскале, поэтому все исходные тексты должны сохраняться для их последующей доработки.

При работе в Turbo Pascal исполняемый код формируется в оперативной памяти и без записи его на диск сразу выполняется. При работе в среде BorlandPascal исполняемый файл формируется автоматически, поэтому файл с расширением .exe появляется в текущем каталоге после первого удачного запуска программы.

 

Процесс преобразования исходного кода в исполняемый происходит в два этапа:

1. компиляция,

2. компоновка (линковка).

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

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

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

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

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

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

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

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

Преимущества такого подхода к созданию программ очевидны:

1. программа получается понятнее, ее легче совершенствовать в дальнейшем,

2. отдельные модули могут разрабатываться различными программистами, так как это относительно автономные программные единицы,

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

4. модули, включаемые в исходный код программы, хранятся на диске в откомпилированном виде. Поэтому процесс подготовки всей программы к выполнению займет меньше времени – компилироваться будет только основная программа,

5. при выполнении программы в среде Turbo Pascal исполняемый код модулей размещается в отдельных сегментах памяти, что дает возможность создавать программы большого размера (более 64К).

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

Стандартные модули: SYSTEM, CRT, GRAPH, DOS, PRINTER, OVERLAY образуют системную библиотеку Паскаля Turbo.tpl (Turbo Pascal Library).Модуль SYSTEM подключается к программе пользователя автоматически, остальные модули указываются в операторе Uses:

Uses CRT, GRAPH;

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

 

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

Модуль – это самостоятельная отдельно компилируемая программная единица, поэтому его структура напоминает структуру обычной программы:

1. заголовок модуля

2. интерфейсный раздел

3. раздел реализации

4. инициирующий раздел.

Собственно программный код располагается в исполняемой части, иногда в инициирующей. Заголовок и интерфейсная часть задают название модуля и перечисление всех программных элементов, которые представляет этот модуль тем программам или другим модулям, которые будут его использовать. Исходный текст модуля, как и любой Паскаль-программы, содержится в файле с расширением имени .pas. После компиляции модуля на диске создается файл с объектным кодом и расширением имени .tpu. (Turbo Pascal Unit).

Заголовок модуля содержит слово Unit и имя модуля:

Unit Abc;

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

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

Interface

Uses список модулей, используемых интерфейсным разделом

Const объявление глобальных констант

Type объявление глобальных типов

Var объявление глобальных переменных

Function заголовки функций и процедур со списками формальных

Procedure параметров, видимых другиммодулям и головной программе

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

Implementation

Uses список модулей, используемых разделом реализации (скрытых)

Const объявление локальных констант

Type объявление локальных типов

Var объявление локальных переменных

Function описание указанных ранее функций и процедур без списка Procedure формальных параметров

Этот раздел скрыт от вызывающей программы и других модулей.

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

Begin

…….

End.

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

 

Пример: создать модуль My_modul, который содержал бы

1. функцию Geron для определения площади треугольника по формуле Герона,

2. процедуру Swap для обмена значениями двух переменных вещественного типа,

3. текстовый файл f.txt для записи в него результатов работы функции Geron

Unit My_modul;

Interface интерфейсный раздел

Var f: Text;

{определение площади треугольника по формуле Герона – по трем его сторонам a, b, c – вещественного типа}

Function Geron(a, b, c: Real): Real;

{обмен значениями двух переменных x и y - вещественного типа}

Procedure Swap(Var x, y : Real);

Implementation раздел реализации

Function Geron;

Var p: Real;

Begin

p := (a + b + c) / 2.0; {полупериметр}

Geron := Sqrt(p * (p –a) * (p – b) * (p – c));

End;

Procedure Swap;

Var temp: Real;

Begin

temp := x;

x := y;

y := temp;

End;

 

 

Begin инициирующий раздел

Assign(f, ‘D:\User\f.txt’);

End.

Сохраним этот файл на диске с именем My_modul.pas.

 

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

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

Результатом компиляции модуля является файл с тем же именем и расширением tpu (Turbo Pascal Unit), который можно хранить на диске так же, как и exe-файл.

Меню Compile, управляющее процессом компиляции, содержит следующие опции:

Compile

Make

Build







©2015 arhivinfo.ru Все права принадлежат авторам размещенных материалов.