Теоретический материал (Паскаль)

Сайт: Информатикс
Курс: Функции и процедуры. Рекурсия
Книга: Теоретический материал (Паскаль)
Напечатано:: Гость
Дата: Пятница, 21 Январь 2022, 10:10

Понятие подпрограммы. Процедуры и функции. Стандартные подпрограммы

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

Подпрограммы решают три важные задачи:

  • избавляют от необходимости многократно повторять в тексте программы аналогичные фрагменты;

  • улучшают структуру программы, облегчая ее понимание;

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

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

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

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

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

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

  5. Все, что Вы сделали хорошо в одной программе, Вам захочется перенести в новые. Для повторного использования таких частей лучше сразу выделять в программе полезные алгоритмы в отдельные подпрограммы.

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

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

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

Help содержит подробные описания предусмотренных средой программирования процедур и функций. Для вызова подсказки при работе со стандартными процедурами и функциями нужно поставить на имя подпрограммы курсор и нажать клавиши <Ctrl+F1>. Справочная информация о процедурах и функциях в Help имеет стандартную структуру.

Задание. Вызовите помощь по функции Cos и рассмотрите предоставленную информацию.

Сначала идет краткое описание подпрограммы (в одну фразу). Далее под словом Declaration (Объявление) следует интерфейсная часть процедуры или функции, которая  необходима для определения типов фактических параметров. Далее под словом Target приводятся платформы, на которых может использоваться подпрограмма: Windows, real (реальный режим DOS), protected (защищенный режим DOS). После слова Remarks следуют заметки, содержащие необходимые детали использования. В разделе See Also приведены имена подпрограмм, связанных с данной по смыслу или по совместному применению. Если перемещать курсор по этим именам (они выделяются подсветкой), то, выбрав одно из них (нажав клавишу <Enter>), можно получить справку по следующей подпрограмме. Каждая процедура и функция сопровождается примером применения, переключение к которому дает последняя строка справочной информации. Любой текст из Help может быть скопирован в редактируемый файл обычными приемами копирования через буфер. Копирование примеров или заголовков функций может значительно облегчить работу.

Существует другой способ получения сведений о процедурах и функциях. Для этого нужно использовать пункт меню Help/Reserved words (зарезервированные слова) или Help/Standard units (стандартные модули).

Задание. Рассмотрите список процедур и функций, выберите какие-либо из них и ознакомьтесь со справочной информацией.

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

Существует два способа объединения программ и подпрограмм пользователя:

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

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

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

Структура текста подпрограммы соответствует структуре текста основной программы за двумя исключениями:

  • подпрограмма начинается с заголовка, содержащего имя подпрограммы, передаваемые в нее и возвращаемые от нее параметры, т.е.  запись заголовка подпрограммы отличается от заголовка программы;

  • подпрограмма кончается не точкой, а точкой с запятой.

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

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

Например, вызов функции

M:= MIN (X, Y)

вернет в основную программу значение наименьшего из двух чисел и это значение будет присвоено переменной M.

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

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

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

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

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

Если говорить о плюсах использования  подпрограмм, то можно назвать следующие:

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

  2. Программа становится более читаемой.

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

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

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

Процедуры и функции объявляются в разделе описания вслед за разделом переменных.

Общая структура программы выглядит так:

Рrogram hh;
  Label; {описание меток}
  Const; {описание констант}
  Type; {описание типов}
  Var; {описание переменных}
  Procedure; {описание процедур}
  Function; {описание функций}
Begin
  . . .
  . . .
end.

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

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

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

На этом занятии рассмотрим примеры организации наиболее простого вызова подпрограмм.

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

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

Program AkulovE;
Uses
  Crt;
Var
  x, y : LongInt;
Procedure Input;
Begin
  TextColor(12);
  writeln('По вызову активизировалась процедура "Input"',#10);
  TextColor(7);
  writeln('Введите два числа через пробел - ');
  readln(x, y);
End;
{  - - - - - - - - - - - - - - - - - - - -}
Procedure Summa;
Begin
  TextColor(14);
  writeln('Для сложения подключилась процедура "Summa"',#10);
  x:=x+y;
End;
{  - - - - - - - - - - - - - - - - - - - -}
Procedure Output;
Begin
  TextColor(10);
  writeln('Заключительная часть. Процедура "Output"',#10,#13);
  TextColor(7);
  writeln('Их сумма - ',x);
End;
{  - - - - - - - - - - - - - - - - - - - -}
Begin
  ClrScr;
  Input;
  Summa;
  Output;
  readln;
End.

Задача 2. Найти среднее арифметическое двух чисел.

Program Fadeev;
Uses
  Crt;
Var
  A, B : integer;
  Rez :real;
{  - - - - - - - - - - - - - - - - - - - -}
Function SredArif(A, B:integer):real;
Begin
  SredArif:=(A+B)/2;
End;
{  - - - - - - - - - - - - - - - - - - - -}
Begin
  ClrScr;
  write('Введите два числа ');
  readln(A,B);
  Rez:=SredArif(A,B);
  write('Cреднее арифметическое этих чисел равно ',Rez:5:3);
  readln;
End.

Формальные и фактические параметры. Вызов по ссылке и по значению. Локальные и глобальные переменные и подпрограммы

Формальные и фактические параметры

Формальные параметры подпрограммы указывают, с какими аргументами следует обращаться к этой подпрограмме (количество аргументов, их последовательность, типы). Они задаются в заголовке подпрограммы в виде списка, разбитого на группы. Разделителем групп является знак точка с запятой (;). В каждую группу  включаются  параметры одного типа, принадлежащие к одной  категории.

Все формальные параметры можно разбить на четыре категории:

  • параметры-значения;
  • параметры-переменные;
  • параметры-константы (используются только в версии 7.0);
  • параметры-процедуры и параметры-функции.

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

function Max( A: array[ 1..100 ] of real ): real;

Чтобы правильно записать этот заголовок, следует в основной программе ввести тип-массив, а затем использовать его в заголовке:

type tArr =array [ 1..100 ] of real;
function Max ( A: tArr ) : real;

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

Вызов по ссылке и по значению

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

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

Приведем примеры:

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

Procedure SetDate (Year, Month, Day : Word);

В подпрограмму передается три величины. Ее вызов в основной программе может иметь различные формы:

  • SetDate (MyYear, MyMonth, MyDay); где MyYear, MyMonth, MyDay - переменные типа Word, которые описаны в основной программе и должны иметь при обращении к процедуре определенные значения. При вызове процедуры эти значения присваиваются внутренним переменным процедуры Year, Month, Day.

  • SetDate (MyYear+1, MyMonth div 2, MyDay); при вызове процедуры используются арифметические выражения, которые вычисляются при вызове. В подпрограмму поступает результат вычислений.

  • SetDate (1999, 1, 31); где в подпрограмму передаются значения констант.

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

Приведем пример.

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

Procedure GetDate (Var Year, Month, Day : Word);

Она имеет три переменные, передаваемые по ссылке. Если мы аналогично предыдущему случаю, вызовем эту процедуру из основной программы командой

GetDate (MyYear, MyMonth, MyDay);

процедура разместит свои переменные Year, Month, Day в тех же ячейках памяти, что и переменные основной программы MyYear, MyMonth, MyDay. После завершения подпрограммы эти переменные сохраняют полученные в процедуре значения.

В 7 версии Borland Pascal предусмотрен новый механизм передачи в подпрограмму параметров по значению. Этот механизм используется, если значение параметра не должно изменяться - это параметры-константы.

Объявление параметра-константы в заголовке подпрограмм имеет вид

  const <имя константы>:<тип константы>

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

  • константа может быть задана в явном виде;

  • может быть указана переменная или выражение совместимого с константой типа.

Например, Procedure Primer (Const x : byte).

Внимание! При вызове процедур необходимо следить за соответствием типов данных в вызывающей программе и подпрограмме.

Параметрызначения

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

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

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

Пример.

procedure Inp ( Max, Min: real ; N: Word );
function Mult (X, Y: integer): real;

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

Inp(Abs (Z), - Abs (T), 2 * K);
M:=Mult(X + Y, X - Y);
MA:=MAX( B, 5 );

Локальные и глобальные переменные и подпрограммы

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

Рассмотрим две почти одинаковые программы.

Program Variant1;    
Var
  X : real;
Procedure writeX;
Var
  X : real;
Begin
  write(X)
End;
Begin
  X := Pi;;
  writeX
End.

Program Variant2;
Var
  X : real;
Procedure writeX;
Begin
  write(X)
End;
Begin
  X := Pi;
  writeX
End.

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

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

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

Возникает вопрос, какова роль локальных переменных, нельзя ли все переменные описать как глобальные?

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

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

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

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

Процедуры

Структура процедуры имеет следующий вид:

Procedure <имя процедуры>(формальные параметры);
Var
  (локальные переменные)
begin
  . . .
end;

Процедура вызывается по имени:

  <имя процедуры> (фактические параметры);

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

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

Заголовок процедуры может выглядеть так:

  PROCEDURE GG(a, b, c : integer);

а вызываться она может так: GG(3, n, m)

Здесь a, b, c – формальные параметры, а 3, n, m – фактические параметры.

Таким образом, в процедуру передаются значения: a=3, b=n, c=m.

Переменные, описанные в процедуре в разделе описаний переменных после слова Var, являются внутренними переменными процедуры, т.е. промежуточными. Они не являются исходными данными для операций внутри процедуры и не являются результатом её выполнения, а нужны лишь для хранения промежуточной информации.

Данные и результаты описываются в круглых скобках после имени процедуры. Перед описанием переменных-результатов пишут служебное слово var.

Например:

Procedure express(a, b, c : real; var x, y : real);
Var
  z : real;
begin
  z:=a + b + c;
  x:=sqr(z);
  y:=sqrt(z);
end ;

Эту процедуру можно вызвать следующим образом:

express(8.6, 6.9, 9.5, x1, y1);

Входные формальные параметры a, b, c принимают значения соответствующих фактических параметров: a=7.6; b=6.8; c=9.5.

При этих значениях выполняется процедура. Результатом выполнения процедуры являются x, y, которые передают свои значения соответствующим фактическим параметрам x1, y1. Таким образом, в основной программе будем иметь x1=625, y1=5.

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

Функции

Другой вид подпрограммы – функция оформляется аналогично процедуре. Отличительные особенности функции: она имеет только один результат выполнения (но может иметь несколько входных параметров); результат обозначается именем функции и передаётся в основную программу.

Функция оформляется в следующем виде:

Function <имя функции>(формальные параметры): тип значения функции;
Var
  . . .
Begin
  . . .
End ;

Вызывается функция по её имени с указанием фактических параметров.

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

Пример. Пусть требуется найти (x! - y!) * d!.

Напомним, что n! представляет собой произведение n чисел натурального ряда: n! = 1*2*3*......*n

Function fac(n: integer): integer;
Var
  p, i: integer;
Begin
  p:=1;
  for i:=2 to n do
    p:=p*i;
  fac:=p;
End;

Вызвать данную функцию можно так: f := (fac(x) - fac(y)) * fac(d).

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

Различие между процедурами и функциями

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

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

Program ProcedureAndFunction;
Uses
  Crt;
Var
  a, b, SumNumbers : integer;
Procedure Summa1(Var Sum : integer; a, b : integer);
Begin
  Sum:= a+b;
End;

Function Sum(a, b : integer) : integer;
Begin
  Sum:= a+b;
End;

Begin
  ClrScr;
  a := 12;
  b := 15;
  Summa1(SumNumbers, a, b);
  writeln ('С помощью процедуры сумма чисел равна ', SumNumbers);
  writeln ('С помощью функции сумма чисел равна ', Sum(a, b));
End.

Вызов процедуры производится по ее имени. Наряду с параметрами-значениями a и b, которые подлежат сложению, в списке параметров присутствует параметр-переменная Sum, который содержит возвращаемое процедурой значение – сумму.

Функция же имеет только два параметра. Это связано с тем, что само имя функции представляет собой идентификатор параметра, значение которого после окончания работы функции равно результату вычисления. Этот параметр соответствует параметру-переменной Sum процедуры. При объявлении функции ей в соответствие ставят определенный тип данных – тип возвращаемого функцией значения.

Объявление функции

Function Sum(a, b : integer) : integer;

внешне похоже на объявление переменной Sum типа integer. Тип функции объявляется следом за списком параметров – после закрывающейся скобки этого списка и двоеточия.

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

SumNumbers:= Sum(a,b);

Если не обращать внимания на наличие списка параметров, то этот оператор выглядит как присвоение переменной SumNumbers значения переменной Sum. Компилятор, конечно же, знает, что Sum – это имя функции (т.к. определение функции предшествует ее использованию) и организует вычисления соответствующим образом. Точно так же, как константа или переменная, вызов функции может использоваться в списке параметров оператора write (см. программу), что для процедур невозможно.

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

Итак, из вышесказанного возьмите на заметку следующее.

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

Особенности использования процедур и функций

Опережающее описание процедуры (директива Forward)

Описание процедуры, содержащее вместо блока операторов директиву Forward, называют опережающим описанием.

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

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

Program Primer;
. . .

Procedure Proc1 (список формальных параметров); Forward;{заголовок первой процедуры}
Procedure Proc2 (список параметров); {заголовок второй процедуры}
Begin{Основной блок процедуры Proc2}
  . . .
  Proc1 (список фактических параметров); {Вызов процедуры Proc1}
  . . .
End;

Procedure Proc1 (список параметров);
Begin{Основной блок процедуры Proc1}
  . . .
  Proc2 (список фактических параметров); {Вызов процедуры Proc2}
  . . .
End;

Begin
  . . . {Тело основной программы}
End.

Процедуры с ближним и дальним адресом вызова

Турбо Паскаль поддерживает две модели вызова процедур - ближнюю Near и дальнюю Far. Между этими двумя моделями существует ряд различий. Процедуры, созданные с использованием модели Near, получаются более быстродействующими, но могут быть вызваны только из модуля, в котором они описаны.

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

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

Параметры-процедуры и параметры-функции

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

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

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

Процедуры и функции должны быть объявлены с директивой Far (использование дальнего типа вызова подпрограмм) и откомпилированы в состоянии {$F+}. А также они не должны быть:

  • стандартной подпрограммой;

  • вложенной подпрограммой;

  • Inline процедурой или функцией (подпрограммы, записанные в машинных кодах);

  • Interrupt процедурой или функцией (подпрограммы обработки прерываний).

При использовании параметров-процедур или параметров-функций в списке перед соответствующими формальными параметрами указывается зарезервированное слово Procedure или Function.

Например,

Procedure Example(k,l : integer; Var M : real; Procedure Prob; Function Step : real);

В списке формальных параметров процедуры Example:

k, l - параметры-значения;
M - параметр-переменная;
Prob - параметр-процедура;
Step - параметр-функция.

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

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

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

Program ProcType;
Type
  Func=Function(x, y : integer) : integer;{Описание процедурного типа}
{$F+} {Директива компилятору на использование дальнего типа вызова п/программ}

Function Add(x, y :integer) : integer;
Begin
  Add := x+y;
End;

Function Mult(x, y :integer) : integer;
Begin
  Mult := x*y;
End;

Function Funny(x, y :integer) : integer;
Begin
  Funny := (x+y)*(x-y);
End;

{$F-}
Procedure Tab(w,h : integer; Operation : Func);
Var
  x, y : integer;
Begin
  for y := 1 to w do
    begin
      for x := 1 to h do
        write(Operation(x,y):5);
      writeln;
    end;
End;

Begin
  Tab(10,10,Add);
  writeln;
  Tab(10,10,Mult);
  writeln;
  Tab(10,10,Funny);
End.

В данной программе процедура Tab представляет собой общее действие, выполняемое над параметрами-функциями Add, Mult, Funny. После запуска программы сначала вызывается процедура Tab для фактических параметров 10, 10 и Add, в результате чего формальным параметрам w и h присваиваются значения  10 и 10, а формальному параметру Operation процедурного типа Func присваивается имя фактической функции Add. В результате этого на экран будет выведена таблица сложения от 1 до 10. Затем процедура Tab вызывается к исполнению для фактических параметров 10, 10 и параметра-функции Mult, в результате этого на экран будет выведена таблица умножения от 1 до 10. Аналогично вызов процедуры Tab с параметрами 10, 10 и Funny даст в результате на экране таблицу произведения суммы на разность чисел от 1 до 10.

Задание. Введите текст этой программы, запишите полученный файл на диск и откомпилируйте его. После того как компиляция выполнится успешно, исполните программу в пошаговом режиме с заходом в процедуры и пронаблюдайте за вызовом функций вычисления суммы, произведения двух чисел или произведения их суммы и разности. Обратите внимание на то, как при исполнении оператора write(Operation(x,y):5) в зависимости от фактического значения параметра-функции Operation процедурного типа Func осуществляется вызов различных функций Add, Mult или Funny. Попробуйте удалить строку с директивой компилятору об использовании дальнего типа вызова или возьмите в фигурные скобки описание процедурного типа Func и пронаблюдайте за результатом. В случае появления ошибок нажатием клавиши F1 получите справку о причинах ошибки и рекомендацию по ее исправлению.

Модули, созданные программистом

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

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

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

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

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

Заголовок модуля

Unit <Имя модуля>;
{$N+} <Глобальные директивы компилятора>;

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

Interface
  Uses<список подключаемых модулей>;
  Const<описания констант, определенных в данном модуле и доступных для других модулей>;
  Type<описания типов, определенных в данном модуле и доступных для других модулей>;
  Var<описания переменных, определенных в данном модуле и доступных для других модулей>;
  Procedure<Заголовки процедур, определенных в данном модуле и доступных для других модулей>;
  Function<Заголовки функций, определенных в данном модуле и доступных для других модулей>;

Реализационная часть

Implementatoin
  Uses<список подключаемых модулей>;
  Const<описания констант, определенных в данном модуле и недоступных для других модулей>;
  Type<описания типов, определенных в данном модуле и недоступных для других модулей>;
  Var<описания переменных, определенных в данном модуле и недоступных для других модулей>;
  Procedure<реализация процедур, определенных в данном модуле и доступных для других модулей>;
  Function<реализация функций, определенных в данном модуле и доступных для других модулей>;
  Procedure<реализация процедур, определенных в данном модуле и недоступных для других модулей>;
  Function<реализация функций, определенных в данном модуле и недоступных для других модулей>;
 

Инициализационная часть

Begin <Слово Begin необходимо, если имеются операторы в данной части программы>
  <часть модуля, исполняемая при его подключении (необязательна)>
End.

Заголовок модуля

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

При выборе имени модуля необходимо учитывать одну особенность: имя модуля должно совпадать с именем файла, в котором он хранится, а значит, имя модуля не может состоять более чем из 8 символов. А также не забывайте, что имя не должно совпадать с именами объектов (процедур, функций и др.).

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

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

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

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

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

Примечание. Интерфейсная часть может быть пуста.

Реализационная часть

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

Реализационная часть также может быть пустой.

Инициализационная часть

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