Процедуры и функции и оператор вызова процедуры (функции)
При составлении сложных программ почти всегда бывает необходимо разбивать всю задачу на несколько блоков и составлять алгоритмы для отдельных блоков задачи отдельно. Для выделенного блока формулируются требования к данным на входе и предполагаемый результат на выходе. Внутреннее устройство блока может варьироваться. Каждый блок в свою очередь может быть разбит на меньшие блоки и т.д. В результате вся сложная программа образует иерархическую структуру блоков, каждый из которых представляет собой самостоятельную, но более частную программу.
В Паскале подобная иерархическая структура формируется за счет механизма процедур и функций. Существует несколько веских причин для того, чтобы использовать механизм структурирования программы:
- текст небольшой программы, содержание отдельных элементов которой описывается просто, хорошо читается и, как следствие, в нем делается меньше ошибок;
- процедуры и функции можно отлаживать по отдельности, что позволяет производить поэтапную отладку программу и лучше локализовывать ошибки; достаточно сложные программы не могут быть отлажены другим способом;
- для того, чтобы пользоваться процедурой, достаточно знать, как она действует, а не как она устроена, поэтому можно поручить программировать разные процедуры разным программистам; только так можно коллективно разрабатывать программы;
- одна процедура, будучи написана, может использоваться в нескольких, иногда очень многих, программах; самые употребительные процедуры и функции встроены в Турбо-Паскаль и могут использоваться в любой программе;
- механизм процедур и функций позволяет создавать программы с помощью наиболее современной технологии программирования “сверху-вниз”, при которой сначала пишется текст основной программы в форме вызовов вложенных процедур, а затем алгоритмизируются эти вложенные процедуры.
На каждую процедуру можно взглянуть двояко: извне и изнутри. При взгляде “изнутри” процедура представляет собой обычную программу, для которой к началу выполнения должны быть заданы входные значения, а к концу выполнения должны быть сформированы выходные значения.
При взгляде “извне” программист должен позаботиться только о том, чтобы передать процедуре те входные значения, которые она должна обработать, и получить от нее результат ее работы. Это достигается за счет использования параметров.
Каждая процедура или функция снабжается списком так называемых формальных параметров. Часть этих параметров объявляется выходными (входными в Паскале являются все). При взгляде “изнутри” все параметры являются обычными переменными с одним отличием: их значение известно к началу действия процедуры. После окончания действия процедуры некоторые параметры или все изменяют свое значение. При этом программист должен позаботиться о том, чтобы выходные параметры принимали нужные значения. При взгляде “извне” программист, если он хочет, чтобы процедура выполнилась, должен всего лишь указать значения параметров при входе в процедуру, а при выходе из нее получить значения тех параметров, которые объявлены выходными. Значения, присваиваемые формальным параметрам процедуры при обращении к ней, называются фактическими параметрами обращения к этой процедуре (или вызова процедуры).
В языке Паскаль взгляд “изнутри” реализуется в разделе описания процедур и функций. Этот раздел помещается после всех разделов объявлений программы, но до операторной части самой программы (то есть тела программы). В этом разделе описываются все процедуры и функции, используемые в программе. В Турбо?Паскале строение текста одной процедуры или функции в точности аналогично строению всей программы: заголовок, разделы объявлений, вложенные процедуры и функции и тело процедуры (функции). Вложенными называются такие процедуры и функции, текст которых помещен внутрь текста данной процедуры или функции. Надо отметить, что в стандартном Паскале вложение процедур и функций не допускается.
Разделы объявлений и тело процедуры идентичны соответствующим разделам программы. Заголовок процедуры состоит из ключевого слова procedure, имени процедуры и списка описаний формальных параметров в круглых скобках.
Список параметров может быть пустым, тогда он опускается:
procedure <имя процедуры> [( <список описаний формальных параметров> )]
Элементы списка отделяются друг от друга точкой с запятой. Описание формального параметра включает идентификатор формального параметра и указание его типа, разделенные двоеточием. Если параметр должен быть выходным, перед именем параметра ставится ключевое слово var. Указание типа в процедурах имеет одну особенность, отличающую его от указания типа при объявлении переменной: в качестве типа может использоваться только имя стандартного или пользовательского (определенного ранее в программе в разделе типов) типа, а не сложная конструкция вроде array ... of или record ... end. Если несколько идущих подряд параметров имеют одинаковый тип, то их описания можно объединить, поместив вместо одного имени параметра список имен, разделенных запятой. В общем случае формат описания формального параметра следующий:
[var] <список имен параметров через запятую> : <имя типа>
Для того, чтобы процедура фактически выполнилась, где-нибудь в программе или в другой процедуре должен стоять оператор вызова процедуры. Оператор вызова процедуры в общем случае применяется тогда, когда необходимо выполнить некоторое стандартное действие, встроенное в систему Турбо?Паскаль или предварительно оформленное в программе в виде процедуры или функции. Формат оператора вызова процедуры следующий:
<имя процедуры или функции> ( <список фактических параметров>)
Фактические параметры в списке разделены запятыми. Каждый фактический параметр согласно положению в списке соответствует своему формальному параметру и должен быть значением того типа, который был задан при описании формального параметра. Если параметр был описан как выходной с помощью ключевого слова var, то фактический параметр в операторе вызова процедуры обязан выражаться только именем переменной программы, а не произвольным выражением. В таком случае переменная на месте выходного параметра программы к началу выполнения следующего после вызова процедуры оператора примет то значение, которое имел соответствующий формальный параметр процедуры к концу работы процедуры.
Пусть, например, в процедуре p параметр y
выходной, а действует она следующим тривиальным образом:
procedure p (x: integer; var
y: integer);
begin
x := 0;
y := 0
end;
и пусть где-то в программе встретился фрагмент
a := 1; b := 1; p(a,b);
Тогда после выполнения вызова процедуры p(a,b)
переменная a будет иметь старое значение 1, а переменная b будет иметь новое значение 0.
Функция отличается от процедуры только тем, что она дополнительно вычисляет некоторое значение, которое возвращает при вызове. В результате возможно использование функций в качестве составной части выражения (а процедуры нет). При вычислении выражения функция вызывается и возвращаемое функцией значение подставляется в выражение. Если функция вызывается через оператор вызова, то возвращаемое значение игнорируется. Помимо возвращаемого значения, функция может выдавать другие выходные данные так же, как это делает процедура (через выходные параметры).
Заголовок функции начинается ключевым словом function и востальном идентичен заголовку процедуры за одним исключением: после списка формальных параметров через двоеточие указывается тип возвращаемого значения (который должен быть простым!):
function
<имя функции>
[( <список параметров>)] : <тип значения функции>
Для того, чтобы обеспечить возврат значения, в Паскале используется следующий механизм: в число переменных автоматически (без объявления) добавляется переменная с именем и типом, совпадающим с именем и типом функции. В конце работы функции этой переменной должно быть присвоено нужное значение. Например, для функции возведения в квадрат
function sqr (x: real): real;
begin sqr := x*x
end;
после присваивания a:=sqr(3) переменная a примет значение 9.
Использование процедур и функций порождает некоторые проблемы в использовании переменных. Рассмотрим операторную часть некоторой процедуры. В ней используются переменные и параметры данной процедуры. Однако не только они. В Паскале полагается, что в операторной части процедуры можно без ограничений использовать переменные самой программы.
Более того, если процедура вложена в другую процедуру, то можно использовать переменные и параметры объемлющей процедуры, а если и та вложена - то объемлющей последнюю и т.д. Другими словами, процедуре доступны все переменные и параметры процедур, внутри которых расположен текст данной процедуры. Такие переменные называются внешними в отличие от внутренних переменных самой процедуры. Возможен случай, когда переменные разных процедур имеют одинаковое имя. Тогда при использовании имени будет подразумеваться переменная внутренней процедуры, которая как бы закрывает внешнюю переменную от использования в операторной части внутренней процедуры.
Все сказанное о процедурах относится также и к функциям. Изложенные правила называются правилами локализации имен и относятся не только к переменным. Все объявления в процедуре и функции распостраняются только на текст процедуры и функции, но зато на весь этот текст, включая все вложенные процедуры и функции. Это касается и имен процедур и функций, вложенных в данную. Во внешней процедуре (в частности, в программе) все эти имена недоступны. Например, если процедура G1 содержит процедуру G2, а та содержит процедуру G3, то можно вызвать G3 из операторной части процедуры G2, но нельзя вызвать G3 из операторной части процедуры G1.
Указанные соглашения о локализации имен определяют два способа передачи информации вызываемой процедуре: посредством параметров и посредством использования внешних переменных. При первом способе мы должны определить соответствующий формальный параметр процедуры, и при вызове процедуры передать нужное значение в качестве фактического параметра. При этом не требуется, чтобы вызываемая процедура была вложена в вызывающую. При втором способе в вызываемой процедуре непосредственно используется имя внешней переменной вызывающей процедуры, но при этом обязательно первая процедура должна быть вложена во вторую. Приведем пример.
procedure
p1;
var i,j: integer;
procedure p2 (k: integer);
var i: integer;
begin {procedure p2} ... i := 2; j := 2; k := 3; ... end; {procedure p2}
begin {procedure p1} ... i := 1; j := 1; p2 (i); ... end; {procedure p1}
В процедуре p2 доступны внутренняя переменная i, которая закрывает доступ к одноименной внешней переменной процедуры p1, внешняя переменная j и параметр k. Значение переменной i передается процедуре p2 через параметр, а j - через непосредственный доступ к внешней переменной. После возврата из процедуры p2 в процедуру p1
переменная i сохранит старое значение 1, в то время как переменная j после присваивания j:=2 в процедуре p2 будет иметь значение 2. Заметим, что если бы формальный параметр k был определен в заголовке процедуры p2 как выходной (с ключевым словом var), то после вызова p2(i) значение переменной i оказалось бы равным 3.
Оба способа передачи значений имеют свои достоинства и недостатки. При передаче значений посредством параметров производится фактическое копирование значений во внутренние переменные процедуры. При больших объемах передаваемых данных это приводит к потерям времени и памяти. Широкое использование внешних переменных усложняет текст и затрудняет его чтение. Истина лежит где-то посередине.
