Порядок выполнения работы

1. 
   Изучить теоретические сведения по теме: “Изучение карты памяти. Разработка программы доступа к полям PSP”.
   
2. 
   Изучить программу распределения памяти и доступа к полям PSP.
   
3. 
   Показать работающую программу преподавателю.
   
4. 
   Ответить на контрольные вопросы.
   

Контрольные вопросы

1. 
   Адреса MS-DOS. Абсолютный адрес, сегмент, смещение.
   
2. 
   Карта распределения памяти при выполнении программы.
   
3. 
   Сегмент кода, сегмент данных, сегмент стека. Назначение каждого из сегментов.
   

Лабораторная работа № 32

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

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

Краткие теоретические сведения

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

• сама программа пользователя;

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

• определяемые пользователем структуры данных и константы;

• точки возврата для подпрограмм;

• временная память для хранения промежуточных результатов при вычислении выражений;

• временная память при передаче параметров и т.п.

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

Статические и динамические переменные

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

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

var M1 : array[1..300,1..300] of Integer;

Такие переменные, описанные в разделе Var, Н.Вирт назвал статическими. Название "статические" они получили за то, что компилятор Паскаля может обработать их без выполнения программы, т. е. на основании лишь статического текста программы. Статические переменные можно использовать в случаях, когда память, необходимая для работы программы, предсказуема в момент написания программы.

В данном случае мы имеем наглядный пример нерационального использования памяти компьютера с применением статических переменных. Так как один элемент матрицы — целое число — занимает в памяти два байта, а общее количество элементов равно 300*300= 90000, то для размещения всей матрицы вышеописанным способом в памяти компьютера нужно 90000*2 байт = 180000 байт. Вместе с тем маловероятно, чтобы при всяком выполнении программы ей действительно были нужны одновременно все элементы такого огромного массива. К тому же все переменные, объявленные в программе, размещаются в одной непрерывной области оперативной памяти, которая называется сегментом данных. Длина сегмента данных определяется архитектурой микропроцессора 8086 и составляет 65536 байт (64 Кбайта), что также вызывает затруднения при обработке больших массивов данных.

Выходом из этого положения может быть использование динамической памяти. Динамическая память - это оперативная память компьютера, предоставляемая программе при ее работе, за вычетом сегмента данных (64 Кбайта), стека (обычно 16 Кбайт) и собственно тела программы. Размер динамической памяти определяется всей доступной памятью компьютера и составляет 200...400 Кбайт.

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

Указатели

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

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

Типизированные указатели

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

Для объявления типа указателя Р на целочисленный тип данных следует записать:

Type Р = ^Integer;

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

Var

Р1, Р2 : Р; {Тип Р введен выше}

R : ^Byte;

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

Например:

RecPtr = ^RecordType;

RecordType=record

Name : string[20];

Number : integer;

end;

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

Реально значения ссылочных типов (указателей) содержат адреса расположения в памяти конкретных значений базового типа. В персональном компьютере адреса задаются совокупностью двух шестнадцатиразрядных слов, которые называются сегментом и смещением. Сегмент - это участок памяти, имеющий длину 65536 байт (64 Кбайт) и начинающийся с физического адреса, кратного 16 (0, 16, 32, 48 и т.д.). Смещение указывает, сколько байт от начала сегмента необходимо пропустить, чтобы обратиться к нужному адресу. Таким образом, по своей внутренней структуре любой указатель представляет собой совокупность двух слов (данных типа Word), трактуемых как сегмент и смещение.

Абсолютный адрес образуется следующим образом: сегмент* 16+смещение.

Для того чтобы присвоить переменной ссылочного типа некоторое значение, можно воспользоваться унарной операцией взятия указателя, которая строится из знака этой операции-символа @ (амперсант) и одного операнда-переменной. Например, если имеется описание переменной I целого типа:

Vаr I : integer;

то применение этой операции к переменной I: @I дает в качестве результата значение типа указатель на целое. Аналогичный результат получится и в результате операции Р = ^Integer;

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

Например, если есть описание:

Var А : array[1..10] of integer;

то конструкция @А[I] имеет смысл указателя на I-е целое в массиве А и также может участвовать в присваивании: Р := @А[I].

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

Среди всех возможных указателей в Турбо Паскале выделяется один специальный указатель, который "никуда не указывает". Можно представить такую ситуацию: в адресном пространстве оперативной памяти компьютера выделяется один адрес, в котором заведомо не может быть размещена никакая переменная. На это место в памяти и ссылается такой нулевой (или пустой) указатель, который обозначается словом Nil. Указатель Nil считается константой, совместимой с любым ссылочным типом, поэтому его значение можно присваивать любому указателю. Обычно значение Nil присваивают указателю, когда его указание надо отменить или в начале инициализации программы. Это позволяет проверять значение указателя, прежде чем присваивать ему какое-либо значение.

Нетипизированный указатель (pointer)

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

Переменные типа Pointer не могут быть разименованы: указание символа ^ после такой переменной вызывает появление ошибки. Как и значение, обозначаемое словом Nil, значения типа Pointer совместимы со всеми другими типами указателей.

Над значениями ссылочных типов допускаются две операции сравнения на равенство и неравенство, например @Х <> @Y или Р1 = Р2.

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

Доступ к переменной по указателю

Для доступа к переменной имеются две возможности: первая - использовать идентификатор переменной, вторая - воспользоваться адресом этой переменной, который содержится в указателе на эту переменную.

Например, чтобы увеличить значение переменной I, на которую указывает указатель Р: по первому способу можно записать: I:=I+2.Для реализации второго, косвенного доступа к переменной по указателю, используется разыменование указателя. Правило разыменования таково: для того чтобы по указателю на переменную получить доступ к самой переменной, нужно после переменной-указателя поставить знак ^. Так, запись: Writeln(Int2^) означает напечатать значение переменной, на которую ссылается указатель Int2. Поэтому чтобы увеличить значение переменной I, на которую указывает указатель Р, используя косвенный доступ к переменной по указателю, можно записать: Р ^:= P^ + 2.

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

Управление динамической памятью

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

Начало кучи хранится в стандартной переменной HeapOrg, конец - в переменной HeapEnd. Текущую границу незанятой динамической памяти указывает указатель HeapPtr.

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

Процедуры динамического распределения

Dispose Уничтожает динамическую переменную

FreeMem Уничтожает динамическую переменную данного размера

GetMem Создает новую динамическую переменную заданного размера и устанавливает переменную-указатель для нее

Mark Записывает в переменной-указателе состояние кучи

New Создает новую динамическую переменную и устанавливает на нее переменную-указатель

Release Возвращает кучу в заданное состояние

Функции динамического распределения

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

MemAvail Возвращает количество имеющихся в куче свободных байтов

Функции для работы с указателями и адресами

Addr Возвращает адрес заданного объекта

Cseg Возвращает текущее значение регистра CS

Dseg Возвращает текущее значение регистра DS

Ofs Возвращает смещение заданного объекта

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

Seg Возвращает сегмент для заданного объекта

SPtr Возвращает текущее значение регистра SP

Sseg Возвращает текущее значение регистра SS

Основные действия над динамическими переменными - создание и уничтожение - реализуются в Турбо Паскале стандартными процедурами New и Dispose.

Процедура New предназначена для создания динамических переменных определенного типа. Она отводит новую область памяти в куче для данной динамической переменной и сохраняет адрес этой области в переменной-указателя. Можно присвоить значение переменной-указателю и с помощью оператора @ или функции Ptr. Оператор @ устанавливает переменную-указатель на область памяти, содержащую существующую переменную, включая и те переменные, которые имеют идентификаторы. Функция Ptr устанавливает переменную-указатель на определенный адрес в памяти. Например:

New(Int1);

P1 := @X;

Ptr($40, $49);

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

Если в программе не предполагается использование кучи, то при работе с программой Турбо Паскаля рекомендуется снизить потребность в памяти для создаваемой программы с помощью меню Options/Heap.

При освобождении динамической памяти нужно соблюдать осторожность, т.е. пользоваться либо New/Dispose, либо New/Mark/Release, либо GetMem/FreeMem, но ни в коем случае не путать сочетание этих процедур.

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

{Программа указателя на массив, доступа к элементам массива}

Program Point1;

Uses Crt;

Type

massiv=array[1..10] of integer; {описание типа массива из 10 целых чисел}

Var

i:integer;

a:massiv; {массив из 10 целых чисел}

PtrMas:^massiv;{указатель на массив}

Begin

{ввод элементов массива}

Writeln('Введите элементы массива : ');

for i:=1 to 10 do

begin

Writeln(i,'-й элемент массива ');

Readln(a[i]);

end;

ClrScr;

Writeln('Введенный массив: ');
{вывод элементов введенного массива }

for i:=1 to 10 do

Write(' ',a[i]);

Writeln;

{Присвоить указателю PtrMas адрес начала размещения массива в памяти}

PtrMas:=@a;

Writeln('Значение первого элемента массива, на который указывает PtrMas: ');

{Напечатать значение первого элемента массива, на который указывает указатель PtrMas}

Writeln(PtrMas^[1]);

{Присвоить указателю PtrMas  адрес начала размещения второго элемента массива}

PtrMas:=@a[2];

Writeln(' Значение второго элемента массива, на который указывает указатель PtrMas: ');

{Напечатать значение первого элемента массива, на который указывает указатель PtrMas}

Writeln(PtrMas^[1]);

Writeln(' Значение 4-того элемента массива, на который указывает указатель PtrMas: ');

{Присвоить указателю PtrMas адрес 4-того элемента массива}

PtrMas:=Ptr(Seg(a[3]),Ofs(a[3])+SizeOf(integer));

{Ptr- преобразует базовый адрес сегмента и смещения в значение типа указатель}

{Напечатать значение 1 элемента массива, на который указывает указатель PtrMas}

Writeln(PtrMas^[1]);

Readkey;

end.

Порядок выполнения работы

1. 
   Изучить теоретические сведения по теме ” Разработка программы использования динамической памяти”.
   
2. 
   Получить у преподавателя индивидуальное задание и разработать программу для работы с динамической памятью и динамическими переменными согласно заданному варианту.
   
3. 
   Показать работающую программу преподавателю.
   
4. 
   Ответить на контрольные вопросы.
   

Контрольные вопросы

1. 
   Статические и динамические переменные.
   
2. 
   Указатели: типизированные, нетипизированные, Nil. Доступ к переменной по указателю.
   
3. 
   Процедуры и функции управления динамической памятью
   

Лабораторная работа № 33

Разработка программы создания связанного списка

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

Краткие теоретические сведения

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

Ч
аще всего указатели используются для ссылки на записи, тем самым достигается значительная экономия памяти. Если же сама запись содержит в себе поле-указатель, указывающий на следующую за ней запись, то это позволяет образовать связанные списки - структуру, в которой отдельные записи последовательно связаны друг с другом. В приведенном ниже примере используются записи, в которых наряду с данными об автомобиле имеется указатель на следующую запись, благодаря чему получается связанный список.
Одно из полей каждого объекта связанного списка имеет тип указатель и указывает на очередной объект в списке. Указатель на первый объект содержится в переменной First, а последний объект имеет указатель на Nil.

Пример программы создания и использования связанного списка

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

{Пример использования указателей для обработки связанного списка}

Program point;

Uses Crt;

Type

NameStr = String [20];

Link = ^Auto;

Auto = record

Name : NameStr; {Марка автомобиля}

Speed : real; {Скорость}

Next : Link; {Поле для связи со следующим объектом в списке}

end;

Var

Р,First : Link; {Указатели на запись: текущую, первую}

NamFind : NameStr; {Марка автомобиля для поиска}

V : 0..4; {Селектор меню}

EndMenu : boolean; {Окончание вывода меню}

{Поиск объекта с именем FN, по результатам поиска возвращает указатель на найденный объект или Nil, если объект не найден}

Function FindName(FN:NameStr) : Link;

Var

Curr : Link;

begin

Curr:=First; {Установить указатель на первом объекте в списке }

{Повторять пока не дойдем до конца списка}

while Curr <> Nil do

if Curr^.Name=FN then {Если нашли заданный объект}

begin

FindName:=Curr; {Возвращаем значение указателя на него}

Exit; {Завершаем функцию}

end

else

Curr:=Curr^ .Next; {Перейти к следующей записи}

FindName:=Nil; {В списке нет искомого объекта}

end; {Конец FindName}

{Добавление записи первой в связанный список}

procedure AddFirst(A:Link);

begin

A^. Next:=First; {Новый объект первый в списке}

First:=А; {Голова списка ссылается на новый объект}

end; {Конец AddFirst}

{Удаление первого объекта из списка}

procedure DelFirst(var A:Link);

begin

A:=First;

First:=First^. Next; {Теперь First указывает на тот объект, на который ранее ссылался объект А}

end; {Конец DelFirst}

{Удаление из списка объекта, стоящего после объекта Old}

procedure DelAfter(Old:Link; var A:Link);

begin

A:=Old^.Next; {Переменной А присваивается значение указателя на удаляемый объект}

Old^.Next:=Old^.Next^.Next; {Теперь Old указывает на тот объект, на который ранее ссылался следующий за ним объект, а объект А исключен из связанного списка}

end; {Конец DelAfter}

{Ввести данные об объекте}

procedure InpAvto;

begin

P:=New(Link); {Создать очередной объект типа Auto}

Write('Введите марку автомобиля :');

Readln(P^.Name) ;

Write('Максимальная скорость :');

Readln(Р^.Speed);

AddFirst(Р); {Вызов процедуры добавления записи, на которую ссылается указатель Р (Р- фактический параметр, А - формальный параметр-значение) }

end; {Конец InpAvto}

{Вывести на экран все объекты из связанного списка}

procedure MyList;

var

Curr : Link; {Локальная переменная - указатель на очередной объект}

begin

Curr:=First; {Установить указатель на первом объекте в списке}

{Повторять, пока не дойдем до конца списка}

while Curr <> Nil do

begin

Writeln( 'Марка : ' , Curr^. Name,' скорость : ', Curr^. Speed) ;

Curr:=Curr^.Next; {Перейти к очередному объекту связанного списка}

end ;

Write('Вывод списка окончен. Нажмите Enter');

Readln;

end; {Конец MyList}

Begin {Основная программа}

New(P); {Создать новую динамическую переменную и установить на нее переменную-указатель}

EndMenu:=False ;

repeat {Очищать экран и выводить меню до тех пор, пока EndMenu<>True}

CIrScr;

Writeln('Укажите вид работы:');

Writein('1. Запись первым в список');

Writeln('2. Удаление первого объекта из списка');

Writein('3. Просмотр всего списка') ;

Writein('4. Удаление объекта, следующего в списке за указанным') ;

Writein('0. Окончание работы');

Readin(V) ;

Case V of {Вызов разных процедур в зависимости от выбора пункта меню}

1 : InpAvto; {Ввод данных об объекте}

2 : DelFirst(P); {Удаление первого в списке}

3 : MyList; {Вывод списка всех элементов связанного списка}

4 : begin {Удаление объекта, следующего за указанным}

Write('Введите марку автомобиля, за которым следует удаляемый из списка :');

Readln(NamFind) ;

DelAfter(FindHame(NamFind),P); {Вызов процедуры

DelAfter с параметрами: функцией FindName(NamFind) и указателем Р}

end

else

EndMenu:=True; {Завершить вывод меню}

end;

until EndMenu; {Если EndMenu=True, то завершить вывод меню на экран}

Dispose(Р); {Уничтожить динамическую переменную Р и освободить память в куче}

end.

Порядок выполнения работы

1. 
   Изучить теоретические сведения по теме ” Разработка программы создания связанного списка”.
   
2. 
   Получить у преподавателя индивидуальное задание и разработать программу для работы со связанным списком согласно заданному варианту.
   
3. 
   Показать работающую программу преподавателю.
   
4. 
   Ответить на контрольные вопросы.
   

Контрольные вопросы

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

Лабораторная работа № 34

Разработка программы для работы с процедурным типом

Цель работы: формирование знаний и умений по работе с процедурным типом данных.

Краткие теоретические сведения

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

Нетипизированные параметры - это группа параметров, перед которыми стоит ключевое слово Var и за которым не следует тип. Фактическими параметрами в операторе вызова процедуры в данном случае могут быть переменные любого типа.

Поскольку у нетипизированных параметрах тип отсутствует, то изначально они совместимы с переменными всех типов.

Обеспечение совместимости с фактическими параметрами может быть достигнуто двумя способами.

Способ 1: внутри процедуры объявляется локальная переменная нужного типа, наложенная на переданный фактический параметр. Для описания такой переменной используется зарезервированное слово Absolute.

Пример 1.

program Primer1;

Var {Обьявление глобальных переменных}

x1,x2,y1,y2,z1,z2: real;

{процедура возведения в степень}

procedure stepen (x,y : real; var s); {x, y – параметры значения}

var ss: real absolute s; {s- параметр без типа, ss наложенная на s – локальная переменная типа real}

begin

ss:=exp(y*ln(x));

end; {конец процедуры stepen}

begin{основная программа}

writeln(‘Введите значение переменных в последовательности: x1 y1 x2 y2’ );

readln (x1, y1, x2, y2); {Чтение исходных данных}

stepen (x1, y1, z1); {Первый оператор вызова процедуры stepen}

stepen(x2, y2, z2); {Второй оператор вызова процедуры stepen}

z1:= z2+z1; {Формироваие результата}

writeln(z1); {печать результата}

end.

Способ 2: внутри процедуры вводится нужный тип. Данный тип ставится в соответствие нетипизированному параметру с помощью присваивания типа переменной.

Пример 2. В программе функция Sum выдает сумму двух вещественных переменных при N=Ø, и сумму двух одномерных массивов при N<>Ø.

program Primer2;

var

ind: integer;

m1,m2: array [1..5] of integer ; {описание массивов m1 m2}

x1,x2:real;

{функция вычисления суммы}

function sum(n: integer ; var y1,y2): real;

Type

mas = array [1..MaxInt] of integer;

Var

i: integer;

s: real;

begin

if n=Ø then sum:= real(y1)+real(y2);

else

begin

s:=Ø;

for i:=1 to n do

s:= s + mas(y1)[i]+mas(y2)[i];

sum:=s;

end;

end; {конец функции sum}

Begin {основная программа}

for ind:= 1 to 5 do

real(m1[i], m2[i] ); {заполнение массивов данными}

writeln(‘Введите 2 вещественных числа: ’)

read(x1,x2);

writeln(’x1 + x2’, sum(Ø,x1,x2)); {вызов в операторе writeln функции sum-для суммирования вещественных чисел x1 и x2 (n=0)}

writeln(’Массивы’, sum (5,m1, m2)); {вызов в операторе writeln функции sum-для суммирования массивов m1 и m2 (n=5<>0)}

end.

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

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

Например:

Type

Func = function(x,y:byte):byte;

Proc = procedure(var x,e:byte);

var

P1 : Proc; F1: Func;

При этом должны совпадать число параметров и соответственно типы параметров. Всем процедуры и функции, имена которых присваиваются процедурным переменным, необходимо компилировать в режиме {$F+}.

Описание процедурных типов вводится в разделе Type. Синтаксис описания совпадает с заголовком процедуры, однако имя процедуры в описании опускается.

Имена параметров в описании процедурного типа играет чисто иллюстративную роль. Никакого влияния на значение этого описания данные имена не оказывают.

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

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

1. 
   Она должна компилироваться в состоянии {$F+} (в исходном тексте программы перед описанием такой процедуры должна быть размещена директива компилятора {$F+}, а в конце описания {$F-})
   
2. 
   Она не должна быть стандартной процедурой или функцией.
   
3. 
   Она не должна быть вложенной.
   
4. 
   Она не должна быть процедурой типа inline.
   
5. 
   Она не должна быть процедурой прерывания (interrupt).
   

Пример 3.

Program Primer3;

Type

Func=function(x,y:anteger):integer;

{$F+}

Function Add(a,b:integer):integer;

Begin

Add:=a+b;

end;

Function Multiplay(a,b:int):int;

Begin

Multiplay:=a+b;

end;

Function Div(a,b:int):int;

Begin

Div:=a/b;

end;

{$F-}

Procedure RAB(n,m:integer;Operation:Func); {Operation-параметр процедурного типа}

Var

i,j:integer;

Begin

for i:=1 to n do

for j:=1 to m do

write(operation (i,j):5);

end;

Begin {основная программа}

RAB(10,10,Add); {вызов процедуры RAB с последним параметром- процедурой Add}

RAB(20,10,Multiplay); ); {вызов процедуры RAB с последним параметром- процедурой Multiplay}

RAB(10,5,Div); ); {вызов процедуры RAB с последним параметром- процедурой Div}

End.

Порядок выполнения работы

1. 
   Изучить теоретические сведения по теме “ Разработка программы для работы с процедурным типом”.
   
2. 
   Получить у преподавателя индивидуальное задание и разработать программу для работы с процедурными типами данных согласно заданному варианту.
   
3. 
   Показать работающую программу преподавателю.
   
4. 
   Ответить на контрольные вопросы.
   

Контрольные вопросы

1. 
   Нетипизированный параметр. Способы присвоения конкретного типа нетипизированному параметру.
   
2. 
   Назначение процедурной переменной, объявление.
   
3. 
   Обеспечение совместимости процедуры, если её нужно присвоить процедурной переменной.
   

Литература

1. 
   Гусева А. И. Учимся программировать: Pascal 7.0. - М.: Бином, 1999.
   
2. 
   Сурков Д.А., и др. Программирование в среде Borland Pascal для Windows.-Мн.: “Вышэйшая школа”, 1996.
   
3. 
   Грызлов В.И. и др. Pascal 7.0.- Киев, BHV, 1999.
   
4. 
   Вирт Н. Алгоритмы и структуры данных –М.: “Мир”, 1989
   

Содержание

Литература…………………………………………………………………………166