Program ex;

Type pTObj=^TObj; {объявление указателя на объект}

TObj=Object {определение объекта}

pole:real; {статическое поле}

procedure Print; {статическая процедура печати}

constructor Init(p:real); {конструктор}

end;

Procedure TObj.Print;

Begin WriteLn('Значение поля = ',pole); end;

Constructor TObj.Init(p:real);

Begin pole:=p; end;

Var p:pTObj; {объявление переменной типа «указатель на объект» }

Begin New(p,Init(5)); {выделение памяти и инициализация поля}

p^.Print;

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

End.

Пример 8. Динамический объект с динамическим полем и деструктором.

Program ex;

Type pTObj=^TObj;

TObj=Object

pPole:^real; {динамическое поле}

procedure Print;

constructor Init(p:real); {конструктор}

destructor Done; {деструктор}

end;

Procedure TObj.Print;

Begin WriteLn('Значение поля = ',pPole^); end;

Constructor TObj.Init(p:real);

Begin New(pPole); {выделение памяти под дин. поле}

pPole^:=p;

end;

Destructor TObj.Done;

Begin Dispose(pPole); {освобождение памяти}

end;

Var p:pTObj;

Begin New(p,Init(5));

p^.Print;

Dispose(p,Done);

End.

При работе с динамическими объектами желательно выполнять контроль распределения памяти из кучи. Отсутствие такого контроля может при недостатке памяти привести к ошибке распределения памяти и нарушению работы ЭВМ.

Организация перехвата управления при выполнении контроля требует замены встроенной функции управления обработкой ошибок распределения памяти из кучи (см. Help). Замена выполняется таким образом, что при отсутствии необходимого количества памяти процедура или функция New возвращает nil вместо адреса. Если памяти не хватает для размещения динамических полей, то, мы получим nil вместо адреса поля. В конструкторе в этом случае можно указать специальную директиву fail, выполнение которой приводит к тому, что распределение памяти под объект и предыдущие динамические поля аннулируется, и указатель на объект становится равным nil.

Пример 9. Динамический объект с динамическим полем и контролем выделяемой памяти.

Program ex;

Type pTObj=^TObj;

TObj=Object

pPole:^real;

procedure Print;

constructor Init(p:real);

destructor Done;

end;

Procedure TObj.Print;

Begin WriteLn('Значение поля = ',pPole^); end;

Constructor TObj.Init(p:real);

Begin New(pPole); {выделение памяти под дин. поле}

if pPole=nil then {если не хватает памяти}

begin Done; {то выполнить деструктор}

fail; {и аннулировать распределение памяти}

end;

pPole^:=p; {иначе - занести информацию в поле}

end;

Destructor TObj.Done;

Begin if pPole<>nil then {если память распределена,}

Dispose(pPole); {то освободить память}

end;

{процедура управления обработкой ошибок при выделении памяти}

{$F+}

Function HeapFunc(size:Word):integer;

Begin HeapFunc:=1; end;

{$F-}

Var p:pTObj;

Begin HeapError:=@HeapFunc; {замена процедуры}

New(p,Init(5));

if p=nil then {если не хватает памяти}

begin WriteLn('Не хватает памяти в куче.');

Halt(2);

end;

p^.Print;

Dispose(p,Done);

End.

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

Пример 10. Статический объект с динамическим полем и контролем распределения памяти в куче.

Program ex;

Type TObj=Object

pPole:^real;

procedure Print;

constructor Init(p:real);

destructor Done;

end;

Procedure TObj.Print;

Begin WriteLn('Значение поля = ',pPole^); end;

Constructor TObj.Init(p:real);

Begin New(pPole);

if pPole=nil then

begin Done;fail;end;

pPole^:=p;

end;

Destructor TObj.Done;

Begin if pPole<>nil then Dispose(pPole); end;

{$F+}

Function HeapFunc(size:Word):integer;

Begin HeapFunc:=1; end;

{$F-}

Var A:TObj;

Begin HeapError:=@HeapFunc;

if not A.Init(5) then {проверка выполнения конструктора}

begin WriteLn('Не хватает памяти в куче.');

Halt(1);

end;

A.Print;

A.Done; {освобождения памяти дин. полей}

End.

1.8 . Ограничение доступа к полям и методам объектов.

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

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

Unit <>;

Interface

Type <имя объекта>=Object

<доступные поля>

<доступные методы>

Private

<закрытые поля>

<закрытые методы>

end;

Implementation ....

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

Контрольные вопросы к Главе 1.

1. В чем заключается основная концепция объектно-ориентированного программирования?

2. Какие языки программирования считаются объектно-ориентированными?

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

4. Что такое объект? Чем он отличается от записи и других структурных типов данных?

5. Как объявляется переменная типа объекта?

6. Как осуществляется доступ к полям и методам? Что собой представляет параметр Self?

7. Как описать объект-потомок?

8. Что такое конструктор и деструктор объекта? Когда они обязательны?

9. Дайте определение полиморфного метода? Как его описать?

10. Дайте определение виртуального метода? Когда необходимо использовать виртуальные методы?

2 Использование технологии ООП.

2.1. Использование объектов при создании новых структур данных.

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

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

Объект «Список» включает поля и методы, позволяющие работать со структурой «Двунаправленный список» (см. Рис. 2.1), состоящий из объектов «Элемент». Объект «Элемент» содержит только те поля и методы, которые необходимы для организации цепочки. Предполагается, что реальная программа опишет объект-потомок, который будет содержать необходимые информационные поля.

Рис. 2.1. Структура данных «Двунаправленный список».

Объект «Список» включает методы, которые реализуют добавление элементов, извлечение элементов и процедуру, позволяющую выполнить поэлементную обработку списка, причем имя конкретной процедуры обработки элемента передается в списке параметров.

Пример 11. Описание объекта «Список» и встроенного объекта «Элемент списка».

Unit spisok;

Interface

Type pElement=^TElement; {указатель на объект-элемент}

tproc=procedure(e:pElement); {процедурный тип}

TElement=Object {объект-элемент списка}

pre,suc:pElement; {адрес предыдущего и последующего}

procedure Print;virtual; {печать элемента}

constructor Init;

end;

TSpisok=Object

first, last, {адрес первого и последнего элемента}

cur:pElement; {адрес текущего элемента}

procedure Add(e:pElement); {добавление в начало}

function Del:pointer; {извлечение последнего}

procedure ForEach(proc:tproc); {выполнить для каждого}

constructor Init;

end;

Implementation

Constructor TElement.Init;

Begin End;

Procedure TElement.Print;

Begin End;

Constructor TSpisok.Init;

Begin first:=nil; last:=nil; cur:=nil; End;

Procedure TSpisok.Add;

Begin

if first=nil then {если элемент первый}

begin first:=e;

last:=e;

e^.suc:=nil;

e^.pre:=nil;

end

else begin e^.suc:=first; {если элемент не первый}

first^.pre:=e;

e^.pre:=nil;

first:=e;

end;

End;

Function TSpisok.Del;

Begin Del:=last;

if last<>nil then {если список не пуст}

begin last:=last^.pre;

last^.suc:=nil;

end;

if last=nil then first:=nil; {если список стал пуст}

End;

Procedure TSpisok.ForEach;

Var next:pElement;

Begin next:=first; {первый элемент}

while next<>nil do {пока не конец списка}

begin proc(next); {выполнить заданную процедуру}

next:=next^.suc {перейти к следующему}

end;

End;

End.

Для тестирования данного модуля используется программа, которая работает со списком целых чисел. Она наследует объекту «Элемент», добавляя информационное поле целого типа, и содержит процедуру, которая должна быть выполнена для каждого элемента списка.

Пример 12. Программа, тестирующая работу объекта «Список».

Program test;

Uses Spisok;

Type pnum=^TNum; {указатель на объект «Число» }

TNum=Object(TElement) {наследуем от объекта «Элемент» }

num:integer; {добавляет информационное поле}

procedure Print;virtual; {печать поля}

constructor Init(n:integer);

end;

Constructor TNum.Init;

Begin num:=n; End;

Procedure TNum.Print;

Begin Write(num:3); end;

{$F+}

Procedure Show(e:pElement); {программа обработки каждого}

Begin e^.Print;end;

{$F-}

{****************Объявление переменных ***************}

Var N:TSpisok; k:integer;p:pNum;

Begin N.Init;

WriteLn('Введите число');

repeat New(p);

ReadLn(k);

p^.Init(k);

N.Add(p);

WriteLn('Введите число');

until eof;

WriteLn('Вывод чисел в обратном порядке');

N.ForEach(Show);

WriteLn;

WriteLn('Вывод чисел в прямом порядке');

while N.first<>nil do

begin p:=N.Del;

p^.Print;

Dispose(p);

end;

WriteLn;

End.

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

2.2. Использование объектов при создании меню.

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

В качестве примера возьмем программу «Записная книжка». Предполагается, что она должна осуществлять: создание новой книжки (файла), добавление записей (фамилии и телефона), поиск записей по фамилии.

Создание библиотеки объектов для этой программы начнем с анализа оконных форм программы.

В начале работы программы на экране должно появляться главное меню системы (см. Рис. 2.2).

Рис. 2.2. Окно «Главное меню».

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