Процедуры и функции

Процедуры и функции.

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

Использование подпрограмм позволяет реализовать один из самых прогрессивных методов программирования ― структурное программирование.

Прежде чем начать описывать подпрограммы вспомним, что собой представляет программа в Delphi. программа хранится на диске с названием заголовка программы и расширением DPR. Вот ее архитектура:

program Project1;	//Заголовок программы
uses Forms, Unit1 in 'Unit1.pas' {Form1};	//Список подключаемых модулей
{$R *.RES}	//Подключаемые файлы ресурсов
begin Application.Initialize; Application.CreateForm(TForm1, Form1); Application.Run; end.	//Текст программы

Файл программы состоит из заголовка и блока программы. Блок программы включает объявление подключаемых модулей (частей программы), подключаемые ресурсные файлы (иконки, указатели мыши, рисунки), текст программы (создание окон, запуск приложения на выполнение).

Вызвать файл программы на редактирование можно из меню "Project" пунктом "View Source". Во избежание появления ошибок, некорректной работы программы настоятельно не рекомендуется самостоятельно вручную редактировать этот файл. Все необходимые изменения производятся в Delphi автоматически.

Заголовок или название программы всегда должен совпадать с названием проекта. Если вам необходимо изменить название проекта, то следует пересохранить проект под другим именем.

Для того, чтобы разбить программу на несколько отдельных задач, которые можно редактировать по отдельности и применяются модули. В Delphi каждое отдельное проектируемое окно имеет свой модуль. Но их в программе может быть гораздо больше.

Структура модуля:

unit Unit1;	//Заголовок модуля
interface	//Заголовки доступных свойств
uses Windows, SysUtils, Forms;	//Подключаемые модули
type TForm1 = class(TForm)	//Описание типа
private { Private declarations }	//Скрытый раздел свойств
public { Public declarations }	//Открытый раздел свойств
end;
var Form1: TForm1;	//Описание переменной
implementation	//Описание свойств
{$R *.DFM}	//Подключаемые файлы ресурсов
end.

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

Если переименовать форму Form1 в MainForm, добавить в не компонент Memo1, и задействовать событие OnChange (изменение текста внутри этого компонента), то программный код изменится следующим образом:

unit Unit1;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type
TMainForm = class(TForm) // изменяется описание класса этой формы
Memo1: TMemo; // добавляется компонент Memo1 из класса TMemo
procedure Memo1Change(Sender: TObject); // заголовок процедуры
private
{ Private declarations }
public
{ Public declarations }
end;

var
MainForm: TMainForm; // задание переменной формы

// из объявленного класса

implementation

{$R *.DFM}

procedure TMainForm.Memo1Change(Sender: TObject);
begin
// здесь следует текст реакции на событие изменения текста

// в компоненте Memo1
end;

end.

Как правило, программист не выходит за области implementation раздела, а тут самостоятельно не создает процедуры. Программная оболочка делает это автоматически по мере необходимости и ликвидирует пустые лишние заголовки процедур при сохранении файла модуля.

Итак, в Delphi предусмотрено несколько средств для деления программы на части. На верхнем уровне деления это модули, на нижнем уровне (уровне элементарных подзадач) это процедуры и функции.

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

Процедуры и функции состоят из операторов локальных данных и внутренних процедур и функций. Структура описания процедуры имеет вид:

Procedure <Имя> (Список_формальных_параметров);

Label //Описание меток;

Const //Описание констант;

Type //Описание типов;

Var //Описание переменных;

Procedure //Описание внутренних процедур;

Function //Описание внутренних функций;

Begin

//Операторы

End;

Структура описания функции имеет вид:

Function <Имя> (Список_формальных_параметров): Тип_результата;

Label //Описание меток;

Const //Описание констант;

Type //Описание типов;

Var //Описание переменных;

Procedure //Описание внутренних процедур;

Function //Описание внутренних функций;

Begin

//Операторы, среди которых есть хотя бы один, который присваивает имени функции значение

//результата

End;

Список параметров

В заголовке подпрограммы (в ее объявлении) указывается список формальных параметров переменных, которые принимают значения, передаваемые в подпрограмму извне во время ее вызова. Для краткости мы далее будем опускать слово "формальный".

Поскольку внутри подпрограммы параметры рассматриваются как переменные с начальным значением, то имена локальных переменных, описываемые в разделе var (внутреннем для подпрограммы), не могут совпадать с именами параметров этой же подпрограммы. Список параметров может и вовсе отсутствовать:

procedure proc1;

function func1: boolean;

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

Если же параметры имеются, то каждый из них описывается по следующему шаблону:

[<способ_подстановки>]<имя_параметра>:<тип>;

О возможных способах подстановки значений в параметры (<пустой>, var, const) мы расскажем в разделе "Способы подстановки аргументов".

Если способ подстановки и тип нескольких параметров совпадают, описание этих параметров можно объединить:

[<способ_подстановки>]<имя1>,...,<имяN>: <тип>;

Пример описания всех трех способов подстановки:

function func2(a,b:byte; var x,y,z:real; const c:char);

В заголовке подпрограммы можно указывать только простые (не составные) типы данных. Следовательно, попытка записать

procedure proc2(a: array[1..100]of char);

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

type arr = array[1..100] of char;

procedure proc2(a: arr);

function func2(var x: string): arr;

Возвращаемые значения

Основное различие между функциями и процедурами состоит в количестве возвращаемых ими значений.

Любая функция, завершив свою работу, должна вернуть основной программе (или другой вызвавшей ее подпрограмме) ровно одно значение, причем его тип нужно явным образом указать уже при объявлении функции.

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

Например:

function min(a,b: integer): integer;

begin if a>b

then min:= b

else min:= a

end;

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

Вызов подпрограмм

Любая подпрограмма может быть вызвана не только из основного тела программы, но и из любой другой подпрограммы, объявленной позже нее.

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

<имя_подпрограммы>(<список_аргументов>);

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

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

Вызов функции не может быть самостоятельным оператором, потому что возвращаемое значение нужно куда-то записывать. Зато оно может стать равноправным участником арифметического выражения. Например:

c:= min(a,a*2);

if min(z, min(x,y))= 0 then...;

Процедура же ничего не возвращает явным образом, поэтому ее вызов является отдельным оператором в программе. Например:

err(res,'Привет!');

Замечание: После того как вызванная подпрограмма завершит свою работу, управление передается оператору, следующему за оператором, вызвавшим эту подпрограмму.

Способы подстановки аргументов

Как уже упоминалось выше, при вызове подпрограммы подстановка значений аргументов в параметры производится в соответствии с правилами, указанными в атрибуте <способ_подстановки>. Мы рассмотрим три различных значения этого атрибута:

<пустой>;

var;

const.

Параметр-значение

Описание

В списке параметров подпрограммы перед параметром-значением служебное слово отсутствует. Например, функция func3 имеет три параметра-значения:

function func3(x:real; k:integer; flag:boolean):real;

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

dlina:= func3(shirina/2, min(a shl 1,ord('y')), true)+0.5;

Для типов данных здесь не обязательно строгое совпадение (эквивалентность), достаточно и совместимости по присваиванию.

Механизм передачи значения

В области памяти, выделяемой для работы вызываемой подпрограммы, создается переменная с именем <имя_подпрограммы>.<имя_параметра>, и в эту переменную записывается значение переданного в соответствующий параметр аргумента. Дальнейшие действия, производимые подпрограммой, выполняются именно над этой новой переменной. Значение же входного аргумента не затрагивается. Следовательно, после окончания работы подпрограммы, когда весь ее временный контекст будет уничтожен, значение аргумента останется точно таким же, каким оно было на момент вызова подпрограммы.

В качестве примера рассмотрим последовательность действий, выполняемых при передаче аргументов 1+а/2, а и true в описанную выше функцию func3. Пусть а - переменная, имеющая тип byte, тогда значение выражения 1+a/2 будет иметь тип real, а true и вовсе является константой (неименованной).

Итак, при вызове func3(1+a/2,a,true) будут выполнены следующие действия:

создать временные переменные func3.x, func3.k, func3.flag;
вычислить значение выражения 1+а/2 и записать его в переменную func3.x;
записать в переменную func3.k значение переменной а;
записать в переменную func3.flag значение константы true;
произвести действия, описанные в теле функции;
уничтожить все временные переменные, в том числе func3.x, func3.k, func3.flag.

Уже видно, что значения аргументов не изменятся.

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

Параметр-переменная

Описание

В списке параметров подпрограммы перед параметром-переменной ставится служебное слово var. Например, процедура proc3 имеет три параметра-переменные и один параметр-значение:

procedure proc3(var x,y:real; var k:integer; flag:boolean);

При вызове подпрограммы параметру-переменной может соответствовать только аргумент-переменная; константы и выражения запрещены. Кроме того, тип аргумента и тип параметра-переменной должны быть эквивалентными.

Механизм передачи значения

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

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

Замечание: Для экономии памяти в параметр-переменную можно передавать и такую переменную, изменять значение которой не требуется. Скажем, если нужно передать в качестве аргумента массив, то лучше не создавать его копию, как это будет сделано при использовании параметра-значения, а использовать параметр-переменную.

Параметр-константа

Описание

В списке параметров подпрограммы перед параметром-константой ставится служебное слово const. Например, процедура proc4 имеет один параметр-переменную и один параметр-константу:

procedure proc4(var k:integer; const flag:boolean);

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

Механизм передачи значения

В некоторых источниках можно встретить утверждение о том, что для параметра-константы, как и для параметра-переменной, не создается копии в момент вызова подпрограммы. Однако выполнение простейшей проверки

var a: byte;

Implementation

procedure prob(const c:byte);

begin

Label1.Caption:=IntToStr(longint(addr(c))); {физ.адрес параметра с}

end;

Procedure TForm1.Button1Click(Sender:TObject);

begin

a:=0;

Label2.Caption:=IntToStr(longint(addr(a))); {физ.адрес переменной а}

prob(a);

end;

end.

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

Области действия имен

Разграничение контекстов

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

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

Таблица 8.1. Пример разграничения контекстов program prog;

var a:byte;

Implementation

procedure pr1 (p:byte);

var b:byte; (первый уровень вложенности)

function f (pp:byte);

var c:byte; (второй уровень вложенности)

begin

//здесь "видны" переменные a, b, c, p, pp

end;

procedure TForm2. Create(Sender:TObject);

begin

//здесь "видны" переменные a, b, p

end;

var g:byte

procedure pr2;

var d:byte; (первый уровень вложенности)

begin

//здесь видны переменные a, d, g

end;

procedure TForm1.Create(Sender:TObject);

begin

//тело программы; здесь "видны" переменные a, g

end;

end.

Побочный эффект

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

Чтобы избежать побочного эффекта, необходимо строго следить за тем, чтобы подпрограммы изменяли только свои локальные переменные (в том числе и параметры-переменные).

Совпадение имен

Вообще говоря, совпадения глобальных и локальных имен допустимы, поскольку к каждому локальному имени неявно приписано имя той подпрограммы, в которой оно объявлено. Таким образом, в приведенном выше примере (см. пример 8.1) фигурируют переменные a, g, pr1.p, pr1.b, pr1.f.pp, pr1.f.c, pr2.d.

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

<имя_программы>.<имя_глобальной переменной>

Например (локальной переменной здесь присваивается значение глобальной):

a:= prog.a;

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

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

В объявлении подпрограммы можно не указывать тип параметра-переменной:

procedure proc5(var x);

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

Для того чтобы внутри самой подпрограммы корректно обрабатывать значения, поступившие через нетипизированный параметр, существует два различных способа.

Явное преобразование типа

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

procedure proc5(var x);

type arr = array[1..10] of byte;

var x: integer;

z: real;

m: arr;

begin

...

y:= integer(x);

z:= real(x);

m:= arr(x);

...

end;

Совмещение в памяти

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

<локальная_переменная>: <тип> absolute <нетипизир_параметр>;

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

function func5(var x):real;

var xxx: longint absolute x;

begin

{здесь с началом любой переменной,

поступившей в параметр х,

... можно обращаться как с longint-числом:

при помощи локальной переменной ххх}

end;

Открытые массивы

Delphi поддерживает так называемые открытые массивы, легко решающие проблему передачи подпрограмме одномерных массивов переменной длины.

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

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;

Процедурные типы

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

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

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;

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

На главную.