Основы Турбо Паскаль

Размещено на http://www.allbest.ru/

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

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

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

Описания процедур.

Описание процедуры позволяет связать идентификатор с процедурным блоком. Процедуру можно затем активизировать с помощью оператора процедуры.

1. Описание процедуры

2. Заголовок процедуры

3. Тело подпрограммы

Заголовок процедуры

Procedure идентификатор процедуры уточненный

Идентификатор метода

Список формальных параметров

Заголовки процедуры именуют идентификаторы процедур и задают формальные параметры (если они имеются).

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

Приведем пример описания процедуры:

Procedure NumString (N: Integer; var S: STRING);

Var

V:integer;

Begin

V:=Abs(n);

S:='';

Repeat

S:=Chr (n mod 10 + Ord (`0')) + S;

N:= N div 10;

Until N = 0;

If N < 0 then

S:= `- `+S;

End;

2. Описания Hear и far

ТР7 поддерживает две модели вызова процедур - ближнею (Hear) и дальнюю (far). С точки зрения объема программы и скорости выполнения ближняя модель вызова более эффективна, но с ней связаны ограничения: процедуры типа near могут вызываться только в том модуле, где они описаны. Процедуры же с дальним типом вызова можно вызывать из любого модуля, но они несколько менее эффективны.

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

Для некоторых специальных целей может потребоваться использование модели с дальним типом вызова. Например, в оверлейных задачах обычно требуется, чтобы все процедуры и функции имели дальний тип вызова. Аналогично, если процедура или функция присваивается процедурой переменной, то она также должна использовать дальний тип вызова. Чтобы переопределить автоматический выбор модели вызова компилятором, можно использовать директиву компилятора ($F+). Процедуры и функции, компилируемые в состоянии ($F+), всегда будут иметь дальний тип вызова (Far), а состоянии ($F-) компилятор автоматически выбирает корректную модель. По умолчанию используется директива ($F-).

Чтобы задать корректную модель вызова, в описании процедуры перед ее блоком можно указать директиву near или far.

При наличии такой директивы она переопределяет директиву $F компилятора и автоматический выбор модели вызова.

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

Procedure MyInt (Flags, CS, IT, AX, BX, CX, DX, SI, DI, DS, ES, BP: Word);

Interrupt;

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

Описание Forward.

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

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

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

В интерфейсной части модуля описания Forward не допускается. Приведем следующий пример опережающего описания:

Procedure Walter (m, n: integer);

Forward;

Procedure Clara (x, y: real);

Begin

End;

Procedure Walter;

Begin

Clara (8.3, 2.4);

End;

Определяющее описание процедуры может быть внешним.

Однако оно может быть внутренним или другим опережающим описанием. Определяющее описание также не может содержать директиву interrupt, описание assembler, near, far, inline или другое описание forward.

Описание assembler.

Описание assembler позволяет создать всю процедуру или функцию на ассемблере.

Блок asm assembler;

Раздел описания asm оператор.

Описание inline. Директивы inline позволяют записывать вместо блока операторов инструкции в машинном коде. При вызове обычной процедуры помещаются в стек для вызова процедуры генерируются инструкция call.

Директива inline оператор inline

Когда происходит вызов процедуры (inline), компилятор генерирует код с помощью директивы inline, а не с помощью инструкции Call. Таким образом, поставляемая процедура «расширяется» при каждом обращении к ней, аналогично макроинструкции на языке ассемблера. Приведем два небольших примера процедур:

Procedure DisableInterrupts: inline ($FA);

Procedure EnableInterrupts;

Inline($FB);

3. Описание функции

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

Описание функции заголовок функции

Тело функции

Заголовок функции function идентификатор

Уточненный идентификатор метода

Список формальных параметров:

Тип результата

Функция не может возвращать процедурный или структурный тип.

В заголовке функции определяется ее идентификатор, формальные параметры (если они имеются) и тип результата.

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

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

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

Результатом функции является последнее присвоение значение.

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

Если идентификатор функции используется при вызове внутри модуля-функции, то она выполняется рекурсивно.

Ниже примеры функции.

Function Max (a: Vector; n: integer):

Extended;

Var

X: extended;

I: integer;

Begin

X:=a (1);

For i:=2 to n do

If x< a (i) then

X:=a (i);

Max:= x;

End;

Function Rower (x: extended; y: integer):

Extended;

Var

Z: extended;

I: integer;

Begin

Z:=1.0;

I:=y;

While i>0 do

Begin

If odd (i) then

Z:= z*x;

X:= Sqr (x);

End;

Power:=z;

End;

Аналогично процедурам, функции могут описываться с ближним типом вызова near, с дальним типом вызова far, опережающие Forward, ассемблерные assembler или подставляемые inline. Однако описание функций прерываний interrupt не допускаются.

Параметры.

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

Список формальных (описание параметров)

Описание параметра список идентификаторов:

Тип размера

Существует три типа параметров: значение, переменная и нетипизированная переменная. Они характеризуются следующим:

· Группа параметров без предшествующего ключевого слова является списком параметров-значений;

· Группа параметров, перед которыми следует ключевое слово const и за которыми указан тип, является списком параметров-констант;

· Группа параметров, перед которыми расположено ключевое слово var и за которыми следует тип, является списком нетипизированных параметров-переменных;

· Группа параметров, перед которыми стоит ключевое слово var или const и за которыми не указан тип, является списком нетипизированных параметров-переменных;

Параметры строкового типа и массивы могут быть открытыми параметрами. Параметры-переменные, описанные с помощью идентификатора OpenString или с использованием ключевого слова String в состоянии ($P+), являются открытыми строковыми параметрами. Значение, константа или параметр-переменная, описанные с помощью синтаксиса Array of T, являются открытым параметром-массивом.

4. Параметры значение

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

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

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

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

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

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

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

5. Параметры переменные

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

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

Файловый тип может передаваться только как параметр-переменная.

Директива компилятора $P управляет смыслом параметра-переменной, описываемого с ключевым словом string. В состоянии по умолчанию (<$P->) STRING соответствует строковому типу с атрибутом размера 225. в состоянии ($P+) string указывает, что параметр является открытым строковым параметром.

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

Правила совместимости по присвоению для объектного типа применяются также к параметру объектного типа. Для формального параметра типа T1 фактический параметр должен иметь тип Т2, если Т2 находится в домене Т1. например:

С учетом описания, методу TFIELD. Copy может передавать экземпляр TFIELD, TSrField, TNumField, TZipField или любой другой экземпляр потомка TField.

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

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

В процедуре или функции у нетипизированного параметра-переменной всех типов, пока ему не будет присвоен определенный тип.

Приведем пример: нетипизированных параметров-переменных:

Function Equal (var source, dest; size: word):

Boolean;

Type

Bytes = array [0..MaxInt] of byte;

Var

V:=integer;

Begin

N;=0;

While (N<size) and (bytes (dest) [n] <>

Bytes (source) [n] do

Inc (n);

Equal:=N= size;

End;

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

Type

Vector = array [1..10] of integer;

Point - record

X, Y: integer;

End;

Var

Vec1, Vec2: Vector;

N: integer;

P: Point;

И вызов функции:

Equal (Vec1, Vec2, SizeOf (Vector));

Equal (Vec1, Vec2, SizeOf (integer)*N);

Equal (Vec[1], Vec[6], SizeOf (integer)*5);

; Equal (Vec1 [1], P, 4);

Выполняются такие действия:

· Сравнивается Vec1 c Vec2;

· Сравниваются первые N элиментов Vec1 с первым N элементами Vec2;

· Сравниваются первые 5 элементов Vec1 с последними пятью элементами Vec2;

· Сравниваются Vec1 [1] c P.x и Vec2 [2] c P.x.

Хотя нетипизированные параметры дают большую гибкость, их использование сопряжено с нескольким риском. Компилятор не может проверить допустимость операций с нетипизированными переменными.

Открытые параметры.

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

Открытые строковые параметры могут описываться двумя способами:

1. с помощью идентификатора OpenString;

2. с помощью ключевого слова String в состоянии ($P+).

Идентификатор OpenString описывается в модуле System. Он обозначает специальный строковой тип, который может использоваться только в описании строковых параметров. В целях обратной совместимости OpenString не является зарезервированным словом и может, таким образом, быть переопределен как идентификатор, заданный пользователем.

Когда обратная совместимость значения не имеет, для изменения смысла ключевого слова string можно использовать директиву компилятора ($p+). В состоянии ($p+) переменная, описанная с ключевым словом string, является открытым строковым параметром.

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

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

Procedure AssignStr (var S: OpenString);

Begin

S:='0123456789ABCDEF';

End;

Так s - это открытый строковой параметр, процедуре AssignStr можно передавать переменные любого строкового типа:

Var

S1:string[10];

S1:string[20];

Begin

AssignStr(S1); {S1:='0123456789'}

AssignStr(S2); (S2:='0123456789ABCDEF');

End.

В AssignStr максимальная длина параметра S та же самая, что у фактического параметра. Таким образом. В первом вызове AssignStr при присвоении параметра S строка усекается, так как максимальная длина S1 равна 10.

В случае применения к открытому строковому параметру стандартная функция Low возвращает 0, стандартная функция High возвращает описанную максимальную длину фактического параметра, а результатом функции SizeOf является размер фактического параметра.

В следующем примере процедура FillString заполняет строку заданным символом до ее максимальной длины. Использование функции High для

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

Procedure FillStr (var S: OpenString; CH: Char);

Begin

{задает длину строки}

S[0]:=Chr (High(s));

{устанавливает число символов}

FillChar (S[1], High) S), Ch);

End;

Значение и параметры-константы, описанные с использованием OpenString или ключевого слова String в состоянии ($P+), не является открытыми строковыми параметрами. Они ведут себя так же, как если бы были описаны с максимальной длиной строкового типа 255, а функция High для таких параметров всего возвращает 255

Формальный параметр, описанный с помощью синтаксиса:

Array of T

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

Array [0..N - 1] of T

Где N число элементов в фактическом параметре. По существу, диапазон индекса фактического параметра отображается в диапазон целых чисел от 0 до N-1. если фактический параметр - это простая переменная типа Т, то он интерпретируется как массив с одним элементом типа Т.

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

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

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

При применении к открытому параметру-массиву стандартная функция Low возвращает 0, стандартная функция High возвращает индекс последнего элемента в фактическом параметре-массиве, а функция SizeOf возвращает размер фактического параметра-массива.

Процедура Clear в следующем примере обнуляет каждый элемент вещественного массива, а функция Sum вычисляет сумму всех его элементов. Поскольку в обоих случаях параметра A является открытым параметром-массивом, подпрограммы могут работать с любым массивом элементов типа Real.

Procedure Clear (var A: array of Real);

Var

I: Word;

Begin

For i:=0 to High (A) do

A[I]:=0;

End;

Function Sum (const A: array of Real):

Real;

Var

I: word;

S: Real;

Begin

S:=0;

For I:=0 to High (A) do

S:=S+A[i];

Sum:=S;

End;

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

Var

I:integer;

Begin

For I:=0 to High (S) do

If S[i] <> # 0 then

While (S[i])

Else

Break;

End;

Допустимы следующие операторы процедур:

PrintSrt (`Hello word');

RrintSrt(`A');

При передаче в качестве открытого параметра-массива пусть строка преобразуется в строку с одним элементом, содержащим символ NULL, поэтому оператор PrintStr(`') идентичен оператору PrintStr (`0#').

6. Параметры процедурного типа

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

Program Tables;

Type

mathFull = function (x, y: integer) integer;

SwapProc = procedure (var A, B: Integer);

Function Add (x, y: integer): integer; far;

Begin

Add:=x+y;

End;

Function Multiply (x, y: integer): integer;

Far;

Begin

Multiply:=x*y;

End;

Function Funny (x, y: integer): integer;

Far;

Begin

Funny:=(x+y)*(x-y);

End;

Procedure PrintNable (w, h: integer; Operation: MathFunc);

Var

X, y: integer;

Begin

For y:=1 to h do

Begin

For x:=1 to w do

Write (Operation (x, y):5;

Writeln;

End;

Writeln;

End;

Begin

printTble (10,10, Add);

PrintTable (10, 10. Multiply);

PrintTable (10,10, Funny);

End.

Параметры процедурного типа особенно полезны в том случае, когда над множеством процедур или функций нужно выполнить какие-то общие действия. В данном случае процедура PrinTable представляет собой общее действие, выполнимое над функциями Add, Multirli, Funny.

Если процедура или функция должны передаваться в качестве параметра, необходимо, чтобы они удовлетворяли тем же правилам совместимости типа, что и при присваивании. То есть такие процедуры или функции должны компилироваться с директивой far; они не могут быть встроенными функциями, не могут быть вложенными и не могут описываться с атрибутами inline или interrupt.

Процедурные переменные.

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

Var

P: SwapProc;

F: MathFunc;

……. Пропущено.

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

Procedure Swap (var A, b: integer);

Far;

Var

Temp: integer;

Begin

Temp:=A;

A:=B;

B:=Temp;

End.

Function Tan (Angle: real): real; far;

Begin

Nan:=Sin(Angle) / Cos (Angle);

End.

Переменой процедурного типа Р теперь можно присвоить значение:

P:=Swap;

После такого приваривания такое обращение Р (I, J) эквивалентно вызову Swap (I, j).

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

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

Как упоминалось выше, имена параметров в описании процедурного типа никакого действия не вызывают.

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

· эта не должна быть стандартная процедура или функция.

· Такая процедура или функция не может быть вложенной.

· Такая процедура не должна быть процедурой типа Inline.

· Она не должна быть процедурой прерывания Interrupt.

Стандартными считаются процедуры и функции, описанные в модуле System, такие как Writeln, Readln, Chr, Ord. чтобы получить возможность использовать стандартную процедуру или функцию с процедурной переменной, необходимо написать для нее специальную «оболочку». например, пусть имеется процедурный тип:

Type

IntProc=Procedure (N: Integer);

Следующая процедура для записи целого числа будет совместимой по присвоению:

Procedure WriteInt (Number: Integer);

Far;

Write (Number);

End.

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

Type

GotoProc = procedure (x, y: integer);

Proclist = array [1..10] of GotoProc;

WindowPtr = ^WindowRec;

Window = record

Next: WindowPtr;

Header: string [31];

Top, Left, Bottom, Right: integer;

SetCursor: GotoProc;

End;

Var

P: Proclist;

W: WindowPtr;

С учетом этих описаний допустимы следующие вызовы процедур:

P [3] (1,1);

W. SetCursor (10.10);

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

Список литературы

1. А. Левин. Самоучитель работы на компьютере. г. Москва 1999 год.

2. А.И. Марченко, Л.А. Марченко. Программирование в среде Turbo Pascal 7.0. Киев «ВЕК+» 1999 год.

3. Рудаков П.И., Федотов М.А. Основы языка Pascal. Учебный курс 2-ое издание. г. Москва 2000 год.

4. Епанешников А.М., Епанешников В.А. Программирование в среде Turbo Pascal 7.0. г. Москва 1999 год.

5. Бинаев С.П., Лаврентьева О.Д. «Среда Turbo Pascal» Киев 1999 год.

6. Ширмов Е.В. «Все о среде Turbo Pascal» «Издательство АСТ Москва» 1998 год.

программный процедура функция паскаль

Размещено на Allbest.ru

...