ПРОЦЕДУРЫ И ФУНКЦИИ


Процедуры и функции представляют собой относительно самостоятельные фрагменты программы, оформленные особым образом и снабженные именем. Упоминание этого имени в тексте программы называется вызовом процедуры (функции). Отличие функции от процедуры заключается в том, что результатом исполнения операторов, образующих тело функции, всегда является некоторое значение, поэтому обращение к функции можно использовать в соответствующих выражениях наряду с переменными и константами. Условимся далее называть процедуру или функцию общим именем “подпрограмма”, если только для излагаемого материала указанное отличие не имеет значения.
ЛОКАЛИЗАЦИЯ ИМЕН
Напомню, что вызов подпрограммы осуществляется простым упоминанием имени процедуры в операторе вызова процедуры или имени функции в выражении. В Delphi 32 функцию можно вызывать точно так же, как и процедуру, т. е. без использования возвращаемого ею значения. Как уже говорилось, любое имя в программе должно быть обязательно описано перед тем, как оно появится среди исполняемых операторов. Не делается исключения и в отношении подпрограмм: каждую свою процедуру и функцию программисту необходимо описать в разделе описаний.
Описать подпрограмму - значит указать ее заголовок и тело. В заголовке объявляются имя подпрограммы и формальные параметры, если они есть. Для функции, кроме того, указывается тип возвращаемого ею результата. За заголовком следует тело подпрограммы, которое подобно программе состоит из раздела описаний и раздела исполняемых операторов. В разделе описаний подпрограммы могут встретиться описания подпрограмм низшего уровня, а в них - описания других подпрограмм и т. д.
Вот какую иерархию описаний получим, например, для программы, структура которой изображена на (для простоты считается, что все подпрограммы представляют собой процедуры без параметров):

Procedure A; Procedure Al;
begin
end {A1};
Procedure A2;
begin
end {A2};
begin {A}
end {A};
Procedure B;
Procedure Bl;
begin
end {Bl};
, Procedure B2;
Procedure B21;
И Т. Д.
Подпрограмма любого уровня имеет обычно множество имен констант, переменных, типов и вложенных в нее подпрограмм низшего уровня. Считается, что все имена, описанные внутри подпрограммы, локализуются в ней, т. е. они как бы “невидимы” снаружи подпрограммы. Таким образом, со стороны операторов; использующих обращение к подпрограмме, она трактуется как “черный ящик”, в котором реализуется тот или иной алгоритм. Все детали этой реализации скрыты от глаз пользователя подпрограммы и потому недоступны ему. Например, в рассмотренном выше примере из основной программы можно обратиться к процедурам а и в, но нельзя вызвать ни одну из вложенных в них процедур a1,
А2, В1
И Т. Д.
Сказанное относится не только к именам самих подпрограмм, но и вообще к любым объявленным в них именам - типам, константам, переменным и меткам. Все имена в пределах подпрограммы, в которой они объявлены, должны быть уникальными и не могут совпадать с именем самой подпрограммы.
При входе в подпрограмму низшего уровня становятся доступными не только объявленные в ней имена, но и сохраняется доступ ко всем именам верхнего уровня. Образно говоря, любая подпрограмма как бы окружена полупрозрачными стенками: снаружи подпрограммы мы не видим ее внутренности, но, попав в подпрограмму, можем наблюдать все, что делается снаружи. Так, например, из подпрограммы В21 мы можем вызвать подпрограмму а, использовать имена, объявленные в основной программе, в подпрограммах в и в2, и даже обратиться к ним. Любая подпрограмма может, наконец, вызвать саму себя - такой способ вызова называется рекурсией.
Пусть имеем такое описание:
var V1 : ... ;
Procedure A;
var V2 : ...;
end {A};
Procedure В;
var V3 : . . . ;
Procedure B1;
var V4 : . . . ;
Procedure В 11;
var V5;
Из процедуры B11 доступны все пять переменных v1,...,v5, из процедуры в1 доступны переменные v1,...,v4, из центральной программы-только v1.
При взаимодействии подпрограмм одного уровня иерархии вступает в силу основное правило Object Pascal: любая подпрограмма перед ее использованием должна быть описана. Поэтому из подпрограммы в можно вызвать подпрограмму а, но из а вызвать в невозможно (точнее, такая возможность появляется только с использованием опережающего описания, см. п. 8.5.) Продолжая образное сравнение, подпрограмму можно уподобить ящику с непрозрачными стенками и дном и полупрозрачной крышей: из подпрограммы можно смотреть только “вверх” и нельзя “вниз”, т. е. подпрограмме доступны только те объекты верхнего уровня, которые описаны до описания данной подпрограммы. Эти объекты называются глобальными по отношению к подпрограмме.
В Object Pascal допускается произвольная последовательность описания констант, переменных, типов, меток и подпрограмм. Например, раздел var описания переменных может появляться в пределах раздела описаний одной и той же подпрограммы много раз и перемежаться с объявлениями других объектов и подпрограмм. Для Object Pascal совершенно безразличен порядок следования и количество разделов var, type, const и label, но при определении области действия этих описаний следует помнить, что имена, описанные ниже по тексту программы, недоступны из ранее описанных подпрограмм, например:
var V1 : ; . . ;
Procedure S;
var V2 : . . . ;
end {S};
var V3 : . . . ;
Из процедуры s можно обратиться к переменным v1 и v2, но нельзя использовать V3, так как описание этой переменной следует в программе за описанием процедуры s.
Локализованные в подпрограмме имена могут совпадать с ранее объявленными глобальными именами. В этом случае считается, что локальное имя “закрывает” глобальное и делает его недоступным, например:
var
i : Integer;
Procedure P;
var
i : Integer;
begin
IbOutput.Caption := IntToStr(i);
end {P};
begin
i := 1;
P
end;
Что выведет эта программа на экран? Все что угодно: значение внутренней переменной i при входе в процедуру p не определено, хотя одноименная глобальная переменная имеет значение 1. Локальная переменная “закроет” глобальную, и на экран будет выведено произвольное значение, содержащееся в неинициированной внутренней переменной.
Если убрать описание
var
i : integer;
из процедуры p, то на экран будет выведено значение глобальной переменной i,t. е. 1.
Таким образом, одноименные глобальные и локальные переменные - это разные переменные. Любое обращение к таким переменным в теле подпрограммы трактуется как обращение к локальным переменным, т. е. глобальные переменные в этом случае попросту недоступны.
ОПИСАНИЕ ПОДПРОГРАММЫ
Описание подпрограммы состоит из заголовка и тела подпрограммы.
Заголовок и стандартные директивы
Заголовок процедуры имеет вид:
PROCEDURE <имя> [(<сп.ф.п.>)] ;
Заголовок функции:
FUNCTION <имя> [(<сп.ф.п.>)] : <тип>;
Здесь <имя> - имя подпрограммы (правильный идентификатор);
<сп.ф.п.> - список формальных параметров; <тип> - тип возвращаемого функцией результата.
Сразу за заголовком подпрограммы может следовать одна из стандартных директив assembler, external, far, forward, inline, interrupt, near. Эти директивы уточняют действия компилятора и распространяются на всю подпрограмму и только на нее, т. е., если за подпрограммой следует другая подпрограмма, стандартная директива, указанная за заголовком первой, не распространяется на вторую.
assembler - эта директива отменяет стандартную последовательность машинных инструкций, вырабатываемых при входе в процедуру и перед выходом из нее. Тело подпрограммы в этом случае должно реализоваться с помощью команд встроенного Ассемблера.
external - с помощью этой директивы объявляется внешняя подпрограмма.
far - компилятор должен создавать код подпрограммы, рассчитанный на дальнюю модель вызова. Директива near заставит компилятор создать код, рассчитанный на ближнюю модель памяти. Введены для совместимости с Delphi 1, которая использовала сегментную модель памяти.
forward - используется при опережающем описании (см. п. 8.6) для сообщения компилятору, что описание подпрограммы следует где-то дальше по тексту программы (но в пределах текущего прораммного модуля).
inline - указывает на то, что тело подпрограммы реализуется с помощью встроенных машинных инструкций.
interrupt - используется при создании процедур обработки прерываний.
Помимо описанных в Object Pascal можно использовать также стандартные директивы, регламентирующие способ передачи параметров через стек и использование регистров для их передачи - такие директивы используются при работе с ядром Windows. Они перечислены в приводимой ниже таблице. Графа порядок определяет порядок размещения параметров в стеке: слева направо означает размещение в стеке по порядку описания - сначала первый параметр, затем второй и т. д.; справа налево означает размещение с конца перечисления параметров - сначала последний, затем предпоследний и т. д. Графа Очистка определяет, кто будет очищать стек: подпрограмма перед передачей управления в вызывающую программу или программа после получения управления. Графа регистры содержит да, если для передачи параметров помимо стека используются также регистры центрального процессора.
Таблица 8.1. Стандартные директивы, регламентирующие способ передачи параметров через стек и использование регистров для их передачи


Директива

Порядок

Очистка

Регистры

safecall

Справа налево

Подпрограмма

Нет

Stdcall

Справа налево

Подпрограмма

Нет

Cdecl

Справа налево

Программа

Нет

Pascal

Слева направо

Подпрограмма

Нет

Register

Слева направо

Подпрограмма

Да

Примечание
Все фуйкции API ядра Wmdows;скомпилированы .в режиме stidcall, а те, что доддерживают технологию СОМ - в режиме sаfеса11.
Параметры
Список формальных параметров необязателен и может отсутствовать. Если же он есть, то в нем должны быть перечислены имена формальных параметров и их типы, например:
Procedure SB(a: Real; b: Integer; с: Char);
Как видно из примера, параметры в списке отделяются друг от друга точками с запятой. Несколько следующих подряд однотипных параметров можно объединять в подсписки, например, вместо
Function F(a: Real; b: Real): Real;
можно написать проще:
Function F(a,b: Real): Real;
Операторы тела подпрограммы рассматривают список формальных параметров как своеобразное расширение раздела описаний:
все переменные из этого списка могут использоваться в любых выражениях внутри подпрограммы. Таким способом осуществляется настройка алгоритма подпрограммы на конкретную задачу.
Рассмотрим такой полезный пример. В Object Pascal не предусмотрена операция возведения вещественного числа в произвольную степень[ Начиная с версии 2 с Delphi поставляется модуль Match, в котором есть соответствующая функция. ]. Тем не менее эту задачу можно решить с использованием стандартных математических функций Ехр и Ln по следующему алгоритму:
X Y = e (Y*Ln(X))
Создадим функцию с именем power и двумя вещественными параметрами а и в, которая будет возвращать результат возведения а в степень в. Обработчик события bbRunСlick нашей учебной формы fmExampie читает из компонента edInput текст и пытается выделить из него два числа, разделенных хотя бы одним пробелом. Если это удалось сделать, он обращается к функции power дважды: сначала возводит первое число х в степень второго числа y, затем х возводится в степень -y.
procedure TfmExample.bbRunClick(Sender: TObject);
Function Power(A, B: Real): Real;
{Функция возводит число А в степень В. Поскольку логарифм отрицательного числа не существует, реализуется проверка значения А: отрицательное значение заменяется на положительное, для нулевого числа результат равен нулю. Кроме того, любое число в нулевой степени дает единицу.} begin
if А > 0 then
Result := Ехр(В * Ln(A)) else if A < 0 then
Result := Ехр(В * Ln(Abs(A))) else if В = 0 then
Result := 1 else
Result := 0;
end; // Power var
S: String;
X, Y: Real; begin
{Читаем строку из edinput и выделяем из нее два вещественных числа, разделенных хотя бы одним пробелом.} S := edinput.Text;
if (S = '') or (pos(' ' ,S) = 0) then
Exit; // Лет текста или в нем нет
// пробела - прекращаем дальнейшую работу try
// Выделяем первое число:
X := StrToFloat(copy(S, I, pos(' ', S) - 1));
// Если успешно, удаляем символы до пробела // и выделяем второе число:
Delete (S, 1, pos (' ', S) ) ;
Y := StrToFloat(Trim(S)) ;
except
Exit; // Завершаемработуприошибкепреобразованияend;
mmOutput.Lines.Add(FloatToStr(Power(X, Y) ) ) ;
mmOutput.Lines.Add(FloatToStr(Power(X, -Y) ) ) ;
end;
Для вызова функции Power мы просто указали ее в качестве параметра при обращении к стандартной функции преобразования вещественного числа в строку FloatToStr. Параметры х и y в момент обращения к функции power - это фактические параметры. Они подставляются вместо формальных параметров а и в в заголовке функции, и затем над ними осуществляются нужные действия. Полученный результат присваивается специальной переменной с именем Re-suit, которая в теле любой функции интерпретируется как то значение, которое вернет функция после окончания своей работы. В программе функция power вызывается дважды - сначала с параметрами х и y, а затем х и -y, поэтому будут получены два разных результата.
Механизм замены формальных параметров на фактические позволяет нужным образом настроить алгоритм, реализованный в подпрограмме. Object Pascal следит за тем, чтобы количество и типы формальных параметров строго соответствовали количеству и типам фактических параметров в момент обращения к подпрограмме. Смысл используемых фактических параметров зависит от того, в каком порядке они перечислены при вызове подпрограммы. В нашем примере первый по порядку фактический параметр будет возводиться в степень, задаваемую вторым параметром, а не наоборот. Программист должен сам следить за правильным порядком перечисления фактических параметров при обращении к подпрограмме.
Любой из формальных параметров подпрограммы может быть либо параметром-значением, либо параметром-переменной, либо, наконец, параметром-константой.
В предыдущем примере параметры а и в определены как параметры-значения. Если параметры определяются как параметры-переменные, перед ними необходимо ставить зарезервированное слово var, а если это параметры-константы - слово const, например:
Procedure MyProcedure(var A: Real; В: Real; const C: String);
Здесь а - параметр-переменная, в - параметр-значение, а с - параметр-константа .
Определение формального параметра тем или иным способом существенно в основном только для вызывающей программы: если формальный параметр объявлен как параметр-переменная, то при вызове подпрограммы ему должен соответствовать фактический параметр в виде переменной нужного типа; если формальный параметр объявлен как параметр-значение или параметр-константа, то при вызове ему может соответствовать произвольное выражение. Контроль за неукоснительным соблюдением этого правила осуществляется компилятором Object Pascal. Если бы для предыдущего примера был использован такой заголовок функции:
Function Power (A: Real; var В : Real): Real;
то при втором обращении к функции компилятор указал бы на несоответствие типа фактических и формальных параметров (параметр обращения -Y есть выражение, в то время как соответствующий ему формальный параметр B описан как параметр-переменная).
Для того чтобы понять, в каких случаях использовать тот или иной тип параметров, рассмотрим, как осуществляется замена формальных параметров на фактические в момент обращения к подпрограмме.
Если параметр определен как параметр-значение, то перед вызовом подпрограммы это значение вычисляется, полученный результат копируется во временную память (стек) и передается подпрограмме. Важно учесть, что даже если в качестве фактического параметра указано простейшее выражение в виде переменной или константы, все равно подпрограмме будет передана лишь копия переменной (константы). Любые возможные изменения в подпрограмме параметра-значения никак не воспринимаются вызывающей программой, так как в этом случае изменяется копия фактического параметра.
Если параметр определен как параметр-переменная, то при вызове подпрограммы передается сама переменная, а не ее копия (фактически в этом случае подпрограмме передается адрес переменной). Изменение параметра-переменной приводит к изменению фактического параметра в вызывающей программе.
В случае параметра-константы в подпрограмму также передается адрес области памяти, в которой располагается переменная или вычисленное значение. Однако компилятор блокирует любые присваивания параметру-константе нового значения в теле подпрограммы.
Итак, параметры-переменные используются как средство связи алгоритма, реализованного в подпрограмме, с внешним миром: с помощью этих параметров подпрограмма может передавать результаты своей работы вызывающей программе. Разумеется, в распоряжении программиста всегда есть и другой способ передачи результатов - через глобальные переменные. Однако злоупотребление глобальными связями делает программу, как правило, запутанной, трудной в понимании и сложной в отладке. В соответствии с требованиями хорошего стиля программирования рекомендуется там, где это возможно, использовать передачу результатов через фактические параметры-переменные.
С другой стороны, описание всех формальных параметров как параметров-переменных нежелательно по двум причинам. Во-первых, это исключает возможность вызова подпрограммы с фактическими параметрами в виде выражений, что делает программу менее компактной. Во-вторых, и главных, в подпрограмме возможно случайное использование формального параметра, например, для временного хранения промежуточного результата, т. е. всегда существует опасность непреднамеренно испортить фактическую переменную. Вот почему параметрами-переменными следует объявлять только те, через которые подпрограмма в действительности передает результаты вызывающей программе. Чем меньше параметров объявлено параметрами-переменными и чем меньше в подпрограмме используется глобальных переменных, тем меньше опасность получения не предусмотренных программистом побочных эффектов, связанных с вызовом подпрограммы, тем проще программа в понимании и отладке. По той же причине не рекомендуется использовать параметры-переменные в заголовке функции: если результатом работы функции не может быть единственное значение, то логичнее использовать процедуру или нужным образом декомпозировать алгоритм на несколько подпрограмм. -
Существует еще одно обстоятельство, которое следует учитывать при выборе вида формальных параметров. Как уже говорилось, при объявлении параметра-значения осуществляется копирование фактического параметра во временную память. Если этим параметром будет массив большой размерности, то существенные затраты времени и памяти на копирование при многократных обращениях к подпрограмме можно минимизировать, объявив этот параметр параметром-константой. Параметр-константа не копируется во временную область памяти, что сокращает затраты времени на вызов подпрограммы, однако любые его изменения в теле подпрограммы невозможны - за этим строго следит компилятор.
Еще одно свойство Object Pascal - возможность использования нетипизированных параметров. Параметр считается нетипизированным, если тип формального параметра-переменной в заголовке подпрограммы не указан, при этом соответствующий ему фактический параметр может быть переменной любого типа. Заметим, что нетипизированными могут быть только параметры-переменные:
Procedure MyProc(var aParametr);
Нетипизированные параметры обычно используются в случае, когда тип данных несущественен. Такие ситуации чаще всего возникают при разного рода копированиях одной области памяти в другую, например, С помощью процедур BlockRead, BlockWrite, Move-Memory И Т. П.
Умалчиваемые параметры
В Delphi 4, 5 и 6 можно использовать так называемые умалчиваемые параметры, т. е. параметры, которые могут опускаться при обращении к подпрограмме. Умалчиваемые параметры замыкают список формальных параметров и имеют вид
<имя>:<тип> = <значение>
Например,
Procedure P(a: array of Integer; S: String = '');
В этом случае два следующих обращения идентичны:
Р([1,2,3], ' ');
Р([1,2,3]);
Если в подпрограмме используются два и более умалчиваемых параметра, то в случае переопределения одного из них при обращении к подпрограмме следует указывать все параметры вплоть до последнего переопределяемого (т. е. нельзя заменять непереопределяемые умалчиваемые параметры запятыми). Например:
Procedure P(a: array of Integer; S: String = '';
В: Integer = 0) ;
Допустимые обращения:
Р([1,2,3]);
Р([1,2,3], 'Строка');
Р(1,2,3],",1)
ПАРАМЕТРЫ-МАССИВЫ И ПАРАМЕТРЫ-СТРОКИ
Может сложиться впечатление, что объявление переменных в списке формальных параметров подпрограммы ничем не отличается от объявления их в разделе описания переменных. Действительно, в обоих случаях много общего, но есть одно существенное различие:
типом любого параметра в списке формальных параметров может быть только стандартный или ранее объявленный тип. Поэтому нельзя, например, объявить следующую процедуру:
Procedure S (a: array [1..10] of real);
так как в списке формальных параметров фактически объявляется тип-диапазон, указывающий границы индексов массива.
Если мы хотим передать какой-то элемент массива, то проблем, как правило, не возникает, но если в подпрограмму передается весь массив, то следует первоначально описать его тип. Например:
type
аТуре = array [1..10] of Real;
Procedure S(var a: аТуре);
Поскольку короткая строка является фактически своеобразным массивом, ее передача в подпрограмму осуществляется аналогичным образом:
type
InputType = String [15];
OutputType = String [30];
Function St(S: InputType): OutputType;
Требование описать любой тип-массив или тип-строку перед объявлением подпрограммы, на первый взгляд, кажется несущественным. Действительно, в рамках простейших вычислительных задач обычно заранее известна структура всех используемых в программе данных, поэтому статическое описание массивов не вызывает проблем. Однако разработка программных средств универсального назначения связана со значительными трудностями.
Открытые массивы
Object Pascal поддерживает так называемые открытые массивы, легко решающие проблему передачи подпрограмме одномерных массивов переменной длины.
Открытый массив представляет собой формальный параметр подпрограммы, описывающий базовый тип элементов массива, но не определяющий его размерности и границы:
Procedure MyProc(OpenArray: array of Integer);
Внутри подпрограммы такой параметр трактуется как одномерный массив с нулевой нижней границей. Верхняя граница открытого массива возвращается стандартной функцией High. Используя 0 как минимальный индекс и значение, возвращаемое функцией High, как максимальный индекс, подпрограмма может обрабатывать одномерные массивы произвольной длины.
Procedure TfmExample.bbRunClick(Sender: TObject) ;
{Иллюстрация использования открытых массивов: программа выводит в компонент mmOutput содержимое двух одномерных массивов разной длины с помощью одной процедуры ArrayPrint) Procedure ArrayPrint(aArray: array of Integer);
var
k: Integer;
S: String;
begin
S:=' ';
for k := 0 to High(aArray) do S := S + IntToStr(aArray[k]);
mmOutput.Lines.Add(S) ;
end;
const
A: array [-1..2] of Integer = (0,1,2,3);
B: array [5..7] of Integer = (4,5,6);
begin
ArrayPrint(A);
ArrayPrint (B);
end;
Как видно из этого примера, фактические границы массивов а и в, передаваемых в качестве параметров вызова процедуре ArrayPrint, не имеют значения. Однако размерность открытых массивов (количество индексов) всегда равна 1 - за этим следит компилятор. Если бы, например, мы добавили в программу двумерный массив с
var
С: array,[1..3,1..5] of Integer;
то обращение
ArrayPrint(С)
вызвало бы сообщение об ошибке.
Конструктор массива
При обращении к подпрограмме на месте формального параметра в виде открытого массива можно указывать так называемый конструктор массива. Конструктор массива представляет собой список разделенных запятыми значений элементов массива, обрамленный квадратными скобками. Например, в предыдущем примере вместо
const
A: array [-1..2] of Integer = (0,1,2,3);
В: array [5..7] of Integer = (4,5,6);
begin
ArrayPrint(A);
ArrayPrint(B);
end;
мы могли бы написать так:
begin
ArrayPrint ( [0,1,2,3]);
ArrayPrint([4,5,6]);
end;
Вариантные массивы-параметры
В Delphi 32 при передаче подпрограмме массивов переменной длины и размерности удобно использовать вариантные массивы (см. п. 7.4.3). В следующем примере с помощью функции GetAr-rayAverage определяется среднее арифметическое значение всех элементов вариантного массива произвольной длины и размерности не выше 5:
function GetArrayAverage (const V: Variant): Double;
{Возвращает среднее арифметическое значение массива произвольной длины и размерности или очень маленькую отрицательную величину, если V - не вариант или если его размерность больше 5} var
i,j,k,l,m: Integer;
Sum: Double;
NItem: Integer;
begin
Result := -1E-309;
if ((VarType(V) and VarArray) <> VarArray) or
(VarArrayDimCount(V) > 5) then Exit;
Sum := 0;
NItem := 0;
// Подсчитываем количество элементов массива
for k := 1 to VarArrayDimCount(V) do
NItem := NItem+VarArrayH'ighBound(V, k)-VarArrayLowBound(V,k) ;
// Подсчитываем сумму элементов case VarArrayDimCount(V) of
1: for i "VarArrayLowBound(V,1) to VarArrayHighBound(V,1) do
Sum := Sum+V[i] ;
2: for i =VarArrayLowBound(V,1) to VarArrayHighBound(V,1) do
for j :=VarArrayLowBound(V,2) to VarArrayHighBound(V,2) do
Sum := Sum+V[i,j] ;
3: for i: =VarArrayLowBound(V,1) to VarArrayHighBound(V,1) do
for j: =VarArrayLowBound(V,2) to VarArrayHighBound(V,2) do
for k: =VarArrayLowBound(V,3) to VarArrayHighBound(V,3) do
Sum := Sum+V[i,j,k] ;
4: for i: =VarArrayLowBound(V,1) to VarArrayHighBound(V,1) do
for j: =VarArrayLowBound(V,2) to VarArrayHighBound(V,2) do
for k :=VarArrayLowBound(V,3) to VarArrayHighBound(V,3) do
for l: =VarArrayLowBound(V,4) to VarArrayHighBound(V,4) do
Sum := Sum+V[i,j,k,1];
5: for i:=VarArrayLowBound(V,1) to VarArrayHighBound(V,1) do
for j :=VarArrayLowBound(V,2) to VarArrayHighBound(V,2) do
for k: =VarArrayLowBound(V,3) to VarArrayHighBound(V,3) do
for 1 :=VarArrayLowBound(V,4) to VarArrayHighBound(V,4) do
for m:= VarArrayLowBound(V,5) to VarArrayHighBound(V,5) do
Sum := Sum+V[i,j,k,1,m];
end;
Result := Sum/NItem
end;
В подобного рода подпрограммах ограничение на размерность вариантного массива определяется, как правило, количеством вариантов в предложении case.
ПРОЦЕДУРНЫЕ ТИПЫ
Основное назначение процедурных типов - дать программисту гибкие средства передачи функций и процедур в качестве фактических параметров обращения к другим процедурам и функциям.
Для объявления процедурного типа используется заголовок процедуры (функции), в котором опускается ее имя, например:
type
Proc1 = Procedure (a, b, с: Real; var d: Real); Proc2 = Procedure (var a, b);
РгосЗ = Procedure;
Func1 = Function: String;
Func2 = Function (var s: String): Real;
Как видно из приведенных примеров, существует два процедурных типа: тип-процедура и тип-функция.
В следующий программе иллюстрируется механизм передачи процедур в качестве фактических параметров вызова. Программа выводит на экран таблицу двух функций: sin1 (х) = (sin(x) + 1) * Ехр(-х) и cosi(x) = (Cos(x) + 1) * Ехр(-х) . Вычисление и печать значений этих функций реализуются в процедуре printFunc, которой в качестве параметров передается количество np вычислений функции в диапазоне х от 0 до 2*3.141592 и имя нужной функции.
Function Sinl(X: Real): Real;
begin
Result := (Sin(X) + 1) * Exp(-X) end; // Sin 1
Function Cosl(X: Real): Real;
begin
Result := (Cos(X) + 1) * Exp(-X) end; // Cosi
procedure TfmExample.bbRunClick(Sender: TObject);
type
Func = function (X: Real): Real; // ПроцедурныйтипProcedure PrintFunc(NP: Integer; F; Func) ;
var
k: Integer;
X: Real;
begin
for k := 0 to NP do
begin
X:=k*2*pi/ NP;
mmOutput.Lines.Add(FloatToStrF(X, ffExponent, 10, 2) + #9#9 + FloatToStrF(F(X), ffExponent, 10, 2)) ;
end;
end; // PrintFunc
begin // bbRunClick
nmiOutput.Lines.Add(#9'Функция SINI:');
PrintFunc (10, Sini);
mmOutput.Lines.Add(#9'Функция COSI:');
PrintFunc (10, Cosi);
end;
Обратите внимание: передаваемые подпрограммы не могут быть локальными, т. е. процедурами или функциями, объявленными внутри другой подпрограммы. Вот почему описание подпрогра^.' sini и cosi размещаются вне обработчика bbRunciick, но выше не." по тексту модуля. Замечу, что символ #9 - это символ табуляции. который вставляется в формируемые строки для разделения колонок с цифрами.
В программе могут быть объявлены переменные процедурных типов, например,так:
var
p1 : Proc1;
fl, f2 : Func2;
ар : array [1..N] of Proc1;
Переменным процедурных типов допускается присваивать в качестве значений имена соответствующих подпрограмм. После такого присваивания имя переменной становится синонимом имени подпрограммы.
РЕКУРСИЯ И ОПЕРЕЖАЮЩЕЕ ОПИСАНИЕ
Рекурсия - это такой способ организации вычислительного процесса, при котором подпрограмма в ходе выполнения составляющих ее операторов обращается сама к себе.
Рассмотрим классический пример - вычисление факториала. Программа получает от компонента edinput целое число n и выводит в компонент lboutput значение N!, которое вычисляется с помощью рекурсивной функции Factorial.
При выполнении правильно организованной рекурсивной подпрограммы осуществляется многократный переход от некоторого текущего уровня организации алгоритма к нижнему уровню последовательно до тех пор, пока, наконец, не будет получено тривиальное решение поставленной задачи. В нашем случае решение при n = 0 тривиально и используется для остановки рекурсии.
procedure TfmExample.bbRunClick(Sender: TObject);
Function Factorial(N: Word): Extended;
begin
if N = 0 then
Result : = 1 else
Result := N * Factorial(N-1)
end;
var
N: Integer;
begin
try
N := StrToInt(Trim(edinput.Text));
except
Exit; end;
IbOutput.Caption := FloatToStr(Factorial(N))
end;
Рекурсивная форма организации алгоритма обычно выглядит изящнее итерационной и дает более компактный текст программы, но при выполнении, как правило, медленнее и может вызвать переполнение стека (при каждом входе в подпрограмму ее локальные переменные размещаются в организованной особым образом области памяти, называемой программным стеком).
Рекурсивный вызов может быть косвенным. В этом случае подпрограмма обращается к себе опосредованно, путем вызова другой подпрограммы, в которой содержится обращение к первой, например:
Procedure A (i : Byte);
begin
В (i);
end;
Procedure В (j : Byte) ;
begin
а(j);
end;
Если строго следовать правилу, согласно которому каждый идентификатор перед употреблением должен быть описан, то такую программную конструкцию использовать нельзя. Чтобы такого рода вызовы стали возможны, вводится опережающее описание:
Procedure В (j : Byte) ; Forward;
Procedure A (i : Byte);
begin
В (i);
end;
Procedure B; begin
A(j);
end;
Как видим, опережающее описание заключается в том, что объявляется лишь заголовок процедуры в, а ее тело заменяется стандартной директивой Forward. Теперь в процедуре а можно использовать обращение к процедуре в - ведь она уже описана, точнее, известны ее формальные параметры, и компилятор может правильным образом организовать ее вызов. Обратите внимание: тело процедуры в начинается заголовком, в котором уже не указываются описанные ранее формальные параметры.

 

 
На главную | Содержание | < Назад....Вперёд >
С вопросами и предложениями можно обращаться по nicivas@bk.ru. 2013 г. Яндекс.Метрика