Язык Паскаль позволяет использовать в программе данные типа “процедура” или типа “функция”. Такие данные можно передавать как аргументы подпрограмм, можно описывать и использовать массивы процедур и массивы функций. Тип “процедура” описывается в операторе Type следующим образом:
Type имя типа=Procedure(список параметров);
Описание процедурного типа отличается от заголовка процедуры только отсутствием имени процедуры, список параметров записывается обычным образом. Если такой оператор Type есть в программе, то все дальние процедуры, записанные ниже и имеющие столько же параметров таких же типов (имена параметров значения не имеют), автоматически становятся объектами этого типа. Процедура называется дальней, если она откомпилирована в режиме F+, этого можно добиться двумя способами: или используя соответствующую опцию компилятора :
{$F+} Procedure A(x:Real; c:Char); Begin...End; {$F-},
или записав после заголовка процедуры атрибут Far:
Procedure A(x:Real; c:Char); Far; Begin ... End;
Опция {$F+} действует до ее отмены опцией {$F-} или до конца программы, а атрибут Far - только на данную процедуру. Дальние объекты в программе имеют четырехбайтовые адреса, состоящие из сегмента и смещения, а ближние объекты имеют двухбайтовые адреса, содержащие только смещение, поскольку все они хранятся в одном сегменте данных. Если процедура находится в модуле, то она является дальней по умолчанию. Функциональный тип описывается так же, как процедурный:
Type имя типа=Function(список параметров):тип;
Данные функционального типа также обязаны иметь дальние адреса. Попробуем применить процедурные типы в реальной задаче. Вспомним алгоритм решения уравнения методом бисекции, описанный в разделе 17. Предположим, что нам требуется решить не одно уравнение, а много уравнений с различными левыми частями. Вместо того чтобы писать много практически одинаковых программ (они будут отличаться только одной функцией) или каждый раз модифицировать программу перед запуском, опишем соответствующий функциональный тип и будем передавать методу бисекции функцию как параметр. Чтобы не записывать несколько операторов вызова метода бисекции, опишем массив функций и будем обрабатывать их в цикле. Такая структура программы позволяет очень легко добавлять новые уравнения.
Const N_Func = 4; {количество уравнений - пока их четыре}
Type
T_Func = Function (x:Real):Real; {тип левой части уравнения}
T_Func_Array = Array[1..N_Func] Of T_Func; {тип массива функций}
T_Num_Array = Array[1..N_Func] Of Real; {тип числового массива}
Function f1(x:Real):Real; Far; Begin f1:=Sqr(x)*(Exp(-x)-1)+1; End;
Function f2(x:Real):Real; Far; Begin f2:=x*Sqr(Sqr(x))-Ln(2+Sqr(x)); End;
Function f3(x:Real):Real; Far; Begin f3:=Sqr(Sqr(x))*(Exp(-2*x)-1)+2; End;
Function f4(x:Real):Real; Far; Begin f4:=ArcTan(1+Sqr(x))-x*Sqr(x)/3; End;
Function Bisection(a,b:Real; f:T_Func):Real; {функция находит корень уравнения f(x)=0 на отрезке [a,b], функция f, вычисляющая левую часть уравнения, передается как параметр}
Var x,Fa,Fx : Real;
Begin
Fa:=f(a); x:=(a+b)/2;
While (x<>a)And(x<>b) Do Begin
Fx:=f(x); If Fx*Fa<0 Then b:=x Else a:=x; x:=(a+b)/2;
End;
Bisection:=x;
End;
Const
f : T_Func_Array = (f1,f2,f3,f4); {массив функций}
a : T_Num_Array =(0,0,0,0); { массив левых концов отрезка [a,b]}
b : T_Num_Array =(5,5,5,5); { массив правых концов отрезка [a,b]}
Var
n : Byte;
Root : Real;
Begin
WriteLn;
For n:=1 To N_Func Do Begin
Root:=Bisection(a[n],b[n],f[n]);
WriteLn('f',n,'(',Root:0:3,')=',f[n](Root):0:6);
End;
End.
Программа выведет
f1(1.197)=-0.000000
f2(1.022)=0.000000
f3(1.217)=-0.000000
f4(1.570)=-0.000000