Методичка С++ (OBJECTS)

Посмотреть архив целиком

26




Московский государственный технический университет им. Н.Э. Баумана



Г. С. Иванова, Т.Н. Ничушкина, Е.К. Пугачев





ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ В СРЕДЕ BORLAND PASCAL 7.0


Учебное пособие

по курсу “Алгоритмические языки и программирование”


Под редакцией Г.С. Ивановой










МОСКВА 1997

Аннотация.

Учебное пособие предназначено для студентов 1 курса кафедры ИУ6, изучающих программирование в среде Borland Pascal 7.0.

Предлагаемый материал разбит на две части.

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

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

Введение.

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

Попытаемся дать определения указанным понятиям.

Абстракция - использование обобщенных представлений данных и процедурных частей программы. До появления концепции ООП языки программирования, как правило, поддерживали невысокий уровень абстракции (на уровне описания простейших абстрактных структур данных, таких как массив или запись, и использования подпрограмм в качестве абстрактных операций, которые использовались при разработке программ). Уровень абстракции современных языков программирования существенно вырос. В частности Borland Pascal (начиная с версии 5.5) и С++ позволяют создавать сложнейшие структуры данных и практически полностью абстрагироваться от деталей их реализации, оперируя с ними как некоторыми объектами, правила поведения которых также описаны внутри структуры.

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

Наследование - создание более сложных объектов из более простых посредством добавления параметров и определения новых свойств, что позволяет повторно не определять уже описанные параметры и свойства объектов, которые новый объект “наследует”.

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

Язык Borland Pascal поддерживает эти свойства наряду со средствами процедурного, структурного и модульного программирования, которыми обладали предыдущие версии языка.

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

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

Средства объектно-ориентированного программирования.

. Определение объекта. Компоненты: поля и методы.

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

Type

<имя объектного типа> = Object

<описание полей объекта>

<заголовки методов объекта>

end;

Например:

Type TRoom=Object

length,wight:real;

Function Square:real;

end;

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

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

Например:

Function TRoom.Square;

Begin Square:=length*wight; end;

. Определение экземпляров объектов. Операция присваивания над объектами. Обращение к компонентам объекта из программы и методов. Неявный параметр Self.

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

Например:

Var A,B:TRoom; {экземпляры объекта}

pS:^TRoom; { указатель на объект}

C:array[1..10] of TRoom; { массив объектов}

Для экземпляров одного объекта разрешена операция присваивания, при этом выполняется копирование полей одного экземпляра объекта в другой, например: a:=b; {поля a копируются в b}

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

а) Ss:=A.Square; {вызов функции-метода объекта TRoom}

б) ReadLn(A.length); {обращение к полю объекта}

в) with A do begin ReadLn(length); Ss:=Square; end; { использование оператора with }

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

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

Self.length Self.wight

В некоторых случаях параметр Self используется внутри методов явно.

Пример 1. Использование параметра Self.

{ Программа определения части адреса - смещения экземпляра объекта в памяти}

Program ex;

Type TRoom=Object

length:real;

wight:real;

Function getAddr:Word;

end;

Function TRoom.getAddr;

Begin

getAddr:=ofs(Self); {в данном случае без Self обойтись нельзя}

end;

Var a:Troom;

Begin writeln('Смещение = ',a.getAddr); end.

. Инициализация полей объектов.

Для записи исходной информации в поля объекта можно использовать три способа:

а) занести необходимую информацию, используя оператор присваивания в основной программе;

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

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

Продемонстрируем вышесказанное на примере.

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

{ Программа определения суммарной площади заданных комнат. Вариант 1.}

Program ex;

Type TRoom=Object

length, wight:real;

function square:real;

end;

function TRoom.square:real;

begin

square:=length*wight;

end;

Var l,w,s:real;

n,i:integer;

rooms:array[1..10] of TRoom;

Begin

writeln('Введите количество комнат не более 10:');

readln(n);

s:=0;

for i:=1 to n do

Begin writeln('Введите параметры ',i,'-ой комнаты:');

readln(l,w);

rooms[i].length:=l; {присвоение значения полю объекта}

rooms[i].wight:=w; {присвоение значения полю объекта}

s:=s+rooms[i].square;

end;

writeln('Площадь=',s:8:2);

end.

Пример 3. Инициализация полей объекта специальным методом.

{ Программа определения суммарной площади заданных комнат. Вариант 2.}

program ex;

Type TRoom=Object

length:real;

wight:real;

function square:real;

procedure Create(l,w:real);

end;

function TRoom.square:real;

begin

square:=length*wight;

end;

procedure TRoom.Create;{метод, инициализирующий поля объекта}

begin length:=l;

wight:=w;

end;

Var l,w,s:real;

n,i:integer;

rooms:array[1..10] of TRoom;

Begin

writeln('Введите количество комнат не более 10:');

readln(n);

s:=0;

for i:=1 to n do

Begin writeln('Введите параметры ',i,'-ой комнаты:');

readln(l,w);

rooms[i].Create(l,w); {вызов метода}

s:=s+rooms[i].square;

end;

writeln('Площадь=',s:8:2);

end.

Пример 4. Использование типизированных констант (аналог записи) для инициализации полей объекта.

{ Программа определения суммарной площади заданных комнат. Вариант 3.}

program ex;

Type TRoom=Object

length:real;

wight:real;

function square:real;

end;

function TRoom.square:real;

begin

square:=length*wight;

end;

Var l,w,s:real;

n,i:integer;

Const rooms:array[1..3] of TRoom=((length:2.5;wight:3.2),

(length:4.15;wight:2.2),

(length:3.1;wight:3.6));

Begin

s:=0;

for i:=1 to 3 do

begin s:=s+rooms[i].square; end;

writeln('Площадь=',s:8:2);

end.

. Наследование.

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

По правилам Borland Pascal у объекта может быть только один родитель, но сколько угодно потомков. Таким образом, механизм наследования обеспечивает создание дерева родственных объектов. Дерево может иметь несколько уровней и ветвей, где на каждом уровне добавляются необходимые поля и методы.

Определение объекта-потомка выполняется следующим образом:

Type <имя объекта-потомка>=Object(<имя объекта-родителя>)

<дополнительные поля данных>

<дополнительные методы>

end;

Например:

Type TName=Object {объект-родитель}

family,name:string[22];

procedure Print;

end;

TPerson=Object(TName) {объект-потомок}

adress:string[20];

procedure Print_All;

end;

Наследование - мощнейший аппарат ООП, позволяющий создавать библиотеки объектов по принципу от простого к сложному!

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

Например:

Var a:TName; b:TPenson;

... a:=b; {разрешено}

b:=a; {недопустимо}

. Полиморфизм.

Объект-потомок может не только дополнять свои методы к методам объекта-родителя, но и заменять методы объекта родителя на свои. При этом объект-потомок содержит объявление метода, имя которого совпадает с родительским.

Примечание. Заменить поле объекта-родителя нельзя.

Пример 5. Наследование. Полиморфизм. Раннее связывание.

{Программа печати имени, фамилии и телефона.}

Type TName=Object {объект-родитель}

family,name:string[22];

procedure Print;

end;

Procedure TName.Print; {процедура печати объекта-родителя}

Begin WriteLn(family,' ',name) end;

Type TPerson=Object(TName) {объект-потомок}

fon:string[7];

procedure Print;

end;

Procedure TPerson.Print; {процедура печати объекта-потомка}

Begin WriteLn(family,' ',name,' ',fon) end;

Const A:TName=(family:'Петров';name:'Петр');

B:TPerson=(family:'Иванов';name:'Иван';fon:'1111111');

Begin

A.Print;

B.Print;

end.

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

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

Например, в примере, приведенном выше, метод TPerson.Print можно было бы описать так:

Procedure TPerson.Print; {процедура печати объекта-потомка}

Begin TName.Print; {обращение к методу объекта-родителя}

WriteLn(fon)

End;

. Раннее и позднее связывание. Виртуальные методы. Конструкторы. Определение типа объекта.

В приведенном выше примере связь объекта с методом выполняется (как принято обычно в Borland Pascal) в процессе компиляции и называется ранним связыванием. Соответствующие методы носят название статических.

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

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

Поясним сказанное на таком примере.

Допустим, что у нас объект-родитель содержит метод Out, который в процессе выполнения вызывает метод Print. Объект-потомок - наследует метод Out, но имеет свой метод Print (см. Рис.1.1). Если метод Print - статический, то метод Out вне зависимости от типа объекта, для которого он вызван, будет вызывать метод Print объекта-родителя (на этапе компиляции эта связь установлена раз и навсегда).

Рис. 1.1. Пример позднего связывания.

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

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

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

Конструктор по форме отличается от обычных методов только тем, что вместо слова Procedure при его описании используется слово Constructor (кроме этого, принято называть его Init, но это не обязательно). До вызова конструктора нельзя использовать виртуальные методы объекта (это приводит к нарушению адресации и может потребовать перезагрузки машины). Обычно тело конструктора используется для инициализации полей объекта, но оно может и не содержать выполняемых операторов.

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

Иерархия объектов для решения данной задачи приведена на Рис.1.2, а структура полей объектов на Рис.1.3.

Рис.1.2. Иерархия объектов.


Рис. 1.3. Структура полей объектов.

Пример 6. Позднее связывание. Виртуальные методы.

{ Программа определения стоимости комнаты или квартиры.}

Program flat_r;

Type

RRoom=record length, wight:real; end;

TSpace=Object {абстрактный объект - помещение}

cost:real; {стоимость метра площади}

function Square:real;virtual; {площадь помещения}

function Price:real; {стоимость квартиры}

end;

TRoom=Object(TSpace) {объект - комната}

length, wight:real; {размеры комнаты}

function Square:real;virtual; {площадь комнаты}

constructor Init(c,l,w:real);

end;

TFlat=Object(TSpace) {объект - квартира}

n:integer; {количество комнат}

rooms:array[1..10] of TRoom; {массив объектов «комната»}

function Square:real;virtual; {площадь квартиры}

constructor Init(nn:integer; c:real; Var mas);

end;

Function TSpace.Price:real; {функция определения стоимости}

Begin price:=cost*Square; End;

Function TSpace.Square:real; {функция определения площади}

Begin Square:=0; End;

Function TRoom.Square:real; {функция определения площади}

Begin Square:=length*wight; End;

Constructor TRoom.Init(c,l,w:real);

Begin cost:=c;

length:=l;

wight:=w;

End;

Function TFlat.Square:real; {функция определения площади}

Var i:integer; s:real;

Begin s:=0;

for i:=1 to n do s:=s+rooms[i].square;

square:=s;

End;

Constructor TFlat.Init(nn:integer;c:real;Var mas);

Var i:integer;

m:array[1..10] of RRoom absolute mas;

Begin n:=nn;

cost:=c;

for i:=1 to n do

rooms[i].Init(0,m[i].length,m[i].wight);

End;

Const mr:array[1..3] of RRoom=((length:3;wight:3),

(length:4;wight:4),

(length:3;wight:5));

Var A:TRoom; B:TFlat;

Begin A.Init(50,5,6);

B.Init(3,60,mr);

WriteLn(A.price);

WriteLn(B.price);

End.

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

При определении того, какой (статический или виртуальный) метод использовать при решении задачи следует иметь в виду, что:

  1. виртуальные методы занимают больше памяти (из-за ТВМ);

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

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

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

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

При необходимости программист может определить тип объекта, с которым в настоящий момент времени работает виртуальный метод. Для этого используется стандартная функция Паскаля TypeOf(TObj), которая для объектов возвращает адрес ТВМ. Сравнив этот адрес с адресом интересующего нас типа, мы определим тип объекта, с которым работает метод:

if TypeOf(Self)=TypeOf(TA) then ...

. Динамические объекты. Деструкторы.

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

Процедура: New(<указатель на объект>[,<имя конструктора>]);

Функция:

<указатель на объект>:= New(<тип объекта>[,<имя конструктора>])

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

Для освобождения памяти при уничтожении динамического экземпляра объекта используется процедура

Dispose(<указатель на объект>,[<имя деструктора>]);

Деструктор - это специальная процедура, при описании которой служебное слово Procedure заменяется служебным словом Destructor (так же как и для конструктора, для деструктора существует рекомендованное имя - Done). Деструктор используется для определения действий, которые необходимо выполнить перед уничтожением объекта. Если динамический объект использует виртуальные методы, то использование деструктора обязательно. Обычно деструктор определяет действия по освобождению памяти, распределенной для размещения динамических полей, как статических, так и динамических объектов, но может и не содержать выполняемых операторов.

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

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.

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

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

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

Unit <>;

Interface

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

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

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

Private

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

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

end;

Implementation ....

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Объект «Список» включает поля и методы, позволяющие работать со структурой «Двунаправленный список» (см. Рис. 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.3), причем до ввода имени файла выбор прочих пунктов меню, кроме «Завершения работы» должен быть блокирован. После ввода имени файла, которое должно быть проверено с точки зрения синтаксиса имен файлов, мы должны вернуться в главное меню.

Рис. 2.3. Окно ввода имени файла.

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

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

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



Рис. 2.4. Форма ввода записей. Рис. 2.5. Форма поиска записей.

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

Рис. 2.6. Иерархия объектов для создания меню.

Основное окно иерархии - окно со строкой текста Twin (см. Рис.2.7а). От этого объекта наследуются остальные. Кроме того, он многократно входит в окна иерархии, позволяя создавать нужные формы. В объектах-потомках строка текста становится заголовком окна или полем ввода в зависимости от вида использования. Объект включает поля, определяющие параметры окна на экране и параметры текста в окне. Метод Draw используется для отображения окна на экране, а метод SetAttr - для изменения цвета фона и цвета символов.

TInput - пассивное окно ввода (см. Рис. 2.7 б), которое закрывается, если требуемая информация введена правильно (Error - метод проверки ввода). Ввод информации осуществляется на место текста во внутреннем окне Inp (метод Input). Объект также содержит процедуру очистки поля ввода Clear.

TMessage - активное окно сообщения (см. Рис. 2.7 в), ожидающее нажатия любой клавиши (метод Run). Внутреннее окно - кнопка Ok. Метод Show используется для отображения окна на экране (без очистки экрана). Метод Enter- пустой.

TMenu - также активное окно, которое требует выбора нужного пункта меню (см. Рис. 2.8 г). Само меню может содержать не более 10 пунктов и задается специальным массивом окон masalt типа Twin. Конкретное количество пунктов определяется nalt, а текущий номер пункта хранится в npos. Метод Show используется для отображения окна на экране (со стиранием предыдущей картинки), метод Run реализует выбор пункта, а метод Enter (заменяемый) осуществляет обработку выбора пункта меню (при нажатии клавиши Enter).

TForm - активное окно - форма, содержащая настраиваемые поля ввода masinp типа TInput (не более 10), количество которых указано в ninput, и меню, наследуемое от TMenu (см. Рис. 2.7 д). Объект имеет собственные методы Show и Enter и содержит методы, выполняющие операции ввода - Input и очистку полей ввода - Clear.

Риc. 2. 7. Библиотечные оконные формы.

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

Пример 13. Библиотека объектов для создания меню программы "Записная книжка".

Unit Menu;

Interface

Uses crt;

Type str80=string[80];

{ ************* Окно с текстом ***********************}

TWin=Object

x1,y1,x2,y2:integer; {координаты окна}

attr:integer; {атрибут}

xt,yt:integer; {начало текста}

text:str80; {строка текста}

constructor Init(ax1,ay1,ax2,ay2,aattr,axt,ayt:integer;atext:str80);

procedure SetAttr(aattr:integer); {изменение цвета и фона окна}

procedure Draw; {рисование окна на экране}

end;

{ ************* Окно ввода **********************}

Type TInput=Object(TWin)

Inp:TWin; {окно ввода}

constructor Init(ax1,ay1,ax2,ay2,aattr,axt,ayt:integer;atext:str80;

bx1,by1,bx2,by2,battr,bxt,byt:integer;btext:str80);

procedure Clear; {очистка поля ввода}

procedure Input; {ввод строки из окна}

function Error:boolean;virtual; {проверка введенной информ.}

procedure Draw;virtual; {рисование окна}

end;

{ *************** Окно сообщения *****************}

Type TMessage=Object(TWin)

Ok:TWin; {кнопка}

procedure Enter;virtual; {при нажатии на Enter ...}

procedure Run;virtual; {процедура выбора из меню}

procedure Show;virtual; {показать окно (наложить)}

constructor Init(ax1,ay1,ax2,ay2,aattr,axt,ayt:integer;atext:str80;

bx1,by1,bx2,by2,battr,bxt,byt:integer;btext:str80);

end;

{ ***************** Окно меню ********************}

Type TMenu=Object(TMessage)

nalt:integer; {количество альтернатив в меню}

masalt:array[1..10] of TWin; {массив альтернатив меню}

npos:integer; {номер выбранной альтернативы}

procedure Show;virtual; {показать окно (наложить)}

procedure Enter;virtual; {при нажатии на Enter ...}

procedure Run;virtual; {процедура выбора из меню}

constructor Init(ax1,ay1,ax2,ay2,aattr,

axt,ayt:integer;atext:str80;n:integer;Var p);

end;

{ ****************** Окно формы *******************}

Type TForm=Object(TMenu)

ninput:integer; {количество полей ввода}

masinp:array[1..10] of TInput; {массив полей ввода}

procedure Enter;virtual; {при нажатии на Enter ...}

procedure Show;virtual; {показать окно (наложить)}

procedure Clear; {очистка окон ввода}

procedure Input; {ввод информации из окон ввода}

constructor Init(ax1,ay1,ax2,ay2,aattr,axt,ayt:integer;atext:str80;

n:integer;Var p1;k:integer;Var p2);

end;

Implementation {Реализация методов}

{ ************* Окно с текстом ***********************}

Constructor TWin.Init;

Begin x1:=ax1; y1:=ay1;

x2:=ax2; y2:=ay2;

attr:=aattr;

xt:=axt; yt:=ayt;

text:=atext;

End;


Procedure TWin.Draw;

Begin Window(x1,y1,x2,y2);

TextBackGround(attr div 16);

TextColor(attr mod 16);

Clrscr;

Gotoxy(xt,yt);

Write(text);

end;


Procedure TWin.setattr;

Begin attr:=aattr;

Draw;

end;

{ ************* Окно ввода **********************}

Constructor TInput.Init;

Begin TWin.Init(ax1,ay1,ax2,ay2,aattr,axt,ayt,atext);

Inp.Init(bx1,by1,bx2,by2,battr,bxt,byt,'');

end;


Procedure TInput.Clear;

begin Inp.text:='';

Inp.Draw;

End;


Procedure TInput.Input;

Begin Window(Inp.x1,Inp.y1,Inp.x2,Inp.y2);

TextBackGround(Inp.attr div 16);

TextColor(Inp.attr mod 16);

repeat

Gotoxy(Inp.xt,Inp.yt);

Clear;

Readln(Inp.text);

Gotoxy(Inp.xt,Inp.yt);

Write(Inp.text);

until not Error;

end;


Function TInput.Error:boolean;

begin Error:=false; end;


Procedure TInput.Draw;

Begin TWin.Draw;

Inp.Draw;

End;

{ *************** Окно сообщения *****************}

Constructor TMessage.Init;

Begin TWin.Init(ax1,ay1,ax2,ay2,aattr,axt,ayt,atext);

Ok.Init(bx1,by1,bx2,by2,battr,bxt,byt,btext);

End;


Procedure TMessage.Run;

Var ch1,ch2:char;

temp:integer;

Begin Ok.setattr(91);

ch1:=readkey;

Enter;

End;


Procedure TMessage.Enter;

Begin end;


Procedure TMessage.Show;

Begin

TWin.Draw;

Ok.Draw

end;

{ ***************** Окно меню ********************}

Constructor TMenu.Init;

Var w:array[1..10] of TWin absolute p;

i:integer;

Begin TWin.Init(ax1,ay1,ax2,ay2,aattr,axt,ayt,atext);

nalt:=n;

for i:=1 to nalt do

masalt[i].Init(w[i].x1,w[i].y1,w[i].x2,w[i].y2,

w[i].attr,w[i].xt,w[i].yt,w[i].text);

End;


Procedure TMenu.Show;

Var i:integer;

Begin Window(1,1,80,25); { очищаем экран}

TextBackGround(0);

TextColor(1);

Clrscr;

TWin.Draw;

for i:=1 to nalt do masalt[i].Draw;

End;


Procedure TMenu.Run;

Var ch1,ch2:char;

temp:integer;

Begin npos:=nalt;

repeat

masalt[npos].Setattr(71);

ch1:=Readkey; {читаем код клавиши}

if ch1=#0 then ch2:=Readkey;

case ch1 of

#0:case ch2 of

#75:begin temp:=npos-1; {влево}

if temp=0 then temp:=nalt; {закольцовываем}

masalt[npos].Setattr(113); {убрать выделение}

masalt[temp].Setattr(71); {выделить пункт}

npos:=temp;

end;

#77:begin temp:=npos+1; {вправо}

if temp=nalt+1 then temp:=1; {закольцовываем}

masalt[npos].Setattr(113); {убрать выделение}

masalt[temp].Setattr(71); {выделить пункт}

npos:=temp;

end;

end;

#13:Enter; {Enter}

end

until((npos=nalt)and(ch1=#13))or(ch1=#27);

Window(1,1,80,25); {возвращаем стандартный режим}

TextBackGround(0);

TextColor(7);

Clrscr;

End;


Procedure TMenu.Enter;

Begin end;

{ ****************** Окно формы *******************}

Constructor TForm.Init;

Var w1:array[1..10] of TWin absolute p1;

w2:array[1..10] of TInput absolute p2;

i:integer;

Begin TWin.Init(ax1,ay1,ax2,ay2,aattr,axt,ayt,atext);

nalt:=n;

ninput:=k;

for i:=1 to nalt do

masalt[i].Init(w1[i].x1,w1[i].y1,w1[i].x2,w1[i].y2,

w1[i].attr,w1[i].xt,w1[i].yt,w1[i].text);

for i:=1 to ninput do

masinp[i].Init(w2[i].x1,w2[i].y1, w2[i].x2,w2[i].y2,w2[i].attr,

w2[i].xt,w2[i].yt,w2[i].text, w2[i].inp.x1,w2[i].inp.y1,

w2[i].inp.x2,w2[i].inp.y2, w2[i].inp.attr,

w2[i].inp.xt,w2[i].inp.yt,w2[i].inp.text);

End;


Procedure TForm.Show;

Var i:integer;

Begin Window(1,1,80,25);

TextBackGround(0);

TextColor(7);

Clrscr;

TWin.Draw;

for i:=1 to nalt do masalt[i].Draw;

for i:=1 to ninput do masinp[i].Draw;

End;


Procedure TForm.Clear;

Var i:integer;

Begin

for i:=1 to ninput do masinp[i].Clear;

End;


Procedure TForm.Input;

Var i:integer;

Begin

for i:=1 to ninput do masinp[i].Input;

End;


Procedure TForm.Enter;

Begin End;

End.

Рассматриваемый пример предполагает работу с файлом. Для удобства программирования создадим объект «База данных», который будет включать все поля и методы, необходимые для работы с файлом строк.

Пример 14. Описание базы данных для программы «Записная книжка».

Unit Basa;

Interface

Type

str80=string[80];

TBase=Object

f:file of str80; {файловая переменная}

filename:str80; {имя файла}

family:str80; {буфер для хранения фамилии}

telefon:str80; {буфер для хранения телефона}

Procedure BWrite(fam,tel:str80);{запись в файл}

Procedure BRead(fam,tel:str80); {чтение из файла}

Constructor Init;

Procedure CreateOpen(fn:str80); {создание/открытие}

Function Found(fam:str80):boolean;virtual;{поиск любой}

Function Compare(fam:str80):boolean;virtual;{тип поиска}

end;

Implementation

Constructor TBase.Init;

Begin end;


Procedure TBase.CreateOpen;

Begin filename:=fn;

{$I-}

Assign(f,FileName);

Reset(f);

{$I+}

if IOResult<>0 then ReWrite(f)

End;


Procedure TBase.BWrite;

Begin Seek(f,filesize(f));

Write(f,fam,tel);

End;


Function TBase.Found;

Var k:boolean;

Begin Reset(f);

k:=true;

Found:=false;

While (not Eof(f)) and k do

begin

BRead(family,telefon);

if Compare(fam) then

begin Found:=true;

k:=false;

end;

end;

End;


Procedure TBase.BRead;

Begin Read(f,family,telefon);

End;


Function TBase.Compare;

Begin Compare:=true; end;

End.

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

Пример 15. Программа «Записная книжка».

Program Memory;

Uses Menu, Base;

{ ************* Объекты-потомки стандартных *****}

Type TMainMenu=Object(TMenu) {основное меню}

may:boolean; {признак задания имени файла}

Procedure Enter;virtual;

end;

Type TOpenBase=Object(TInput) {ввод имени файла}

Function Error:boolean;virtual; {проверка имени файла}

end;

Type TAddMenu=Object(TForm) {форма для добавления записей}

Procedure Enter;virtual; {обработка ввода одной записи}

end;

Type TFindMenu=Object(TForm) {форма для поиска телефонов}

Procedure Input;virtual; {организовать ввод из одного окна}

Procedure Enter;virtual; {обработка поиска одной записи}

end;

Type TNotFound=Object(TMessage){сообщение "данные отсутствуют"}

Procedure Enter;virtual; {ожидание подтверждения}

end;

Type TMyBase=Object(TBase) {база данных}

Function Compare(fam:str80):boolean;virtual; {сравнение фамилий}

End;

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

var a:TMainMenu; b:TAddMenu; c:TOpenBase;

d:TFindMenu;e:TMyBase; h:TNotFound;

{ *********** Дополнительные методы *****************}

Procedure TMainMenu.Enter;

Begin

case npos of

1:begin

c.draw; {нарисовать окно ввода}

c.input; {организовать ввод имени файла}

e.createopen(c.inp.text); {создать или открыть файл}

a.show; {показать главное меню}

a.may:=true; { признак задания имени файла }

end;

2:if may then { если определен файл данных }

begin

b.show; {показать форму}

b.Run; {организовать работу с локальным меню}

a.show; {показать главное меню}

end;

3:if may then { если определен файл данных }

begin

d.show; {показать форму}

d.Run; {организовать работу с локальным меню}

a.show; {показать главное меню}

end;

end;

end;


Function TOpenBase.Error;

var l:integer;

begin l:=length(Inp.Text);

if (l>0) and (l<=8) then Error:=false

else Error:=true;

end;


Procedure TAddMenu.Enter;

Begin Case npos of

1:begin

masalt[1].setattr(113); {убрать выделение пункта меню}

input; {ввести фамилию и телефон}

e.BWrite(masinp[1].inp.text,masinp[2].inp.text);{записать}

masalt[1].setattr(71); {выделить пункт меню}

end;

2:

end;

end;


Procedure TFindMenu.input;

Begin masinp[1].Input; end;


Procedure TNotFound.Enter;

Begin d.Show; end;


Procedure TFindMenu.Enter;

Var i:integer;

Begin Case npos of

1:begin

masalt[1].Setattr(113);{убрать выделение пункта меню}

Input; {ввести фамилию}

if e.Found(masinp[1].inp.text) then

begin {показать в окне номер телефона}

masinp[2].inp.text:=e.telefon;

masinp[2].Draw;

end

else {сообщить об отсутствии данных}

begin

for i:=1 to 2 do masinp[i].inp.text:='';

h.Show; {вывести окно сообщения}

h.Run; {дождаться подтверждения}

end;

masalt[1].Setattr(71); {выделить пункт меню}

end;

2:

end;

end;


Function TMyBase.Compare;

Begin

if family=fam then Compare:=true

else Compare:=false;

end;

{ *****************Описание меню*********************}

const menu1:array[1..4] of TWin=

((x1:10;y1:14;x2:23;y2:18;attr:113;xt:3;yt:2;

text:'Создать или открыть книжку'),

(x1:26;y1:14;x2:39;y2:18;attr:113;xt:4;yt:2;

text:'Записать телефон'),

(x1:42;y1:14;x2:55;y2:18;attr:113;xt:5;yt:2;

text:'Найти телефон'),

(x1:58;y1:14;x2:71;y2:18;attr:113;xt:4;yt:2;

text:'Завершить работу'));

menu3:array[1..2] of TWin=

((x1:23;y1:18;x2:33;y2:21;attr:113;xt:2;yt:2;text:'Добавить'),

(x1:37;y1:18;x2:47;y2:21;attr:113;xt:2;yt:2;text:'Выход'));

menu4:array[1..2] of TWin=

((x1:23;y1:18;x2:33;y2:21;attr:113;xt:2;yt:2;text:'Найти'),

(x1:37;y1:18;x2:47;y2:21;attr:113;xt:2;yt:2;text:'Выход'));

input:array[1..2] of TInput=

((x1:22;y1:8;x2:32;y2:8;attr:94;xt:1;yt:1;text:'Фамилия';

Inp:(x1:34;y1:8;x2:46;y2:8;attr:112;xt:1;yt:1;text:'')),

(x1:22;y1:10;x2:32;y2:10;attr:94;xt:1;yt:1;text:'Телефон';

Inp:(x1:34;y1:10;x2:46;y2:10;attr:112;xt:1;yt:1;text:'')));


Begin

a.init(5,5,76,20,30,5,3,'Записная книжка',4,menu1);

b.init(20,2,50,22,94,5,3,'Добавление записей',2,menu3,2,input);

c.init(30,8,50,19,94,3,3,'Введите имя файла',

35,12,45,12,112,1,1,' ');

d.init(20,2,50,22,94,5,3,'Поиск записей',2,menu4,2,input);

e.init;

h.init(25,6,45,14,36,6,2,'Нет данных',

32,11,38,12,71,2,1,'Ok');

a.may:=false;

a.show;

a.Run;

end.

. Использование объектов при создании движущихся изображений.

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

Рис. 2.8. Иерархия классов для программы создания движущихся изображений.

Пример 16. Программа создания движущихся изображений.

{Вращение линии и квадрата вокруг их геометрических центров и движение окружности по окружности}

Program ex;

Uses crt,graph;

Type

Figure=Object

x,y, {координаты центра}

halflen, {радиус вращения}

dx,dy:integer; {проекции радиуса вращения}

constructor Init(ax,ay,ah:integer);

procedure Move(t:real); {организация движения}

procedure Draw;virtual; {рисование объекта}

procedure Rel(t:real);virtual; {определение смещения}

end;

Line=Object(Figure) {линия}

constructor Init(ax,ay,ah:integer);

procedure Draw;virtual;

end;

Square=Object(Figure)

constructor Init(ax,ay,ah:integer); {квадрат}

procedure Draw;virtual;

end;

Circle=object(Figure) {окружность}

r:integer;

constructor Init(ax,ay,ah,ar:integer);

procedure DRAW;virtual;

end;

Constructor Figure.Init;

Begin

x:=ax; y:=ay; halflen:=ah;

End;

Procedure Figure.Draw;

Begin End;

Procedure Figure.Rel;

Begin

dx:=round(halflen*cos(t));

dy:=round(halflen*sin(t));

End;

Procedure Figure.Move;

Var color:word;

Begin

color:=Getcolor; {запоминаем цвет}

SetColor(GetBkColor); {рисование цветом фона}

Draw; {стираем фигуру - рисуем цветом фона}

SetColor(color); {возвращаем цвет}

Rel(t); {пересчитываем значения dx и dy}

Draw; {рисуем на новом месте}

End;

Constructor Line.Init;

Begin

Figure.Init(ax,ay,ah);

End;

Procedure Line.Draw;

Begin

graph.Line(x+dx,y+dy,x-dx,y-dy);

End;

Constructor Square.Init;

Begin

Figure.Init(ax,ay,ah);

End;

Procedure Square.Draw;

Begin

graph.line(x+dx,y+dy,x-dy,y+dx);

graph.line(x-dy,y+dx,x-dx,y-dy);

graph.line(x-dx,y-dy,x+dy,y-dx);

graph.line(x+dy,y-dx,x+dx,y+dy);

End;

Constructor Circle.Init;

Begin

Figure.Init(ax,ay,ah);

r:=ar;

End;

Procedure Circle.Draw;

Begin

graph.Circle(x+dx,y+dy,r);

End;


Var driver,mode:integer;

t:real;

L:Line;

S:Square;

C:Circle;

Begin

driver:=detect;

InitGraph(driver,mode,'');

t:=0;

L.Init(160,250,75);

S.Init(320,250,75);

C.Init(480,250,75,10);

repeat

L.Move(t);

S.Move(-2*t);

C.Move(1.5*t);

delay(50);

t:=t+0.05;

until keypressed or (t>10000);

Closegraph;

end.



Литература

  1. Фаронов В.В. Турбо Паскаль (в 3-х книгах). Книга 1. Основы Турбо Паскаля. - М.: «МВТУ - ФЕСТО ДИДАКТИК», 1992.-304 с., ил.

Содержание

Аннотация........................................................................................................................................2

Введение............................................................................................................................................3

1. Средства объектно-ориентированного программирования. 

1.1 . Определение объекта. Компоненты: поля и методы. 

1.2 . Определение экземпляров объектов. Операция присваивания над объектами. Обращение к компонентам объекта из программы и методов. Неявный параметр Self. 

1.3 . Инициализация полей объектов. 

1.4 . Наследование. 

1.5 . Полиморфизм. 

1.6 . Раннее и позднее связывание. Виртуальные методы. Конструкторы. Определение типа объекта. 

1.7 . Динамические объекты. Деструкторы. 

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

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

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

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

2.3 . Использование объектов при создании движущихся изображений. 

Литература................................................................................................................................... 27



Список примеров.

Пример 1. Использование параметра Self. 

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

Пример 3. Инициализация полей объекта специальным методом. 

Пример 4. Использование типизированных констант (аналог записи) для инициализации полей объекта. 

Пример 5. Наследование. Полиморфизм. Раннее связывание. 

Пример 6. Позднее связывание. Виртуальные методы. 

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

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

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

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

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

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

Пример 13. Библиотека объектов для создания меню программы "Записная книжка". 

Пример 14. Описание базы данных для программы «Записная книжка». 

Пример 15. Программа «Записная книжка». 

Пример 16. Программа создания движущихся изображений. 



Случайные файлы

Файл
113982.rtf
KDA-0001.DOC
140996.rtf
113278.rtf
153019.rtf