Программа на Delphi

указателями. Эти типы могут быть использованы для повышения эффективности

пользовательских программ, в которых используются указатели. К их числу

относятся: PAnsiString, PString, PByteArray, PCurrency, PExtended и ряд

других указателей. Впрочем, эти типы могут быть легко заменены стандартными

типами. Например PString эквивалентен ^String и т.д.

14.1. Операции с указателями

Для указателей допустимы операции присваивания и сравнения. Указателю можно

присваивать:

содержимое указателя такого же типа;

константу Nil (пустой указатель);

адрес объекта с помощью функции Addr;

адрес с помощью оператора @;

адрес, построенный функцией Ptr.

Пример:

TrPt:= Nil;

Klo1Ptr:= Klo2Ptr;

P1:=@Pp; {эквивалентно P1:= Addr(Pp);}

P2:= Ptr($B701);

14.2. Стандартные процедуры и функции для работы с указателями

Procedure GetMem(Var: P: Pointer; Size: Word);

Выделяет блок памяти размера Size и присваивает адрес начала блока

указателю P.

Procedure FreeMem(Var: P: Pointer; Size: Word);

Освобождает блок памяти размера Size, адресованный указателем P.

Ниже приведен подробный пример, демонстрирующий экономный процесс

копирования текстового файла 't1.txt' в файл 't2.txt' с использованием

указателя Buffer.

Var

F1, F2: file; {объявление файловых переменных}

Buffer: PChar; {объявление указателя на строку }

begin

AssignFile(F1, 't1.txt'); {связывание F1 с файлом 't1.txt'}

Reset(F1, 1); {файл открыт для ввода/вывода}

AssignFile(F2, 't2.txt'); {связывание F2 с файлом 'text.txt'}

Rewrite(F2, 1); {файл открыт для вывода}

try

Size := FileSize(F1); {вычисления размера файла}

GetMem(Buffer, Size); {выделение памяти под чтение файла}

try

BlockRead(F1, Buffer^, Size); {считывание всего файла 't1.txt'}

BlockWrite(F2, Buffer^, Size); {запись в файл 't2.txt'}

finally

FreeMem(Buffer); {освобождение памяти}

end;

finally

CloseFile(F1); {закрытие файла F1}

CloseFile(F2); {закрытие файла F2}

end;

end;

В этом примере объявлен указатель на строку Buffer с завершающим нулем,

которая будет использована для копирования файла 't1.txt' в файл 't2.txt'.

Для этого оператором GetMem для переменной Buffer^ будет динамически

выделен блок памяти размером, равным размеру файла. Далее оператором

BlockRead файл 't1.txt', связанный файловой переменной F1, будет считан в

Buffer^ и затем оператором BlockWrite переменная Buffer^ будет записана в

файл 't2.txt', связанный с файловой переменной F2. Для предотвращения

исключительных ситуаций пример содержит два вложенных блока try – finally –

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

либо причине файл не удалось прочитать или записать операторами BlockRead

или BlockWrite. Такой способ гарантирует освобождение памяти оператором

FreeMem как в случае успешного копирования, так и в случае возможного сбоя.

Внешний блок обслуживает ситуацию, когда у системы возможно нет того объема

памяти, который запрашивает оператор GetMem. В любых вариантах – при

успешном или безуспешном копировании файла – следующие за последним finally

операторы CloseFile закроют открытые операторами Reset и Rewrite файлы F1 и

F2 и позволяет программе продолжить работу.

Procedure New(Var: P: Pointer);

Создает новую динамическую переменную того типа, на который ссылается

указатель. Эквивалентна оператору GetMem(P, SizeOf(P^));

Procedure Dispose(Var: P: Pointer);

Уничтожает динамическую переменную, на которую указывает P. Эквивалентна

оператору FreeMem(P, SizeOf(P^));

Procedure ReallocMem(var P: Pointer; Size: Integer);

Процедура работает следующим образом:

если P= Nil и Size = 0, то оператор не выполнит никаких действий;

если P= Nil и Size > 0, то оператор сработает аналогично GetMem;

если P <> Nil и Size = 0, то оператор сработает аналогично FreeMem.

Function Addr(X): Pointer;

Адрес указанного имени.

14.3. Прочие процедуры и функции для работы с указателями

В модулях System и SysUtils объявлены процедуры и функции, которые могут

найти применение в пользовательских программах. Ниже дано описание

некоторых функций и процедур.

Function GetHeapStatus: THeapStatus;

Расположена в модуле System. Дает сведение о состоянии распределен-ной и

доступной программе памяти. Тип функции имеет вид

THeapStatus = record

TotalAddrSpace: Cardinal;

TotalUncommitted: Cardinal;

TotalCommitted: Cardinal;

TotalAllocated: Cardinal;

TotalFree: Cardinal;

FreeSmall: Cardinal;

FreeBig: Cardinal;

Unused: Cardinal;

Overhead: Cardinal;

HeapErrorCode: Cardinal;

end;

Function AllocMem(Size: Cardinal): Pointer;

Выделяет блок памяти и устанавливает каждый байт "в нуль". Освобо-ждение

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

Procedure GetMemoryManager(var MemMgr: TMemoryManager);

Дает текущее состояние менеджера памяти – специальной записи с типом:

TMemoryManager = record

GetMem: function(Size: Integer): Pointer;

FreeMem: function(P: Pointer): Integer;

ReallocMem: function(P: Pointer; Size: Integer): Pointer;

end;

Procedure SetMemoryManager(var MemMgr: TMemoryManager);

Устанавливает менеджер памяти – выполняет операции выделения и освобождения

памяти в соответствии с предварительно установленными в менеджере памяти

значениями.

14.4. Глобальные переменные AllocMemCount и AllocMemSize

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

быть использованы при контроле за динамически создаваемыми и разрушаемыми

пользовательскими переменными.

AllocMemCount – количество блоков выделенной памяти.

AllocMemSize – размер блоков выделенной памяти.

15. Подпрограммы

Подпрограмма – это законченная алгоритмическая единица, которая

предназначена для выполнения некоторого ограниченного по отношению к

использующей ее программе круга операций.

В языке Object Pascal есть два вида подпрограмм – процедуры и функции.

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

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

описана. Описанием подпрограммы называется ее исходный код, а обращением к

подпрограмме является оператор или его часть, которые содержат код вызова

такой подпрограммы. Таким образом, описание – это технология, а обращение –

это действия по предписанной технологии.

Всякая подпрограмма может иметь локальные и глобальные по отношению к ней

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

подпрограммой, в которой он описан. Всякий другой параметр будет

глобальным. Все глобальные параметры всегда описаны за пределами

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

15.1. Процедуры

Всякая процедура имеет заголовок и тело. Тело процедуры состоит из

операторов, предназначенных для описания имен и действий над данными.

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

Procedure procedureName(parameterList); directives;

localDeclarations;

begin

statements;

end;

Здесь

Name – имя процедуры,

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

directives – директивы,

localDeclarations – внутренние описания,

statements – операторы тела процедуры.

procedureName – имя процедуры. Именем процедуры может быть любое имя, не

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

именем.

parameterList – список формальных параметров может быть либо пуст (в этом

случае скобки можно не использовать), либо должен содержать

последовательность входных и/или выходных величин. Отдельная величина в

описании заголовка может быть:

объявленной с помощью слова var переменной с типом или без типа;

константой;

выходной величиной (т. н. out-параметром).

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

procedure ByRef(var X: Integer; L, K: Integer);

begin

X := X * 2 * L; {правильно}

K := 2 + L; {ошибка}

end;

Процедура c именем ByRef содержит три параметра – переменную X и две

константы L и K. Тело процедуры состоит из операторов, заключенных в

операторных скобках begin – end. Переменные L, K являются только входными и

не могут быть изменены в теле процедуры. По этой причине оператор K:= 2 + L

не даст результата и значение К останется таким же, каким оно было до

обращения к процедуре. Напротив, переменная X, объявленная с помощью слова

var, будет вычислена и на выходе будет иметь то значение, которое будет

вычислено внутри процедуры ByRef.

Out-параметр являет прямую противоположность константе, он должен быть

только выходной, определяемой внутри процедуры, величиной. Например, в

следующем коде

procedure GetInfo(out Info: SomeRecordType);

var MyRecord: SomeRecordType;

...

Proc1(MyRecord);

…

переменная MyRecord не может передавать данные в процедуру Proc1. Напротив,

только Proc1 может сформировать данные и передать их в MyRecord.

Тип параметра может быть любым. Однако нельзя объявлять новый тип прямо в

заголовке подпрограммы. Такой тип должен быть объявлен раньше и только

после этого может быть использован в заголовке подпрограммы.

localDeclarations – внутренние описания могут содержать описание локальных

имен типов или переменных. В предыдущем примере переменная MyRecord типа

SomeRecordType, объявленная внутри процедуры GetInfo, является образцом

такого описания.

directives – директивы используются для того, чтобы дать компилятору

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

описаны в параграфе 15.3.

Для вызова процедуры, т. е. для обращения к заложенному в ней алгоритму,

следует записать оператор, в котором на место формальных параметров должны

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

описание процедуры MatrMult, так и обращение к ней.

Program {начало программы}

…

Const n = 10; {размер матриц}

Type tMatr = array[1.. n, 1.. n] of Real; {тип матриц}

Var Q1, Q2, Q3: tMatr; {описание матриц}

Procedure MatrMult(M1, M2: tMatr; Var M3: tMatr); {заголовок}

Var i, j, k: Integer;

Begin

For i:= 1 to n do

For j:= 1 to n do

Begin {блок определения одного элемента матрицы M3}

M3[i, j]:=0;

For k:=1 to n do

M3[i, j]:= M3[i, j] + M1[i, k] * M2[k, j];

End;

End; {конец описания процедуры MatrMult}

Procedure Prim; {заголовок процедуры Prim}

Var i, j: Integer;

Begin

For i:= 1 to n do {блок задания элементов матриц Q1, Q2}

For j:= 1 to n do

Begin

Q1[i, j]:=i + j;

Q2[i, j]:=i - j;

End;

MatrMult(Q1, Q2, Q3); {оператор обращения к процедуре MatrMult}

End; {конец описания процедуры Prim}

… {текст головной программы}

Prim; {обращение к процедуре Prim}

Q3[2, 3]:= 1;

…

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

части:

описание глобальных констант и переменных;

текст процедуры MatrMult;

текст процедуры Prim;

текст головной программы.

В верхней части описана глобальная константа n = 10, которая используется

во всех следующих за этим структурах. Так, в секции Type объявлен тип

вещественного квадратного массива tMatr. Далее в секции Var объявлены три

переменные – матрицы Q1, Q2, Q3 типа tMatr.

Далее дан текст процедуры MatrMult, которая представляет алгоритм

перемножения матриц M1 и M2 с записью результата в переменную M3. Матрицы

M1, M2 в процедуре не меняются, поэтому их необязательно объявлять

переменными (с позиций процедуры MatrMult переменные M1, M2 выступают в

качестве констант). Напротив, матрица M3 получается как результат,

определяемый внутри процедуры MatrMult, поэтому она объявлена в заголовке

словом Var. Необъявление M3 как переменной привело бы к ошибке: измененные

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

i, j, k, объявленные внутри процедуры, являются локальными и действуют

только в пределах этой процедуры.

Описание процедур заканчивается процедурой Prim. В теле этой процедуры

объявлено две локальные переменные i, j, выполняющих вспомогательную роль

счетчиков циклов. Далее расположено два вложенных друг в друга цикла, с

помощью которых определяются элементы матриц Q1 и Q2. По отношению к

процедуре Prim эти матрицы являются глобальными переменными и,

следовательно, они доступны не только во внешнем блоке, но и внутри

процедуры Prim. И наконец, в нижней части расположен оператор обращения к

процедуре MatrMult, который предназначен для вызова алгоритма перемножения

матриц.

В нижней части программы дан фрагмент текста головной программы, содержащей

вызов процедуры Prim.

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

Сначала будет выполнена процедура Prim (обращение к ней содержится в самой

нижней части текста примера). Эта процедура без параметров, поэтому

управление будет сразу передано в тело процедуры, где начнется

последовательное выполнение содержащихся в нем операторов. Сначала будут

выполнены два вложенных цикла For, где элементы матриц Q1, Q2 будут

заполнены значениями (например Q1[1, 1] = 2, Q2[1, 1] = 0 и т. д.). Далее

уже внутри Prim произойдет обращение к процедуре MatrMult. При этом сначала

произойдет подстановка фактических параметров Q1, Q2, Q3 на место

соответствующих формальных параметров M1, M2, M3. Далее управление будет

передано внутрь процедуры MatrMult, где аналогично последовательным

выполнением ее операторов произойдет перемножение матриц. После выполнения

процедуры MatrMult управление будет передано в ту же точку, с которой

производился ее вызов. Поскольку вызов MatrMult производился из Prim, то

управление будет вновь возвращено в процедуру Prim к оператору,

расположенному вслед за оператором вызова MatrMult. Поскольку в Prim больше

нет невыполненных операторов, то она также заканчивает свою работу и

управление передается в ту алгоритмическую единицу, которая и вызывала

Prim, а именно в головную программу, к оператору Q3[2, 3] := 1.

15.2. Функции

В отличие от процедуры функция предназначена для вычисления одного значения

любого типа. Тип функции указывается в конце ее заголовка. Тип

возвращаемого значения отделяется от списка формальных параметров символом

":" (двоеточие). Кроме того, в теле функции, по крайней мере, один раз

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

функции или переменной Result.

Синтаксис функции имеет вид

function functionName(parameterList): returnType; directives;

localDeclarations;

begin

statements;

end;

Здесь functionName – имя функции; ParameterList, directives,

localDeclarations, statements имеют тот же смысл, что и в процедуре;

ReturnType – тип возвращаемого результата.

Пример.

Function Fact(n: Word): LongInt; {заголовок функции Fact}

Var i: Word; j: LongInt;

Begin

j:=1;

if (n > 1) then

For i:= 2 to n do j:= j * i;

Result:= j;

End; {конец описания функции Fact }

… {текст головной программы}

Var r: Real;

…

r:= 3.4 * Fact(3) / 2.5 / (122 - Fact(5)); {обращение к функции Fact}

…

В этом примере описана функция с именем Fact вычисления факториала n!

неотрицательного целого числа. Тип функции определен как LongInt. В теле

функции размещен оператор Result:= j, который определяет возвращаемый

функцией результат. Способ обращения к функции демонстрирует последний

оператор примера. Видно, что способ обращения к функции имеет существенное

отличие от способа обращения к процедуре. Так, в этом операторе обращение к

функции Fact производится дважды – один раз с фактическим параметром 3,

другой – с параметром 5. Далее возвращенные результаты (соответственно, 6 и

120) будут подставлены в выражение правой части оператора, после чего

последний будет вычислен и переменная r получит вещественное (Real)

значение 4.08.

15.3. Параметры без типа

Это особый вид параметров, который может быть использован только в

заголовках имен процедур и функций. Каждый параметр без типа должен быть

описан как var, const или out-параметр. Например:

procedure TakeAnything(const C);

описывает С как константу без типа.

Параметр без типа компилятор расценивает как параметр потенциально любого

типа. Это означает, что в тело подпрограммы передается только адрес

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

таким параметром.

Однако имеется одно исключение: при обращении к подпрограммам, содержащим

параметры без типа, нельзя использовать числовые значения или

нетипизированные числовые константы.

Следующий пример использует параметры без типа в функции Compare, которая

сравнивает размеры двух переменных V1 и V2 и возвращает ответ в виде

константы –1, если размер V1 меньше размера V2, нуль – если размеры

одинаковы, 1 – если размер V1 меньше размера V2.

function Compare(var V1, V2): ShortInt;

Var i, j: LongInt;

Begin

I:=SizeOf(V1);

J:=SizeOf(V2);

If (I < J) then Result:= -1

Else

If (I > J) then Result:= 1

Else Result:= 0;

End;

Примеры обращений к функции Compare:

type

TVector = array[1..10] of Integer;

TPoint = record

X, Y: Integer;

end;

var

Vec1, Vec2: TVector;

N,i: Integer;

P: TPoint;

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11