функции в качестве параметров подпрограмм
Использование функций и процедур в качестве параметров
Страницы работы
Содержание работы
ЛАБОРАТОРНАЯ РАБОТА II-1- 05
ИСПОЛЬЗОВАНИЕ ФУНКЦИЙ И ПРОЦЕДУР
В КАЧЕСТВЕ ПАРАМЕТРОВ
Цель работы: изучение принципов использование процедур и функций в качестве параметров при программировании численных методов.
1. Библиотечные подпрограммы и численные методы. Подпрограммы, выполняющие решение часто повторяющихся задач, удобно хранить в собственном модуле. Такие подпрограммы называют библиотечными, а набор подпрограмм (модуль) – библиотекой подпрограмм. Значение библиотечных подпрограмм в том, что их можно использовать затем в новых программах, не тратя время на повторное программирование.
При этом важно таким образом оформить библиотечную подпрограмму, чтобы при использовании ее для решения новой задачи не нужно было переделывать сам текст подпрограммы. Настроить подпрограмму на решение новой задачи можно только с помощью нужных значений ее параметров.
Большинство численных методов направлено на обработку заданных функций и получение значений тех функций, которые неизвестны. Это означает, что при решении новой задачи изменяется вид функции, а в программе – имя функции. Возникает необходимость передачи имени функции (или процедуры) в обрабатывающую подпрограмму в качестве параметра.
Например, программа, реализующая вывод на экран таблицы значений функции, может иметь достаточно простой вид
Var N,i :integer; a,b,h :real; x,y:real;
Writeln(‘Таблица значений функции’);
For i:=0 to N do begin
Для того, чтобы выводить таблицы значений функции и в других программах, оформим необходимые действия в виде подпрограммы-процедуры. В качестве параметров процедуры укажем те переменные, которые можно задавать по-разному для одной и той же функции (пределы a,b и шаг h). В этом случае программа будет иметь следующий вид:
Var N,i:integer; x,y:real;
Writeln(‘Таблица значений функции’);
For i:=0 to N do begin
Отметим, что параметры процедуры имеют свои имена, которые не обязаны совпадать с именами переменных в программе. Но переменные программы, используемые для указания значений параметров при вызове, должны иметь тот же тип, что и параметры подпрограммы.
Процедура Tabl(ta,tb,th) позволяет получать на экране таблицы для любых приемлемых интервалов изменения аргумента с любым шагом. Однако, ее нельзя считать библиотечной процедурой и включать в собственный модуль, потому что она обрабатывает только одну фиксированную функцию. Для обработки другой функции придется изменять строку y:=Fun1(x), что недопустимо для текста подпрограммы, находящейся в модуле.
2. Функциональные и процедурные типы. Язык программирования Турбо-Паскаль позволяет интерпретировать процедуры и функции как элементы, значение которых можно присваивать переменным и передавать в качестве параметров другим подпрограммам. Это особенно важно при программировании алгоритмов обработки функций и численных методов.
При описании параметров необходимо указывать их тип. Так как функциональные типы не являются стандартными, их необходимо описать в программе в разделе Type.
Описание функционального типа во многом совпадает с записью заголовка процедуры или функции, используемой как параметр, но при этом:
— имя процедуры или функции не ставится;
— перечисляются типы параметров;
— имена параметров могут быть произвольными;
Приведем некоторые примеры описаний функционального типа:
NumericalProc = procedure(N:byte; var x,y:mas);
Имена параметров в описании процедурного типа играют чисто формальную роль и могут быть выбраны любыми.
Функции в качестве параметров подпрограмм
«Любой дурак может написать программу, которую поймет компилятор. Хорошие программисты пишут программы, которые смогут понять другие программисты»
20. Параметры подпрограмм
Список формальных параметров подпрограммы определяет число, порядок и тип фактических параметров, которые д.б. указаны при вызове подпрограммы.
Формальные параметры можно классифицировать на следующие виды: параметры значения, переменные, константы и выходные (var, const и out).
Параметры-значения всегда имеют тип, т.е. являются типизированными, в то время как все другие могут быть типизированными или нетипизированными. Кроме того, специфические правила применяются к параметрам массивам.
Файловые переменные и структурные типы, включающие файловые типы, должны всегда объявляться как параметры переменные.
Параметры переменные и параметры значения.
Параметры значения передаются как значения, в то время как параметры переменные передаются по ссылке (reference). Для пояснения различия между ними сравните две функции:
function DoubleByValue(X: Integer): Integer; // X is a value parameter
function DoubleByRef(var X: Integer): Integer; // X is a variable parameter
Эти функции возвращают одинаковые значения, однако вторая изменяет значение соответствующего фактического параметра:
var I, J, V, W: Integer;
J := DoubleByValue(I); // J = 8, I = 4
W := DoubleByRef(V); // W = 8, V = 8
Даже если одна и та же переменная используется как два или более параметров, никаких копий не создается, например:
procedure AddOne(var X, Y: Integer);
Фактический параметр, соответствующий параметру переменной, должен быть сущностью, которой можно присвоить значение: переменной, типизированной константой, разыменованным указателем, полем или индексированным именем массива.
Эти параметры подобны параметрам значениям за тем исключением, что их значения нельзя изменять в подпрограмме. Их нельзя также передавать (внутри подпрограммы) другим подпрограммам как параметры переменные. Вместе с тем, когда передается ссылка на объект (как параметр константа), свойства объекта модифицировать можно.
Использование параметров констант позволяет компилятору оптимизировать код для строковых и структурных параметров. Кроме того, это обеспечивает также защиту от непредумышленной передачи параметра другой подпрограмме в качестве параметра переменной.
Эти параметры (out parameters), подобно параметрам переменным, также передаются по ссылке. Вместе с тем начальное значение выходного параметра игнорируется, так как он предназначен только для возврата результата. Например,
procedure GetInfo(out Info: SomeRecordType);
При вызове этой процедуры ей передается некоторая переменная типа SomeRecordType и она не используется для передачи каких-либо данных процедуре. Выходные параметры часто используются при использовании COM и CORBA моделей. Кроме того, параметр необходимо объявлять выходным, если процедуре передается неинициализированная переменная.
Любой из параметров – var, const или out – может быть объявлен как не имеющий типа, т.е. нетипизированный. Исключение составляет лишь параметр значение, тип которого должен быть указан обязательно. Пример:
procedure TakeAnything(var A; const B; out C);
Если параметр объявлен нетипизированным, соответствующий фактический параметр не может быть числом или нетипизированной числовой константой. Внутри подпрограммы нетипизированный параметр несовместим ни с каким типом и для его использования необходимо обязательно выполнять приведение типа (typecast).
Приведенная ниже функция иллюстрирует использование нетипизированных параметров для того, чтобы выполнять сравнение параметров любых типов:
Function Equal(var Source, Dest; Size: Integer): Boolean;
Передача имен процедур и функций в качестве параметров в подпрограммы
Вопросы для проверки знаний.
Begin
Begin
Begin
if n=1 then factorial:=1 else factorial:=n*factorial(n-1);
Пример 6. Программный код рекурсивной функции, вычисляющей числовую последовательность с рекуррентной формулой x1 = 3, xn+1 = 4xn + 1 (строка 1 примера 2).
function seq (n : integer): integer;
if n=1 then seq:=3 else seq:=4*seq(n-1)+1;
function r_fun (n : integer): integer;
if n=0 then r_fun:=-3 else r_fun:=(n*n+2*n-3)*r_fun(n-1);
Практическое задание.
1. Разработать код рекурсивной функции, выполняющей возведение вещественного числа в целую степень.
Многие общие методы вычислительной математики, например, дифференцирование (определение производных функции f(x) в заданной точке x = x0), интегрирование (расчет определенного интеграла функции f(x) на отрезке [a,b]) и др., формулируются таким образом, что применять их можно к самым различным функциям. При программной реализации данных методов возникает проблема передачи в подпрограммы, реализующие эти методы, имен процедур и функций в качестве их входных параметров. Например, при программной реализации общих методов дифференцирования и интегрирования наряду с входными параметрами x0 и a,b в соответствующие процедуры необходимо передавать и функцию f(x).
Пример 1. Описание процедурного типа для процедур, у которых три вещественных входных параметра x,y,z и два вещественных выходных параметра a,b:
type Proc_type3r_2r = Procedure (x,y,z: real; var a,b: real);
Пример 2. Описание функционального типа для функций, у которых два вещественных входных параметра x,y и вещественный тип возвращаемого значения:
type Func_type2r_r = Function (x,y: real): real);
Пример 3. Описание процедурного типа для процедур без параметров:
type Proc_type = Procedure;
Фактически описание процедурного и функционального типа создает указатель на подпрограмму, которая после этого может определяться как переменная. После описания процедурных и функциональных типов их можно использовать для задания типов формальных параметров в заголовках других (внешних) подпрограмм.
Пример 4. Заголовок процедуры, у которой формальными входными параметрами являются процедура Pr и функцияFun, имеющие типы, заданные в примерах 1 и 2, а также задано два вещественных выходных параметра v,u:
рrocedure comp(Pr:Proc_type3r_2r; Fun:Func_type2r_r; var v,u: real);
Для практического использования внешних подпрограмм, в заголовки которых входят входные параметры-подпрограммы, необходимо дать описания реальных процедур и функций, имена которых будут передаваться как входные фактические параметры через вызовы внешних подпрограмм. Описания процедур и функций, выступающих в роли входных параметров внешних программ, должны компилироваться в режиме дальней адресации. Для этого в их заголовке указывается директива far или перед текстом описания подпрограммы задается ключ компиляции <$F+>.Он включает режим формирования дальнего типа вызова процедур и функций. После его использования выключить режим можно с использованием обратного ключа <$F->.Прямой и обратный ключи вставляются в текст программы между описаниями подпрограмм.
Замечание. При подстановке фактических процедурных или функциональных параметров в вызов внешней подпрограммы в Free Pascal (в отличие от Турбо Паскаля) перед именем данных параметров необходимо ставить оператор адреса @.
Пример 5. Если в процедуру comp из примера 4 необходимо подставить процедуруPr_1 типа Proc_type3r_2r и функцию F_2 типа Func_type2r_r, то при выходных параметрах a,b вызов процедуры comp в Free Pascal будет иметь вид:
comp(@Pr_1, @F_2,a,b);
Аналогичный вызов в Турбо Паскале будет иметь вид: comp(Pr_1, F_2,a,b).
Пример 6. Разработать две функции численного (приближенного) расчета первой и второй производных дважды дифференцируемой функции одного вещественного аргумента f(x) в заданной точке х=a с именами dfdx и d2fdx2. Для приближенного расчета производных использовать разностные отношения:
где Dх – заранее заданное малое положительное число. В функциях принять: Dх = 0,001.
Вычисление дифференцируемой функции f(x) реализовать с помощью функции F1(x), имя которой передается как параметр. В качестве реальной функции f(x) для отладки программы принять sin(0,5x).
Значение точки х=a вводится в программу с клавиатуры, рассчитанные функциями dfdx и d2fdx2 приближенные значения первой и второй производных в точке х=a выводятся на экран.
Решение. Введем в основной программе глобальный параметр x0 – вводимое число. В описаниях типов введем тип Fun, который представляет собой функцию от одного вещественного аргумента, возвращающую вещественное значение.
Программный код с необходимыми комментариями:
type Fun = function(x: real): real;
var x0: real;
Function F1(x: real): real;
begin F1:= sin(0.5*x) end;
Function dfdx (F:Fun; x:real) :real;
begin dfdx:=(F(x+0.001)-F(x))/0.001; end;
Function d2fdx2(F:Fun;x:real):real;
begin d2fdx2:=(F(x+0.001)-2*F(x)+F(x-0.001))/0.000001; end;
begin
WriteLn(‘ First derivative of function at’,x0:10,’=’,dfdx(@F1,x0):10);
WriteLn(‘ Second derivative of function at’,x0:10,’=’,d2fdx2(@F1,x0):10);
Нам важно ваше мнение! Был ли полезен опубликованный материал? Да | Нет
Параметры процедур и функций
Параметры служат для передачи в процедуры и функции исходных данных и для приёма результатов. В зависимости от назначения они описываются в заголовке подпрограммы тремя основными способами:
Первый способ предполагает указание списка параметров и их типа, например:
Procedure MyProc (a,b,c: Integer; d: Real);
Function MyFunc (a,b,c: Integer; d: Real):Real;
В этом случае в процедуру и функцию передаются значения фактических параметров, указанных при вызове подпрограммы. Такие параметры называются параметрами-значениями. Формальный параметр является переменной, локальной в блоке. Если параметр определен как параметр–значение, то перед вызовом подпрограммы это значение вычисляется, полученный результат копируется во временную память и передается подпрограмме. Изменение значения формальных параметров внутри процедуры или функции не приводит к изменению фактических. Фактический параметр может быть выражением того же типа, что и соответствующий ему формальный параметр.
Второй способ. Фактические параметры передаются в процедуру или функцию по ссылке. В этом случае перед списком параметров располагается слово var, например:
Procedure MyProc(var a,b,c: Integer; d: Real);
Function MyFunc(var a,b,c: Integer; d: Real):Real;
Когда параметр передается посредством ссылки, фактический параметр является переменной. Формальный параметр обозначает эту фактическую переменную в течение всего времени активизации блока. Параметры, переданные посредством ссылки, называются параметрами-переменными. Если параметр определен как параметр–переменная, то при вызове подпрограммы передается сама переменная, а не её копия (фактически в этом случае подпрограмме передается адрес переменной). Их характерный признак – любое изменение формального параметра означает изменение фактического параметра. В параметры, передаваемые по ссылке, помещаются результаты работы программы.
Третий способ описания основан на использовании параметров–констант, которые задаются с использованием слова const:
Procedure MyProc(const a,b,c: Integer; d: Real);
Function MyFunc(const a,b,c: Integer; d:Real):Real;
В этом случае используется механизм передачи параметров по ссылке, но внутри подпрограммы формальные параметры изменять нельзя. Это означает, что в случае параметра–константы в подпрограмму также передается адрес области памяти, в которой располагается переменная или вычисленное значение. Однако компилятор блокирует любые присваивания параметру–константе нового значения в теле подпрограммы. Этот способ используется для передачи в подпрограмму данных большого объема.
Возможен смешанный вариант, когда указываются и посылаемые в подпрограмму данные, и возвращаются результаты, например:
Procedure MyProc(a,b,c: Integer; var d: Real);
Function MyFunc(a,b,c:Integer; var d:Real):Real;
Нетипизированные параметры–переменные. Существует разновидность ссылочных параметров без типа. Они называются нетипизированными и предназначены для передачи и приёма данных любого типа. Параметр считается нетипизированным, если тип формального параметра–переменной в заголовке подпрограммы не указан, при этом соответствующий ему фактический параметр может быть переменной любого типа. Нетипизированными могут быть только параметры–переменные.
Нетипизированные параметры описываются с помощью ключевых слов var и const, при этом тип данных опускается:
Procedure MyProc(const y; var x);
Function MyFunc(const y; var x):Real;
Внутри подпрограммы тип таких параметров неизвестен, поэтому программист должен сам позаботиться о правильной интерпретации переданных данных. В остальном это обычные параметры, передаваемые по ссылке.
Параметры–массивы. Для передачи массива фиксированной длины в подпрограмму необходимо предварительно описать его тип.
Type
MasType=array [1..10] of Integer;
Procedure S (mas:MasType);
При передаче подпрограмме массивов переменной длины используются так называемые открытые массивы. Открытый массив представляет собой формальный параметр подпрограммы, описывающий базовый тип элементов массива, но не определяющий его размерности и границы:
Procedure MyProc(OpenArray:array of Integer);
Внутри подпрограммы такой параметр трактуется как одномерный массив с нулевой нижней границей. Верхняя граница открытого массива возвращается функцией High. Используя нуль как минимальный индекс и значение, возвращаемое функцией High, как максимальный индекс, подпрограмма может обрабатывать одномерные массивы произвольной длины.
Пример. Программа вывода на экран содержимого двух одномерных массивов различной длины.
Program DemoMass;
Const
A: array[-1..2] of Integer=(0,1,2,3);
B: array[5..7] of Integer=(4,5,6);
Procedure ArrayPrint(Mas:array of Integer);
Begin
For i:=0 to High(Mas) do
Begin
Параметры–строки. Поскольку строка фиксированной длины является фактически своеобразным массивом, её передача в подпрограмму осуществляется аналогичным образом:
Type
InType=String[15];
OutType=String[30];
Function St (s:InType):OutType;
Для передачи строк произвольной длины можно установить режим компиляции, при котором отключается контроль за совпадением длины фактического и формального параметра–строки. При передаче строки меньшего размера формальный параметр будет иметь ту же длину, что и параметр обращения; передача строки большего размера приведет к её усечению до максимального размера формального параметра. Контроль включается только при передаче строки, объявленной как формальный параметр–переменная. Если соответствующий параметр объявлен параметром–значением, эта опция игнорируется и длина не контролируется.
Процедурные типы. Параметры–функции и параметры–процедуры. Процедурные типы позволяют передавать имена процедур и функций в подпрограммы в качестве параметров. Для объявления процедурного типа используется заголовок процедуры (функции), в котором отсутствует ее имя:
Type
Proc1=Procedure (a,b,c:Real; var d:Real);
Proc2=Procedure;
Func1=Function (var a:Integer):real;
Существуют два процедурных типа: тип-процедура и тип-функция. При передачи имен процедур и функций в качестве параметров, эти подпрограммы должны быть откомпилированы с расчетом на дальнюю модель памяти, т.е. сразу за заголовком процедуры или функции должна быть использована директива компилятора Far.
Program DemoProc;
Type
Func=Function (x:Real):Real;
Function sin1(x:Real):Real; far;
Begin
Function cos1(x:Real):Real; far;
Begin
Procedure Fn(x:Real; f:Func);
Begin
Writeln (‘Значение функции =’,p:8:3);
Begin
В программе могут быть объявлены переменные процедурных типов:
Переменным процедурных типов допускается присваивать в качестве значений имена соответствующих подпрограмм. После такого присваивания имя переменной становится синонимом имени подпрограммы, например:
Program DemoProc1;
Type
Func=Function (x:Real):Real;
Function sin1(x:Real):Real; far;
Begin
Procedure Fn(x:Real; f:Func);
Понятие процедуры и функции.
Для организации подпрограмм используются 2 типа подпрограмм: процедуры и функции.
Функция – подпрограмма, в которой выполняется некоторый набор действий, в результате чего имя функции получает некоторое единственное значение, передаваемое в вызываемую подпрограмму, при этом управление при выходе из функции возвращается в точку ее вызова.
Процедура – подпрограмма, в которой производится некоторый набор действий, при этом имени процедуры ничего не присваивается: процедура не имеет возвращаемого значения. Результаты в вызывающую программу передаются через механизм параметров или глобальные переменные. Управление возвращается за точку вызова процедуры.
Локальные const, var, type, label – описательная часть.
Сравнение процедур и функций.
— Функция обязательно имеет тип возвращаемого значения. Процедура возвращаемого значения не имеет.
— Внутри тела функции – обязательно присвоение имени значения.
— Процедура вызывается отдельно с помощью оператора вызова с передачей параметров, функция – вызывается в операторе присваивания.
— Функция всегда возвращает хотя бы 1 результат; процедура не возвращает ничего.
Модель дальнего вызова подпрограмм.
Спецификатор far, объявленный около имени процедуры, включает директиву дальнего вызова. В данном режиме компилятор определяет модель памяти, для которой любые указатели воспринимаются как дальние, то есть, данные могут располагаться в сегменте, отличном от сегмента программы.
Предварительное описание подпрограмм.
В ряде случаев необходимо выполнять предварительные описания процедур или функций. Например, пусть существует процедура a, которая в ходе своей работы выполняет обращение к процедуре b. Следовательно, процедура b должна быть объявлена и известна компилятору до момента вызова (т.е. выше процедуры a).
Допустим, процедура b в ходе своей работы вызывает процедуру a. Для разрешения этого выполняют предварительное объявление. Оно представляет собой заголовок процедуры или функции без указания её тела с обязательной директивой forward. Эта директива указывает компилятору на то, что тело подпрограммы будет описано ниже с возможным досрочным вызовом.
Внешнее описание подпрограмм.
В процессе накопления опыта программирования может быть создан набор подпрограмм, удобных для дальнейшего использования. Обычно такие функции объединяют в библиотеки. Библиотека представляет собой откомпилированный файл, не являющийся программой.
В таком случае объектный код содержится в некотором *.obj-файле, а само подключение производится директивой <$L имя файла>. После описания заголовка подпрограммы из *.obj-файла необходимо задать служебное слово external. Это укажет компилятору, что вызываемую подпрограмму с данным именем следует искать в одном из подключенных объектных файлов.
Механизм параметров. Формальные и фактические параметры. Параметры значения, переменные, константы, нетипизированные параметры.
Организация обмена данными происходит с помощью механизма параметров.
Все данные можно разбить на 4 основных класса:
При организации вызова подпрограмм в оперативной памяти в специальной области, называемой областью рекурсивного стека, создается копия рабочих полей подпрограммы, содержащая всю локальную для этой подпрограммы информацию, необходимую для ее выполнения. Рекурсивный стек состоит из страниц и заполняется по мере вызова подпрограмм.
1 – указатель связи (адрес вызываемой подпрограммы)
2 – локальные переменные, объявленные в описательной части подпрограммы
3 – адрес возврата (куда будет передано управление)
4 – параметры из заголовка вызываемой подпрограммы, при этом список записывается в страницу стека в прямом порядке
5 – возвращаемое значение, если таковое имеется.
После завершения подпрограммы страница стека полностью удаляется.
Формальные и фактические параметры.
Обмен информацией между вызываемой и вызывающей подпрограммой осуществляется с помощью механизма передачи параметров. Переменные, указанные в заголовке подпрограммы называют формальными параметрами. Эти переменные используются только внутри подпрограммы.
Переменные, указанные в строке вызова подпрограммы называются фактическими параметрами. Их значение зависит от механизма передачи параметра. Для вызываемой подпрограммы данные переменные являются глобальными.
Между фактическими и формальными параметрами устанавливается взаимооднозначное соответствие. Количество, типы и порядок следования параметров должны совпадать.
Параметры значения: используются для передачи данных в подпрограмму, при этом создается копия передаваемого значения. Изменения таких параметров не видны на внешнем уровне. Тип формального и фактического параметра должен быть совместим по присваиванию.
Если в вызывающей программе описаны переменные X: Integer, C: Byte; Y: Longint;, то синтаксически правильными вызовами P будут P(X), P(C), P(Y), P(200).
Основной недостаток – временные затраты, необходимые для создания копии передаваемого параметра, затрата памяти в стеке и его переполнение.
Параметры ссылки (параметры-переменные): используются для организации передачи результатов работы подпрограммы через параметры, при этом передается адрес параметра без создания его копии.
Все изменения, производимые с параметром, передаваемым по ссылке, видны после вызова подпрограммы.
Параметры-константытак же, как и параметры-переменные, позволяют передавать в подпрограмму данные по ссылке, но в отличие от параметров-переменных модификация переданных значений внутри подпрограммы невозможна и эта ситуация будет отслеживаться компилятором. Параметры-константы используются для передачи в подпрограмму больших объемов данных с целью экономии динамической памяти.
Такие параметры передаются с указанием ключевого слова const и приводят в текущую область стека адрес передаваемого значения.
Нетипизированные параметры: В ряде случаев необходимо передавать параметры, тип которых в момент описания функциинеизвестен. Такие параметры называют нетипизированными, при этом тип формального параметра в заголовке функции не указывается, а производится подстановка типа фактического параметра.
Процедурные типы. Параметры-функции и параметры-процедуры.
Передаваемым в подпрограмму параметром может также быть процедура или функция (указатель на нее), т.е. параметр процедурного типа.
Для параметров-функций и параметров-процедур существуют следующие правила: подпрограммы должны иметь ключевое слово far; они не должны являться стандартными подпрограммами; не должны объявляться внутри других подпрограмм; не должны иметь директив inline или interrupt.
Type
F1 = procedure;
F2 = function(X: Integer; var S: String): Boolean;
function F2(X: Integer; var S: String): Boolean; far;