Материал о процедурах

[ZMEEEI]

Как видно из примера, удвоение второго формального параметра в процедуре INC2 не вызвало изменения фактической переменной В, так как этот параметр описан в заголовке процедуры как параметр-значение. Этот пример может служить еще и иллюстрацией механизма «накрывания» глобальной переменной одноименной локальной: хотя переменная В объявлена как глобальная (она описана в вызывающей программе перед описанием процедуры), в теле процедуры ее «закрыла» локальная переменная В, объявленная как параметр-значение.

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

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

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

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

[ZMEEEI]

Параметры - массивы и параметры - строки

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

Procedure S (a: array [1..10] of Real);

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

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

type

atype = array [1..10]of Real;

Procedure S (a: atype);

.......

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

type

intype = String [15] ;

outype = String [30] ;

Function St (s : intype): outype;

.......

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

подпрограммах массивы с «плавающими» границами изменения индексов. Например, если разработана программа, обрабатывающая матрицу 10х10 элементов, то для обработки матрицы 9x11 элементов необходимо переопределить тип, т.е. перекомпилировать всю программу (речь идет не о динамическом размещении массивов в куче, а о статическом описании массивов и передаче их как параметров в подпрограммы). Этот недостаток, как и отсутствие в языке средств обработки исключительных ситуаций (прерываний), унаследован из стандартного Паскаля и представляет собой объект постоянной и вполне заслуженной его критики. Разработчики Турбо Паскаля не рискнули кардинально изменить свойства базового языка, но, тем не менее, включили в него некоторые средства, позволяющие в известной степени смягчить отмеченные недостатки.Эти недостатки практически полностью устранены в языке Object Pascal, используемом в визуальной среде программирования Delphi.

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

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

[ZMEEEI]

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

Procedure MyProc(OpenArray: array of Integer);

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

{Иллюстрация использования открытых массивов: программа выводит на экран содержимое двух одномерных массивов разной длины с помощью одной процедуры ArrayPrint}

Procedure ArrayPrint(aArray: array of Integer);

var

k: Integer;

begin

for k := 0 to High(aArray) do

Write(aArray[k]:8);

WriteLn

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(С)

вызывало бы сообщение об ошибке

Error26: Type mismatch.

(Ошибка 26: Несоответствие типов.)

[ZMEEEI]

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

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

Для объявления процедурного типа используется заголовок процедуры (функции), в котором опускается ее имя, например:

type

Prod = Procedure (a, b, c: Real; var d: Real);

Proc2 = Procedure (var a, b) ;

РгосЗ = Procedure;

Func1 = Function: String;

Func2 = Function (var s: String): Real;

Как видно из приведенных примеров, существует два процедурных типа: тип-процедура и тип-функция.

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

sin1(х) = (sin(x) + 1) * ехр(-х)

cos1(x) = (cos(x) + 1) * exp(-x).

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

Пример 8.3.

Uses CRT;

type

Func = Function (x: Real) : Real;

{----------------}

Procedure PrintFunc (XPos: Byte; F:Func) ;

{Осуществляет печать функции F . (XPos - горизонтальная позиция начала вывода) }

const

np = 20; {Количество вычислений функций}

var

х : Real; i : Integer;

begin {PrintFunc}

for i := 1 to np do

begin

x := i * (2 * pi / np) ;

GotoXY (XPos, WhereY) ;

WriteLn (x:5:3, F(x):18:5)

end

end; {PrintFunc}

{-----------------}

Function Sin1fx: Real): Real; far;

begin

sinl := (sin(x) + 1) * exp(-x)

end;

Function Cos1(x: Real): Real; far;

begin

cosl := (cos(x) + 1) * exp(-x)

end;

{---------------}

begin {основная программа}

ClrScr; {Очищаем экран}

PrintFunc (1, sin1); GotoXY (1,1); {Переводим курсор в левый верхний угол}

PrintFunc (40, cos1)

end.

[ZMEEEI]

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

Стандартные процедуры (функции) Турбо Паскаля не могут передаваться рассмотренным способом.

В программе могут быть объявлены переменные процедурных типов, например, так:

var

p1 : Proc1;

f1, f2 : Func2;

р : array [1..N] of Proc1;

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

type

Proc = Procedure (n: word; var a: Byte);

var

ProcVar: Proc; x, у : Byte;

Procedure Procl(x: word; var y: Byte); far;

begin

if x > 255 then

у := x mod 255

else

у := Byte(x)

end;

begin {Главная программа}

ProcVar := Proc1;

for x := 150 to' 180 do

begin

ProcVar (x + 100, y);

Write (y:8)

end

end.

Разумеется, такого рода присваивания допустимы и для параметров-функций, например:

type

FuncType = Function (i : Integer) : Integer;

var

VarFunc : FuncType;

i : Integer;

Function MyFunc (count : Integer) : Integer; far;

begin

.......

end; {MyFunc}

begin {Основная программа}

.......

i := MyFunc(1); {Обычное использование результата функции}

.......

VarFunc := MyFunc;

{Присваивание переменной процедурного типа имени функции MyFunc}

.......

end.

Отметим, что присваивание

VarFunc := MyFunc(1);

будет недопустимым, так как слева и справа от знака присваивания используются несовместимые типы: слева - процедурный тип, а справа - INTEGER; имя функции со списком фактических параметров MyFunc(1) трактуется Турбо Паскалем как обращение к значению функции, в то время как имя функции без списка параметров рассматривается как имя функции.

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

[ZMEEEI]

Нетипизированные параметры - переменные

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

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

Нетипизированные параметры в сочетании с механизмом совмещения данных в памяти (см. п.4.4) можно использовать для передачи подпрограмме одномерных массивов переменной длины (этот способ можно использовать в Турбо Паскале версии 6.0 и более ранней, в которых нет открытых массивов).

В примере 8.4 функция NORMA вычисляет норму вектора, длина которого меняется случайным образом. Стандартная константа MAXINT содержит максимальное значение целого типа INTEGER и равна 32767.

Следует учесть, что при обращении к функции NORMA массив X помещается в стек и передается по ссылке, поэтому описание локальной переменной А в виде одномерного массива максимально возможной длины в 65532 байта (встроенная константа MAXINT определяет максимально возможное значение типа INTEGER и равна 32767), совпадающего с X, на самом деле не приведет к выделению дополнительного объема памяти под размещение этой переменной. Иными словами, переменная А - фиктивная переменная, размер которой никак не влияет на объем используемой памяти. С таким же успехом можно было бы объявить ее в виде массива из одного элемента, правда, в этом случае необходимо позаботиться об отключении контроля выхода индекса за границы диапазона.

Пример 8.4

const

NN = 100; {Максимальная длина вектора}

var

а : array [1..NN] of Real;

i, j, N : Integer;

{----------------}

Function Norma (var x; N: Integer) : Real;

var

a : array [1..2*MaxInt div SizeOf (Real) ] of Real absolute x;

i : Integer;

s : Real;

begin {Norma}

s := 0;

for i := 1 to N do

s := s + sqr (a [i] ) ;

Norma := sqrt(s)

end {Norma} ;

{-------------------}

begin {main}

for i := 1 to 10 do

begin

N := Random (NN) + 1; {Текущая длина вектора}

for j := 1 to N do

a [ j ] : = Random ;

WriteLn ('N = ', N:2,норма=',Norma(a, N):10:7)

end

end {main} .

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

[ZMEEEI]

Рекурсия и опережающее описание

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

Рассмотрим классический пример - вычисление факториала (пример 18). Программа вводит с клавиатуры целое число N и выводит на экран значение N!, которое вычисляется с помощью рекурсивной функции РАС. Для выхода из программы необходимо либо ввести достаточно большое целое число, чтобы вызвать переполнение при умножении чисел с плавающей запятой, либо нажать Ctrl-Z и Enter.

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

Пример 8.5

Program Factorial;

{$S+} {Включаем контроль переполнения стека}

var

n: Integer;

Function Facfn: Integer): Real;

{Рекурсивная функция, вычисляющая n ! }

begin {Fac}

if n < 0 then

WriteLn ('Ошибка в задании N')

else

if n = 0 then

Fac := 1

else Fac := n * Fac(n-l)

end {Fac} ;

{---------------}

begin {main} repeat



ReadLn (n) ;

WriteLn ('n!= ',Fac(n))

until EOF

end {main} .

Рекурсивная форма организации алгоритма обычно выглядит изящнее итерационной и дает более компактный текст программы, но при выполнении, как правило, медленнее и может вызвать переполнение стека (при каждом входе в подпрограмму ее локальные переменные размещаются в особым образом организованной области памяти, называемой программным стеком). Переполнение стека особенно ощутимо сказывается при работе с сопроцессором: если программа использует арифметический сопроцессор, результат любой вещественной функции возвращается через аппаратный стек сопроцессора, рассчитанный всего на 8 уровней. Если, например, попытаться заменить тип REAL функции FAC (см. пример 8.5) на EXTENDED, программа перестанет работать уже при N = 8. Чтобы избежать переполнения стека сопроцессора, следует размещать промежуточные результаты во вспомогательной переменной. Вот правильный вариант примера 8.5 для работы с типом EXTENDED:

[ZMEEEI]

Program Factorial;

{$S+,N+,E+} {Включаем контроль Стека и работу сопроцессора}

var

n: Integer;

Function Fac(n: Integer): extended;

var

F: extended; {Буферная переменная для разгрузки стека сопроцессора}

{Рекурсивная функция, вычисляющая п! }

begin {Рас}

if n < 0 then

WriteLn ('Ошибка в задании N') else

if n = 0 then

Fac := 1 else begin

F := Fac(n-l) ; Fac := F * n end end {Fac} ;

{--------------}

begin {main}

repeat

ReadLn (n) ;

WriteLn ('n! = ',Fac(n))

until EOF

end {main} .

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

Procedure A (i : Byte) ;

begin

.......

В (i);

.......

end ;

Procedure В (j : Byte) ;

.......

begin

.......

A(j);

.......

end;

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

Procedure В(j : Byte); forward;

Procedure A(i : Byte);

begin

.......

В (i) ;

.......


end ;

Procedure В;

begin

.......

A(j);

.......

end;

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

[ZMEEEI]

Расширинный синтаксис вызова функций

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

{$Х+} {Включаем расширенный синтаксис}

Function My.Func (var x : Integer) : Integer;

begin

if x<0 then x:=0

else MyFunc := x+10

end; {MyFunc}

var

i : Integer;

begin {main}

i := 1;

i := 2*MyFunc(i) -100; {Стандартный вызов функции}

MyFunc ( i ) {Расширенный синтаксис вызова}

end. {main}

Расширенный синтаксис делает использование функций таким же свободным, как, например, их использование в языке Си, и придает Турбо Паскалю дополнительную гибкость. С помощью расширенного синтаксиса нельзя вызывать стандартные функции. Компиляция с учетом расширенного синтаксиса включается активным состоянием опции EXTENDED SYNTAX диалогового окна OPTIONS/COMPILER (см. прил.1) или глобальной директивой компилятора {$Х+}.