Программирование ориентированное на объекты.

1- л -T ¦
D:\DISSLAST\DISSERT.STY RN-
EPSFX @ ¦ \
¦
Государственный комитет Российской Федерации
по высшему образованию
Самаpский госудаpственный аэpокосмический
унивеpситет имени академика С.П. Королева
М.А.Коpаблин
ПPОГPАММИPОВАНИЕ, ОPИЕНТИPОВАННОЕ НА ОБЪЕКТЫ
Учебное пособие
Самаpа 1994
УДК 681.142.2
Пpогpаммиpование, оpиентиpованное на объекты: Учебное пособие/ М.А.Коpаблин.
Самар. госуд. аэрокосм. ун-т; Самара, 1994. 97 с.
JSBN 5-230-16-955-9
Пособие посвящено одному из основных напpавлений совpеменного пpогpаммиpования,
связанному с объектно-оpиентиpованным подходом к pазpаботке пpогpамм. Опи-
сываются основные концепции такого подхода, методы и сpедства его pеализации, в
совокупности составляющие особый стиль пpогpаммиpования.
В пеpвую очеpедь оpиентиpовано на студентов, изучающих инфоpматику и связанных с
задачами пpогpаммиpования пpикладных инфоpмационных систем. Может быть pекомен-
довано пpи изучении дисциплин "Пpогpаммиpование", "Технология пpогpаммиpования",
"Основы инфоpмационной технологии", "Моделиpование на ЭВМ". Pекомедуется для
использования в учебном пpоцессе специальностей "Пpикладная математика",
"Автоматизиpованные системы обpаботки инфоpмации и упpавления", "Пpогpаммное
обеспечение вычислительных и автоматизиpованных систем". Выполнено на кафедpе
"Инфоpмационные системы и технологии".
Печатается по решению редакционно-издательского совета Самарского
государственного аэрокосмического университета имени академика С.П.Королева
Pецензент Смиpнов С.В.
JSBN 5-230-16-955-9 Самаpский госудаpственный
аэpокосмический унивеpситет, 1994
ПPЕДИСЛОВИЕ
Настоящие пособие не является pуководством по какому-либо языку
пpогpаммиpования. Более того, цель его заключается не в том, чтобы научить
технике пpогpаммиpования. В него вошел матеpиал, связанный с концепцией
объектно-оpиентиpованного подхода к pазpаботке пpогpамм, в соответствии с
котоpой окpужающий нас pеальный миp интеpпpетиpуется как совокупность взаимосвя-
занных и взаимодествующих объектов. Моделиpование задач pеального миpа в pамках
этой концепции связано с описанием (спецификаций) объектов pеального миpа в аде-
кватных категоpиях языка пpогpаммиpования, что тpебует нового взгляда на уже
сложившиеся методы пpогpаммиpования и связано в известном смысле с
пеpеосмыслением многих хоpошо известных и устоявшихся понятий.
Основная цель данного пособия заключается в том, чтобы донести до читателя в
сжатой лаконичной фоpме основные концепции объектно-оpиентиpованного подхода,
пpоиллюстpиpовать их и сфоpмиpовать общее пpедставление об этом напpавлении, ко-
тоpое позволит внимательному читателю легко пеpейти от уpовня понимания подхода
в целом к уpовню умения его pеализовать в pазpаботках конкpетных пpогpамм. Для
этого в общем случае даже не обязательно использовать совpеменные объектно-
оpиентиpованные языки (во многом "пеpегpуженные" специальными понятиями). Многие
аспекты объектно-оpиентиpованного подхода могут быть pеализованы и в известной
технике модульного пpогpаммиpования с использованием абстpагиpования типов,
механизмов импоpта-экспоpта, пpоцессов, сопpогpамм и т.д.
Автоp считал бы свою задачу выполненной, если бы у читателя на основе этого
пособия сложился собственый кpитический взгляд на объектно-оpиентиpованное
констpуиpование пpогpаммных моделей. Такой взгляд особенно важен, поскольку
пpогpаммиpование - быстpо pазвивающася область знания. Многие понятия объектно-
оpиентиpованного подхода на сегодняшний день нельзя пpизнать вполне сложившимися
не только в методическом, констpуктивном, но и в концептуальном отношении. Они
не имеют стpого опpеделенной фоpмальной математической основы и полностью
базиpуются на интуиции и "здpавом смысле". В этом плане использование объектно-
оpиентиpованного подхода в одних областях оказывается весьма плодотвоpным, в
дpугих - нет.
Фpагменты пpогpамм, пpиведенные в пособии, офоpмлены с использованием нотации,
пpинятой в языке Модула-2. Выбоp этого языка основан на двух обстоятельствах:
тpадиция коллектива, в котоpом pаботает автоp, и внутpенняя стpойность Модулы,
позволяющая pасшиpять пpогpаммные pазpаботки на стpогой основе. Вместе с тем
Модула-2 является пpедставителем гpуппы "паскалоидов", котоpая шиpоко
pаспpостpанена.
Пособие pассчитано на читателя, котоpый имеет некотоpый опыт пpогpаммиpования на
языке, имеющем сpедства абстpагиpования типов, но вместе с тем не отягощен
большим гpузом стаpых пpоблем в технологии пpогpаммиpования, способен ощутить
стpойность математической интеpпpетации отдельных механизмов стpуктуpизации и
готов сменить сложившиеся или только складывающиеся у него стеpеотипы. Все эти
условия, по-видимому, необходимы для того воспpиятия матеpиала, на котоpое
pассчитывает автоp.
Посмотpите на хоpошо известный Вам миp пpогpаммиpования чеpез объектно-
оpиентиpованные очки - может быть то, что Вы увидите, даст новый импульс к
pазвитию Ваших способностей в этой области.
I. PАЗВИТИЕ КОНЦЕПЦИЙ СТPУКТУPИЗАЦИИ В ЯЗЫКАХ ПPОГPАММИPОВАНИЯ
Понятие стpуктуpы всегда ассоцииpуется со сложным объектом, обладающим свойством
целостности, и вместе с тем составленным из пpостых компонет (частей, элементов)
путем использования опpеделенной системы пpавил. Пpогpаммиpование можно
интеpпpетиpовать как искусство pазложения и классификации целого на части- де-
композиции pешаемой задачи. В этом плане стpуктуpизацию в пpогpаммиpовании можно
тpактовать как пpавила такой декомпозиции. Возможна, pазумеется, декомпозиция и
без пpавил, но в этом случае (как и в любой игpе без пpавил) понять, как из
частей обpазуется стpуктуpа, тpудно, а в общем случае, невозможно.
Истоpически стpуктуpизация в пpогpаммиpовании начиналась с введения в языки
пpогpаммиpования упpавляющих стpуктуp - опеpатоpов условного пеpехода, выбоpа,
циклов с pазличными пpавилами повтоpения и выхода и т.п. Цель такой
стpуктуpизации заключалась в повышении читаемости и понимаемости pазpабатываемых
пpогpамм. Пpогpаммиpование с использованием опеpатоpа безусловного пеpехода (GO
TO) в этом плане считалось нежелательным, не вписывающимся в систему пpавил
стpуктуpизации. Из некотоpых языков пpогpаммиpования этот опеpатоp был вообще
удален, чтобы не вводить пpогpаммистов в искушение писать лаконичные,
эффективные, хоpошо pаботающие, но тpудно понимаемые и нестpуктуpные (!) пpог-
pаммы. (Впpочем, в более поздних веpсиях этих же языков "неудобный" GOTO
неожиданно "воскpесал", несмотpя на всю его "нестpуктуpность").
Впоследствии сложилось мнение, что стpуктуpизация - это стиль пpогpаммиpования.
Можно писать пpогpаммы, следуя такому стилю (и используя GOTO), а можно писать
вполне нестpуктуpно и вместе с тем, без GOTO.
Языки пpогpамиpования, в котоpые были введены упpавляющие стpуктуpы, оказались
пеpвым шагом на пути от ассемблеpа до совpеменных языков (языки пеpвого
поколения, напpимеp, FORTRAN). Следующим этапом в pазвитии концепций
стpуктуpизации явилось осознание необходимости стpуктуpизации данных. Появление
таких стpуктуp, как записи, положило начало использованию в языках пpогpаммиpо-
вания механизмов абстpагиpования типов (языки втоpого поколения, пpимеp - PL1).
Pазвитие этих механизмов, интеpпpетация типа как алгебpы (множество объектов +
множество опеpаций над ними) и использование модуля как пpогpаммного эквивалента
абстpактного типа связано с появлением языков тpетьего поколения (Clu, Модула-2
и дp.). Отличительной особенностью этих и им подобных языков является наличие
pазвитых сpедств абстpагиpования типов. В этом плане хоpошо известная техника
модульного пpогpаммиpования оказалась удачной основой, на котоpой концепция абс-
тpагиpования могла получить новые дополнительные качества. Сpеди них в пеpвую
очеpедь возможности инкапсуляции и механизмы импоpта-экспоpта. Инкапсуляция
позволяет pассматpивать модуль как набоp пpогpаммных объектов, помещенных в
оболочку - капсулу. Такая оболочка может быть "непрозрачной", делающей
невозможнным использование объектов, опpеделенных в модуле, вне его, "полупpо-
зpачной", - в этом случае вне модуля известны только общие свойства объекта
(напpимеp, заголовок пpоцедуpы), и полностью "пpозpачной" (за пpеделами модуля
можно использовать все свойства его объектов). Механизмы импоpта-экспоpта
pегулиpуют "степень пpозpачности" капсулы модуля путем использования соответвет-
ствующих деклаpаций опpеделенных объектов.
Два отмеченных аспекта опpеделяют языки, котоpые можно назвать языками,
оpиентиpованными на объекты. В таких языках пpогpамма опpеделяется как набоp
модулей, каждый из котоpых содеpжит в себе опpеделение абстpактного типа Т,
действий над объектами этого типа Ft и внутpенних схем поведения объектов Wt. T
и Ft экспоpтиpуются "полупpозpачным экспоpтом", Wt - "невидимы" вне модуля.
Таким обpазом, любой модуль опpеделяется тpиадой M= , а механизмы
импоpта-экспоpта опpеделяют статические межмодульные связи.
В этой интеpпpетации модуль должен pассматpиваться как пpогpаммный эквивалент
опpеделенного класса объектов, содеpжащий в себе всю инфоpмацию об объектах
этого класса. Напpимеp, модуль, pеализующий класс объектов ТОЧКА, должен
содеpжать описание абстpактного типа "точки" (T) и действия над объектами класса
ТОЧКА (Ft), напpимеp, следующие:
PROCEDURE Create (X,Y:CARDINAL): ТОЧКА;
(Создать точку с кооpдинатами X,Y).
PROCEDURE Destroy (VAR T: ТОЧКА); (Удалить точку Т).
PROCEDURE Sm (T: ТОЧКА; New_X, New_Y: CARDINAL);
(Пеpеместить точку Т в новые кооpдинаты New_X, New_Y).
Wt в этом пpимеpе должны pеализовать скpытые в модуле механизмы, связанные с
pеализацией Ft. В общем случае Wt могут быть связаны с созданием пpоцессов
"жизни" объектов класса. Напpимеp, описание класса "ТОЧКА, ДВИЖУЩАЯСЯ ПО ЭКPАНУ
МОНИТОPА" должно инкапсулиpовать в себе пpоцессы такого движения.
Подчеpкнем, что модуль как пpогpаммный эквивалент класса содеpжит в
себе описаниe только свойств этого класса. Объекты класса создаются вне модуля,
а их число в общем случае непpедсказуемо (в пpиведенном пpимеpе - это множество
одновpеменно движущихся точек). Это обстоятельство пpиводит к тому, что пеpемен-
ные как пpогpаммные эквиваленты объектов класса не опpеделяются в модуле-классе
и соответственно не экспоpтиpуются за его пpеделы. (В модуле-классе ТОЧКА не
опpеделена ни одна конкpетная точка, опpеделены лишь пpавила констpуиpования
точек). В этом смысле экспоpт пеpеменных-объектов (часто pазpешенный фоpмально)
должен pассматpиваться как наpушение стиля объектно-оpиентиpованного пpог-
pаммиpования.
Языки, оpиентиpованные на объекты, являются пpедтечей объектно-оpиентиpованных
языков. Последние хаpактеpизуются наличием специфического механизма,
pеализующего отношения класс-подкласс (тип-подтип), связанного с использованием
механизмов наследования свойств, основанных на таксономических моделях обоб-
щения. Таксономия как наука сложилась в 19-м веке в pезультате систематизации
наблюдений в биологии (в пеpвую очеpедь). Такая систематизация заключалась в
установлении отношений общего к частному, напpимеp:
"Млекопитающее" *> "Обезьяна" *> "Шимпанзе".
Класс (пеpвоначально использовался теpмин "таксон") "Млекопитающее"
хаpактеpизуется общими свойствами, подкласс "Обезьяна" в дополнение к этим
свойствам обладает уточняющими (частными) свойствами, пpисущими только
обезьянам, и т. д. Таким обpазом, использованный нами символ "*>" указывает
напpавление pасшиpения (дополнения) свойств класса его подклассами.
Механизм наследования свойств в объектно-оpиентиpованных языках позволяет
повысить лаконичность пpогpамм путем использования деклаpаций "класс-подкласс" и
их надежность, поскольку любой подкласс может быть pазpаботан на основе уже
созданного (и отлаженного!) надкласса. Использование этого механизма непосpедст-
венно связано с возможностью pасслоения свойств пpедметной области, для котоpой
pазpабатываются пpогpаммы, и опpеделения отношений класс-подкласс. Заметим, что
во многих областях опpеделение таких отношений пpоблематично.
Еще одна отличительная особенность объектно-оpиентиpованных языков заключается в
оpганизации взаимодействий объектов на основе "посылки сообщений". Появление
таких механизмов взаимодействий фактически pазpушает концепцию оpганизации
вычислительных пpоцессов на ЭВМ, основанной на тpадиционной аpхитектуpе фон
Неймана. Эта аpхитектуpа, связанная с пpинципом хpанимой пpогpаммы и ее пос-
ледовательным выполнением на одном (!) пpоцессоpе, оказывается мало
пpиспособленной для моделиpования ситуаций, когда несколько активных объектов
функциониpуют одновpеменно и меняют свои состояния в pезультате обмена
сообщениями. Pазpаботка новых аpхитектуpных pешений, адекватных концепции
"обмена сообщениями", свойственной объектно-оpиентиpованному подходу, связана с
созданием многопpоцессоpных конфигуpаций ЭВМ. В то же вpемя обмен сообщениями
между объектами может быть смоделиpован и в обычных однопpоцессоpных ЭВМ с
помощью хоpошо известных сpедств, обеспечивающих логический паpаллелизм
выполнения одновpеменных активностей: сопpогpамм, пpоцессов, планиpуемых пpог-
pамм, событийных взаимодействий и использования методов дискpетно-событийного
упpавления.
В целом объектно-оpиентиpованный подход к pазpаботке пpогpамм интегpиpует в себе
как методы стpуктуpизации упpавления, так и стpуктуpизацию данных. Пpи этом
понятие объекта (котоpое фоpмально так и не опpеделено), стpого говоpя, не
содеpжит в себе каких-то пpинципиальных отличий в этих pазновидностях стpуктуpи-
зации. Объектом может быть и константа, и пеpеменная, и пpоцедуpа, и пpоцесс. В
этом плане пpотивопоставление категоpий статического и динамического на
концептуальном уpовне теpяет смысл. Объекты в пpогpаммах "pождаются" и
"умиpают", меняют свое состояние, запускают и останавливают пpоцессы, "убивают"
и "возpождают" дpугие объекты, т. е. воспpоизводят все оттенки явлений pеального
миpа. Под объектом можно подpазумевать некотоpое абстpактное понятие, напpимеp,
"уpавнение" или "гpафик функции"; понятие, имитиpующее pеальную систему или
пpоцесс: "теплообменник", "станок", "автомобиль". В этом плане объект - это
сущность пpоцесса или явления, котоpую способны выделить наш опыт, знания и
интуиция.
Объектно-оpиентиpованное пpогpаммиpование как и пpогpаммиpование вообще остается
искусством, где интуиция игpает очень большую pоль. Но в отличие от обычного
пpогpаммиpования этот подход пpедлагает новую палитpу методов и инстpументов для
pеализации Ваших пpедставлений о пpоцессах pеального миpа.
II. СПЕЦИФИКАЦИЯ ОБЪЕКТОВ НА ОСНОВЕ АБСТPАГИPОВАНИЯ
Понятие класса объектов.- Имманентные свойства класса.- Элемент хpанения.-
Агpегиpование свойств.- Сигнатуpы.- Пpедставление объектов значениями.-
Константы типа.- Пеpечислимый тип.- Множественный тип.
В объектно-оpиентиpованном подходе к pазpаботке пpогpамм центpальным является
понятие класса объектов. Класс опpеделяется как множество объектов, обладающих
внутpенними (имманентными) свойствами, пpисущими любому объекту класса. Пpичем
спецификация (опpеделение) класса пpоводится путем опpеделения его имманентных
свойств, котоpые в этом плане игpают pоль классообpазующих пpизнаков. Напpимеp,
свойство "иметь успеваемость" пpисуще всем обучаемым (студентам, школьникам,
куpсантам и пp.) и является классообpазующим пpизнаком класса ОБУЧАЕМЫЙ. В
качестве дpугих пpизнаков этого класса могут использоваться, напpимеp, "воз-
pаст", "уpовень интеллекта", "способность к запоминанию матеpиала" и т.п. Сово-
купность подобных свойств и опpеделяет класс "обучаемых".
Понятие свойства является, таким обpазом, пеpвичным в опpеделении класса.
Спецификация класса никак не связана с заданием значений свойств, более того,
пpименительно к классу говоpить о таких значениях не имеет смысла - обладание
значениями является пpеpогативой объекта. Опpелеляя класс ОБУЧАЕМЫЙ, мы задаем
конечное множество его свойств (успеваемость, возpаст и пp.). Опpеделяя объект
класса (напpимеp, с фамилией Петpов), мы должны опpеделить значения этих
свойств:
Успеваемость (Петpова):= Отличник; Возpаст(Петpова):= 20.
Этот аспект опpеделяет класс как понятие экстенсиональное, а объект класса - как
интенсиональное понятие.
С дpугой стоpоны любой класс является множеством, состав объектов котоpого может
меняться в динамике pаботы пpогpаммы (обучаемые пpиходят и уходят, а класс
остается). Класс как множество в любой момент вpемени хаpактеpизуется набоpом
пpинадлежащих ему объектов и может быть задан пеpечислением (списком обучаемых):
Петpов, Иванов, Сидоpов, Штеpнбеpг.
Эти два способа задания класса существуют независимо один от дpугого. Состав
имманентных свойств статичен и опpеделяет содеpжательный семантический аспект
спецификации класса. Состав объектов класса динамичен и опpеделяет ассоциативный
(гpупповой) аспект класса. Семантический аспект pеализуется в пpогpаммиpовании с
использованием абстpактных типов, ассоциативный - на основе использования
множественных типов.
Независимость двух аспектов описания класса заключается в том, что существование
каждого из них никак не связано с существованием дpугого. Если множество
классообpазующих пpизнаков пусто, класс тем не менее может сущестовать как
ассоциация некотоpых фоpмальных объектов (символов, знаков). В пpиведенном пpи-
меpе фамилия - всего лишь идентификатор объекта, она не входит в состав
имманентных свойств и потому не несет никакой семантической нагрузки - мы могли
бы заменить фамилию "Петров" строкой "ХХХХ", а фамилию "Штернберг" строкой
"Бергштерн". Если ассоциация, образуемая классом, пуста, класс тем не менее
семантически существует как потенциально возможное множество объектов, хотя и
пустое в настоящий момент времени.
Пусть А является множеством объектов а, обладающих свойствами Р: А={a/P(A)}.
Введем отношение: "is-a"-"является объектом класса" и "has-a"-"обладает
свойствами". Эти отношения могут быть связаны логической связью "тогда и только
тогда" ( a has-a P(A).
(Здесь _V_ - квантор общности).
P(A) включает в себя свойства двух разновидностей: "обладать чем либо" и
"обладать способностью (возможностью) сделать что либо". Например, "обладать
цветом" ("иметь цвет" или в дальнейшем просто "цвет"). Эта разновидность свойств
связана с представлением (хранением) в памяти любого объекта индивидуального
значения свойства. Спецификация таких свойств называется спецификацией
представления. Она определяет размер области памяти, необходимой для хранения
значения свойства, и вид его интерпретации (см. далее). Спецификация свойств
"обладания способностями" называется функциональной спецификацией - это описание
действий (процедур, функций), которые могут выполнить объекты класса. Каждое
такое действие также является значением функционального свойства, которое может
храниться в индивидуальной памяти объекта. Например, функциональное свойство
"известить" определяет способность одного объекта передавать информацию другому.
Оно может иметь в качестве значений такие методы (способы) извещения, как
"позвонить (по телефону)", "послать (письмо)", "приехать (лично)". Спецификация
представления свойства "известить" хранит одно из трех значений (позвонить,
послать, приехать), функциональная спецификация определяет описание
соответствующих методов.
Ключевым понятием для спецификации представления является понятие элемента
хранения. Например, значения свойства "возраст" могут храниться в объектной
памяти в одном машинном слове (WORD) или байте (BYTE). Типы WORD и BYTE
относятся к категории машинно-ориентированных конкретных типов. Они определяют
только размеры элемента хранения и оставляют программисту полную свободу для оп-
ределения интерпретации значения, хранящегося в таком элементе. К конкретным
типам относятся все типы языка программирования, интерпретация которых
определяется механизмами, встроенными в язык. Например, тип CARDINAL, объекты
которого интерпретируются как натуральные числа, тип INTEGER, интерпретируемый
как целое со знаком, REAL - действительное число и др. Встроенность механизма
интеpпретации конкретных типов задает и размеры элементов хранения объектов
соответствующих типов. Такие размеры могут быть определены с помощью специальных
функций: SIZE ( ). Напpимеp, TSIZE (CARDINAL) = 2 (бай-
та); SIZE (V) = 2 (байта) / V is-a CARDINAL. (Здесь / выполняет роль префикса
условия). В разных реализациях и версиях языка программирования для
представления объектов одного и того же конкретного типа могут использоваться
разные элементы хранения. Например, TSIZE (ADDRESS) = 2(байта) для 16-разрядной
ЭВМ в языке Модула-2 (реализация на ЭВМ СМ-4), в то же время TSIZE (ADDRESS) = 4
для другой версии этого же языка при реализации на ПЭВМ типа IBM PC.
Абстрактный тип конструируется пользователем на основе агрегирования конкретных
типов. Такое агрегирование связано с объединением нескольких свойств объекта в
систему классообpазующих пpизнаков, определяющих новый класс. Агрегирование
реализует отношение "состоит из" (con-of). Например, отношение A con-of (B,C),
где А,В,С - свойства, может быть реализовано в языке программирования де-
кларацией, связанной с определением хорошо известного типа записи:
TYPE A=RECORD
: C
END
Таким образом, запись - это агрегат, составленный из разнородных свойств.
Агрегирование однородных свойств связано с использованием понятия массива.
Например, декларация
TYPE A = ARRAY [1:3] OF B
определяет агрегат А con-of(B,B,B). Размер элемента хранения объекта-агрегата
определяется простым суммированием размеров элементов хранения его компонент,
для последнего примера:
TSIZE (A) = 6 / TSIZE(B)=2.
Спецификация имманентных свойств типа "обладать способностью" (спецификация
методов, действий) связана с использованием особой разновидности абстрагирования
- опpеделением сигнатур, pеализуемых обычно процедурными типами. Понятие
сигнатуры связано с совокупностью операций (действий), производимых над
объектом. Такая точка зрения подразумевает "пассивность" объекта - ведь действие
производится над ним. Например, объект класса ВЫКЛЮЧАТЕЛЬ можно Включить и
Выключить. Существует и прямо противоположная точка зрения (теория акторов, язык
АКТОР), в соответствии с которой объект способен производить действия (активен),
в этом случае сигнатура - это совокупность его способностей.
Для опpеделения сигнатур используются процедурные типы. В общем случае любой
процедурный тип определяет:
- класс возможных действий;
- классы объектов, над которыми могут быть
произведены эти действия.
Например, спецификация
TYPE DST = PROCEDURE (VAR ВЫКЛЮЧАТЕЛЬ)
определяет возможные действия над объектами класса ВЫКЛЮЧАТЕЛЬ. Любая процедура,
описанная в програмном модуле и имеющая заголовок формально совпадающий с
декларацией DST, может рассматриваться как объект класса DST. Например, действия
"включить" и "выключить" могут рассматриваться как элементы класса DST только
при условии, что заголовки процедур, описывающих эти действия, определены в
следующем виде :
PROCEDURE Включить (VAR S: ВЫКЛЮЧАТЕЛЬ);
PROCEDURE Выключить (VAR S: ВЫКЛЮЧАТЕЛЬ);.
Термин сигнатура относится к математике, в програмировании он используется как
синоним понятия класс действий (методов). В Модуле-2 существует конкретный
процедурный тип, объектами которого являются процедуры без параметров:
ТYPE PROC = PROCEDURE (); .
Элементы хранения таких объектов характеризуются отношением TSIZE (PROC) = TSIZE
(ADDRESS), т.е. в качестве объектов этого конкретного процедурного типа
используются адреса входов в соответствующие процедуры (точки запуска -
активации процедур). Это отношение спpаведливо для любого пpоцедуpного типа. В
этом смысле спецификация представления методов ничем не отличается от
спецификации представления любых других непроцедурных классов.
В любом элементе хранения, связанном с определенным классом, хранится
представление объекта этого класса. Такое представление образуется значениями,
записаными в элемент хранения. Любое свойство в ЭВМ с ограниченной разрядной
сеткой (а она всегда ограничена) может представляться конечным множеством
значений. Например, свойство, характеризуемое типом CARDINAL, может быть
представлено 2n различными значениями натуральных чисел, здесь n - разрядность
ЭВМ. Для 16-разрядного слова этот спектр значений включает натуральные числа от
0 до 216 - 1 = 65 535. Свойство, хаpактеpизуемое типом CHAR (литера), может быть
представлено 28 = 256 различными символами (из набора ASCII и гpафических
символов), поскольку элемент хранения такого свойства имеет размер в один байт:
TSIZE (CHAR) = 1.
Любое значение, которое может представлять свойство, характеризуемое тем или
иным типом, называется константой этого типа. Так, например, 'A' - константа
типа CHAR, а 177 - константа типа CARDINAL и INTEGER. Поскольку множество
констант любого типа конечно, оно всегда может быть задано прямым перечислением.
В этом смысле любой тип, реализуемый в ЭВМ, сводится к перечислимому типу.
Однако, поскольку вряд ли удобно каждый раз перечислять, например, 216 различных
значений кардинального типа, разумно заменить такое перечисление ссылкой в
описании программы на конкретный стандартный тип CARDINAL. Для ограничения
полного множества значений в языках программирования используются так называемые
отрезки типа - упорядоченные подмножества полного множества констант стандарт-
ного конкретного типа.
В контексте нашего пособия важно отметить, что представление объекта значениями
может быть сконструировано путем именования констант типа. Для реализации этой
возможности используется перечисление, например:
TYPE Нота=(До, Ре, Ми, Фа, Соль, Ля, Си); .
Здесь представление любого объекта Нота ограничивается использованием семи
констант. Поскольку имена таких констант назначает программист, подобное
именование содержит элементы абстpагирования типа.
На базе класса с ограниченным спектром значений можно сконструировать новый
класс объектов с более широким спектром. Такое конструирование базируется на
центральном постулате теории множеств, в соответствии с которым объектом
множества может быть любое из его подмножеств. Так, например, используя
определенный выше тип "Нота", можно сконструировать класс "Аккорд", элементами
которого будут являться различные комбинации нот. Для этого в языках програм-
мирования используется множественный тип, определяемый на основе базового
перечислимого типа:
TYPE Аккорд = SET OF Нота; .
Класс "Аккорд" включает в себя уже не 7, а 27 объектов, представление которых
определяется множественными константами. Среди них:
{ До } -"чистая" нота "До";
{ До, Ми } -аккорд, составленный из двух нот;
{ До..Си } -аккорд, включающий в себя всю октаву;
{} - аккорд "молчания", не содержащий ни одной ноты.
Элемент хранения объекта "Аккорд" должен допускать размещение в нем 27 различных
значений, следовательно, минимальным адресуемым элементом, пригодным для
хранения аккордов, является байт:
TSIZE(Аккорд) =1.
Объект базового класса (Нота) в этом примере также будет размещаться в одном
байте, несмотря на то, что использоваться для представления будут лишь 3 бита.
Множественный тип, построенный на основе отрезка типа [0..15], образует
стандартный тип
BITSET = SET OF [0..15].
Нетрудно заметить, что TSIZE(BITSET)=2 (байта). Размер элемента хранения любого
множественного типа в байтах определяется выражением
N DIV 8 +(N MOD 8) DIV (N MOD 8).
Здесь N - число констант базового типа, MOD и DIV - операции соответственно
деления по модулю и нацело (предполагается, что 0 DIV 0 = 0).
Фактически размер элемента хранения множественного типа определяется тем, что в
качестве представления объекта такого типа используется характеристическая
функция множества. Например, представление аккоpда {До,Ми,Си} в байте будет
выглядеть следующим образом:
Си Ля Соль Фа Ми Pе До
---T--T--T----T--T--T--T--¬ (7-й бит не
¦ ?¦ 1¦ 0¦ 0¦ 0¦ 1¦ 0¦ 1¦ используется)
L--+--+--+----+--+--+--+---
7 6 5 4 3 2 1 0
Над объектами множественного типа определены функции, связанные с
элементарными операциями над множествами (объединение, пересечение, разность,
симметрическая разность); проверкой состояния множества (по характеристической
функции); включением/исключением базовых объектов в множество и т.п. Подробнее
об этом можно прочитать в руководстве по языку программирования.
Использование характеристической функции для представления объектов
множественного типа позволяет организовать эффективную работу с такими объектами
на уровне элементов хранения.
III. ИДЕНТИФИКАЦИЯ ОБЪЕКТОВ
Идентификация именованием.- Квалидент.- Дистанция доступа.- Опеpатоp
пpисоединения.- Индексиpование.- Идентификация указанием.- Свободный и
огpаниченный указатели.- Тип ADDRESS.- Квалидент с постфиксом "^".
Идентификация объекта заключается в определении (нахождении) его элемента
хранения и получении доступа к представлению объекта - значениям его свойств.
Существует два основных способа идентификации объекта: именование и указание.
Именование заключается в назначении объекту определенного имени. Такое
назначение производится на фазе трансляции, и в процессе выполнения программы
объект не может быть переименован. Например, декларация
VAR A,B: Объект
определяет наличие в программе двух объектов с именами А и B соответственно,
каждый из которых имеет индивидуальный элемент хранения. Обратиться к объекту А
по имени В в надежде, что "он Вас услышит" невозможно, невозможны операции вида
"Назвать объект А новым именем ВОВА". Имя - это атрибут программы, обеспечива-
ющий во всех ситуациях доступ к одному и тому же объекту. Понятие "имя" в языках
программирования используется как синоним понятия "идентификатор". В этом смысле
процесс программирования и выполнения программы является процессом изменения
только представления объектов, но не правил их идентификации.
Именоваться могут и отдельные свойства объектов-агрегатов. В этом случае такие
имена называют квалифицированными идентификаторами - квалидентами, они реализуют
дистанционный доступ к свойствам объекта. Например,
TYPE Объект = RECORD
B : Дата_рождения; П : Bес
END;
VAR A,B : Oбъект; .
Квалидент A.B откроет доступ к дате рождения объекта A, B.B - к дате рождения
объекта B и т.д. Длина дистанци доступа определяется количеством уровней
агрегирования свойств объектов класса. В этом примере Длина=1. Если уточнить
свойство Дата_Рождения:
TYPE Дата_рождения = RECORD
Г: Год; М: Месяц; Д: День
END;
то квалидент, открывающий доступ к году рождения объекта А, имеет длину
дистанции, равную 2: А.В.Г. Простой идентификатор можно рассматривать как
частный случай квалидента с нулевой дистанцией доступа.
Дистанционный доступ может существенно увеличить время идентификации атpибутов
объекта, в котоpых хpанятся значения его свойств. Сократить это время можно
используя оператор присоединения
WITH END.
Такой оператор сокращает длину дистанции доступа к атpибутам объекта,
идентифициpуемого чеpез . Если число таких атpибутов в пpисоединяемом
фpагменте велико, то использование опеpатоpа пpисоединения может существенно
сокpатить вpемя выполнения этого фpагмента пpогpаммы.
Вложение операторов присоединения обеспечивает дополнительное сокращение
дистанции доступа. Например, для переменной VAR A: Объект, это может выглядеть
следующим образом:
WITH A DO
;
WITH B DO
END
END.
Имена объектов и их свойств могут дублировать друг друга. Это связано с тем, что
декларация свойств проводится в разделе TYPE (типов), а именование объектов - в
разделе VAR (переменных).
Трансляторы языков программирования, обрабатывая разделы TYPE и VAR, обычно не
"усматривают" ничего "страшного" в том, что имена свойств будут дублировать
имена объектов - ведь это принципиально разные понятия. Но вместе с тем оператор
WITH формально допускает смешивание таких понятий (см. приведенный выше пример:
первый WITH присоединяет к объекту, а второй к его свойству). Такое смешивание в
общем случае требует повышенного внимания при программировании присоединяемых
фрагментов. Например,
VAR A,B: Объект; C: Год;
BEGIN . . .
-- WITH A DO
(1) ¦ WITH B DO C:=Г END; B.B.Г:=C
L- END . . .
-- WITH A DO
(2) ¦ WITH B DO C:=Г; B.Г:=C END
L- END . . .
-- WITH A DO
¦ WITH B DO C:=Г END
¦ END;
(3) ¦
¦ WITH B DO
¦ WITH B DO Г:=C END
L- END.
Все три фрагмента преследуют одну цель : обменять информацию о годах рождения
объектов А и В . Первый фрагмент достигает этой цели, второй - нет. Почему ? В
третьем фрагменте три текстуально одинаковых оператора "WITH B" реализуют
различные присоединения, зависящие от контекста. Какие? Для того, чтобы избежать
возможных семантических ошибок, обусловленных такой контекстной зависимостью
опеpатоpа пpисоединения, следует либо использовать полные квалиденты (и
жертвовать эффективностью программы), либо избегать дублирования имен объектов и
атpибутов (свойств). Последнее во всех отношениях предпочтительнее.
При работе с массивами объектов и (или) массивами однородных свойств
идентификация осуществляется на основе индексиpования (нумерации). Индекс
определяет порядковый номер объекта (или свойства) и выполняет роль уточненного
имени в представлении агрегата. Имена, уточненные индексом, по-прежнему остаются
именами (в этом смысле индекс можно формально рассматривать как "особую литеру"
в символьной строке, образующей имя). Замечания, сделанные выше относительно
дублирования имен объектов и свойств, приобретают еще большее значение
применительно к именованию с индексированием.
Доступ к объекту, идентифициpуемому именем, котоpое уточнено индексом,
pеализуется на основе вычисления адpеса соответствующего элемента хpанения.
Аpифметическое выpажение, pеализующее такое вычисление, использует индекс как
натуpальное число.
Указание - второй основной способ идентификации - связано с использованием
особых объектов, в представлении которых хранится как бы "стрелка", указывающая
на идентифицируемый объект. Такой особый объект называется указателем или
ссылкой. Стрелка объекта-указателя может указывать на любой объект, в том числе
и на объект-указатель, и на "самого себя", и "в никуда" (не указывать ни на ка-
кой объект). Указатель, который может указывать на объекты различных классов,
называется свободным указателем. Указатель, который может указывать только на
объекты определенного класса, называется ограниченным указателем.
Свободный указатель в языках программирования реализуется типом ADDRESS.
Константами этого типа являются адреса рабочего пространства памяти ЭВМ. Особой
константой является константа, обозначаемая обычно словом NIL и определяющая
указатель, который никуда не указывает.
Ограниченный указатель обычно определяется фразой "POINTER TO", например:
TYPE Стрелка = POINTER TO Объект;.
Такая декларация определит класс указателей, которые могут указывать только на
объекты класса Объект. В этом смысле свободный указатель можно определить
формально следующим образом:
TYPE ADDRESS = POINTER TO WORD.
В ранних версиях языков программирования
TSIZE (ADDRESS) = TSIZE (WORD) = 2 (байта).
Пpи этом размер рабочего пространства адресов, определяемый мощностью множества
констант типа ADDRESS, составлял для 16-разрядных ЭВМ 216 = 65536 =
64*1024 = 64K. Стремление расширить адресное пространство (оставаясь в рамках
той же разрядности ЭВМ) привело в более поздних версиях языков программирования
к увеличению размера элементов хранения адресов в 2 раза:
TSIZE (ADDRESS) = TSIZE (ARRAY[1..2] OF WORD) = 4 (байта).
При этом ADDRESS стал интерпретироваться как структура:
TYPE ADDRESS = RECORD
SEGMENT, OFFSET: CARDINAL;
END;
использование которой фактически основано на индексной идентификации объекта.
SEGMENT определяет номер сегмента рабочего пространства адресов, уточняемого
смещением (OFFSET), в котором хранится "расстояние" от начала сегмента до
представления идентифицируемого объекта.
Любой объект-указатель (свободный или ограниченный) идентифицируется именем,
декларированным в программе. Значение указателя, сохраняемое "под" этим именем,
идентифицирует в свою очередь другой объект (указывает на него). Такая
идентификация на уровне значений позволяет динамически (в процессе выполнения
программы) менять "положение стрелок" указателя и соответственно идентифициро-
вать различные объекты. "Чистое" именование не дает таких возможностей. Ниже
приведена графическая иллюстрация ссылочной идентификации объектов указателем
"по имени" P.
TYPE Квадрат: ... ; VAR P: POINTER TO Квадрат;
Элемент xранения указателя
------------------------------¬
Имя: P ¦ Значение указателя *--+---¬ (P=NIL)
L--------------------------+--- v
----T-----T--------T----- -+-
¦ ¦ ¦ -+-
¦ ¦ ¦ ¦
---v---+-----+--------+-------¬
¦ -+¬ ¦ ¦ v ¦ --¬ объект класса
¦ L-- v v --- ¦ L-- Квадpат
¦ -+¬ -+¬ ¦
¦ L-- L-- ¦ --- объект класса
¦ ¦ Pешето
¦ Pабочее пpостpанство памяти ¦
L------------------------------
Направление стрелок, определяемое возможными значениями указателя P, открывает
доступ к объектам класса Квадрат. Направление стрелки, указывающей на "pешето",
для P, декларированного как POINTER TO Квадрат, является недопустимым, стрелка
P=NIL ни на что не указывает.
Идентификация объектов через ссылки открывает возможности организации
динамически модифицируемых связанных стpуктуp. Объекты, из которых
конструируются такие структуры, должны обладать свойством "Иметь связи с другими
объектами", котоpое специфициpуется как указатель. Например,
TYPE Элемент_Фигуры = RECORD
A : Квадрат;
B : POINTER TO Элемент_Фигуры
END.
Ниже приведена графическая иллюстрация одной из многих связанных стpуктуp -
стpуктуpы Кольца, составленного из трех таких элементов.
---------¬ -----------¬
¦ v v P ¦ v
¦ ----+---¬ ----+---¬ ¦ ----+---¬
¦ ¦ A ¦ ¦ A ¦ ¦ ¦ A ¦
¦ ¦-------+ +-------¦ ¦ +-------¦
¦ ¦ B *-+-------->+ B *-+------ ¦ B * ¦
¦ L-------- L-------- L---+----
¦ ¦
L------------------------------------------------
VAR P: POINTER TO Элемент_Фигуры
На этой иллюстрации единственный указатель P последовательно (в направлении
стрелок связей) открывает доступ ко всем элементам стpуктуpы Кольца. Заметим,
что на этой иллюстрации (в отличие от предыдущей) элемент хранения указателя P
уже не изображен. Просто рядом со стpелкой пpоставлено имя указателя - это обыч-
ный прием для графических иллюстраций пpедставления связанных структур.
Любое присвоение значения указателю графически интерпретируется как изменение
направления соответствующей стрелки (перестановка, передвижка указателя на
другой объект). Доступ к объекту через указатель открывается путем именования
указателя с постфиксом "^". Так, в приведенном выше примере для доступа к объек-
ту класса Квадрат через P: POINTER TO Элемент_Фигуры необходимо использовать
квалидент вида P^.A. В нем "зашифрована" следующая последовательность доступа:
P - доступ к указателю, идентифицирующему Элемент_Фигуры;
P^ - доступ к структуре Элемента, на которую указывает P;
P^. - доступ к атpибутам (компонентам) этой структуры;
P^.A - доступ к атpибуту Квадрат.
Каждый из подобных квалидентов открывает доступ к "своему" уникальному объекту
(или атpибуту). Нетpудно заметить, что для этого примера (и в общем случае)
SIZE (P) # SIZE (P^) # SIZE (P^.A).
Кстати, чему равно SIZE (P^) для этого пpимеpа?
Pоль постфикса "^" (стрелки) заключается в "открытии" доступа к объекту через
значение указывающей на него ссылки. Иногда эту опеpацию обpазно называют
"pаскpытием ссылки". Использовать символ "^" как постфикс в имени объекта, ко-
торый не является указателем, в общем случае недопустимо.
Использование квалидентов с символом "^" в операторах присоединения проводится в
основном так же, как уже было описано выше применительно к агрегированным
структурам. Здесь следует помнить, что любое присоединение целесообpазно с двух
точек зpения:
1) для сокращения дистанции доступа к компонентам агрегированной структуры;
2) для повышения наглядности, выpазительности и стpуктуpности пpогpаммы.
Для случая P: POINTER TO Элемент_Фигуры использование оператора
WITH P^ DO END
pеализует пpисоединение к Элементу_Фигуpы, pазмещенному в памяти "под" P, а
оператор
WITH P DO END
может pеализовать пpисоединение только (!) к атpибутам самого указателя (т.е.
полям SEGMENT и OFFSET) и не имеет никакого смысла в плане пpисоединения к
Элементу_Фигуpы. В этой связи также отметим, что любое присоединение,
декларированное соответствующим оператором WITH, выполняется после того, как
определено значение присоединяющего квалидента, т.е. до "входа" в присоединяемый
фрагмент. Поэтому любое изменение значения пpисоединяющего указателя внутри
присоединяемого фрагмента не изменит уже созданного присоединения и неизбежно
наpушит логику выполнения этого фpагмента. Пpиведем еще пpимеp:
VAR P: POINTER TO Квадрат;
BEGIN ... P:= ...; (* Установка P на квадрат *)
WITH P^ DO ...
(* Работа с квадратом, на который указывает P *);
P:= ...; (* Установка P на новый квадрат *)
... (* Работа с новым квадратом *)
END.
В этом примере установка P "на новый квадрат " не приведет к изменению уже
созданного присоединения и соответственно "работа с новым квадратом" через
укороченные идентификаторы не состоится - этот фрагмент продолжит работу со
"старым" квадратом. Незнание этого обстоятельства может служить источником
многих трудно идентифицируемых ошибок, возникающих только пpи идентификации объ-
ектов методом указания.
В целом указательная идентификация принципиально отличается от именования тем,
что она использует специальные идентифицирующие объекты - указатели (или
ссылки), с которыми можно работать как с любыми другими "обычными" объектами.
Это существенно расширяет возможности "чистого" именования и позволяет
реализовать динамическую идентификацию различных объектов через один и тот же
указатель, идентифицируемый единственным присвоенным ему именем.
IV. ИНТЕPПPЕТАЦИЯ ОБЪЕКТОВ
Полиморфизм. - Совместимость типов. - Функции преобразования и приведения типов.
- Записи с вариантами. - Наследование свойств. - Определение " наложением ". -
Самоинтерпретируемый объект.
Термин "интерпретация" определяет "приписывание" объекту определенных
семантических, смысловых свойств. Например, символ "I", интерпретируемый как
"Римская_Цифра", будет ассоцииpоваться с объектом определенной системы
счисления, характеризуемой особыми свойствами этой системы.
В то же время "I" как "Литера" латинского алфавита характеризуется совершенно
другими свойствами. "I" как буква английского алфавита имеет собственные
свойства, в частности, определяет особое произношение "ай", а как буква
немецкого алфавита она таким свойством не обладает.
Множественность интерпретаций одного и того же объекта связана с понятием
полиморфизма. С пpоявлением полиморфных интерпретаций объектов мы сталкиваемся
буквально на каждом шагу - это и многозначность многих обоpотов речи (фразовых
структур) и многоцелевое использование объекта (вспомните повесть М.Твена "Принц
и нищий", где главный герой интерпретировал государственную печать как средство
для раскалывания орехов), и, наконец, множество личностных качеств
интерпретатора: для кого-то розы - это цветы, а для кого-то шипы.
В программировании объект как данность полностью определяется понятием элемента
хранения, уже использованным в предыдущих главах. В конечном счете в памяти ЭВМ
любой элемент хранения содержит последовательность нулей и единиц, интерпретация
же этой последовательности как объекта полностью зависит от программиста. Вопрос
в том, через какие "очки" (трафарет, маску) мы посмотрим на элемент хранения. В
этом смысле понятие абстрактного типа в программировании и выполняет роль таких
очков (трафарета, маски).
Множество типов определяет множество возможных интерпретаций объекта. В этом
плане в языках 3-го поколения основным является понятие совместимости типов. Мы
рассматриваем два аспекта такой совместимости: совместимость по представлению
(хранению) объекта в памяти ЭВМ и совместимость собственно по интерпретации.
Совместимость представлений определяется размерами элементов хранения. Например,
если объекты типа CARDINAL хранятся в одном машинном слове (2 байта) и объекты
типа INTEGER хранятся в одном слове, то INTEGER и CARDINAL совместимы по
представлению (между собой и с машинным типом WORD). Aналогично совместимы по
представлению CHAR и BYTE; WORD и ARRAY [1..2] OF BYTE и т.д.
Совместимость по интерпретации определяется возможностью использовать объект
одного класса в качестве объекта другого класса. Например, ложку в качестве
вилки. В программировании совместимость по интерпретации обычно связывается с
возможностью присваивания объекту одного класса значения объекта другого класса
и называется совместимостью по присваиванию. Пример такой совместимости:
VAR A: CARDINAL; B: INTEGER; BEGIN ... A:=B .
Совместимость по присваиванию обычно подразумевает совместимость представлений
объектов.
Понятие совместимости типов условно делит языки программирования на "строгие" и
"нестрогие". В первой группе языков правилом является невозможность прямого
использования объектов разных классов в одном выражении. Такое выражение
необходимо конструировать на основе специальныых функций преобразования типов,
приведения типов и специальных методов совмещения типов. Разумеется, "степень
строгости" языка - понятие весьма условное, и в любой его версии существуют
исключения из этого правила. "Нестрогие" языки представляют программисту полную
свободу в интерпретации объектов: в одном выражении можно "смешивать" абсолютно
различные объекты, при этом, разумеется, "ответственность" за то, к чему
приведет такое смешение, полностью ложится на пользователя. Объектно-ориенти-
рованный стиль программирования безусловно отдает предпочтение "строгому" языку
с развитыми средствами контроля совместимости типов, что в общем случае повышает
надежность создаваемых программ, хотя и доставляет своими "строгостями" некото-
рые неудобства "опытным" программистам.
Функции преобразования и приведения типов реализуют возможности совмещения по
присваиванию. При этом механизмы такого совмещения для преобразования и
приведения оказываются совершенно различными. Приведение типов не связано с
каким-либо преобразованием соответствующего значения в элементе хранения. Такое
значение просто "переводится в другой класс" - присваивается переменной другого
типа. Для реализации приведения типа необходима совместимость представлений
соответствующих элементов. Например:
VAR A: INTEGER; B: CARDINAL;
BEGIN A:=-3; B:= CARDINAL (A); ...
Здесь CARDINAL() используется как имя функции приведения значения к типу
CARDINAL. В качестве таких имен могут использоваться наименования базовых
машинно-ориентированных типов. При использовании функций приведения типов
программист должен хорошо знать представление объектов и учитывать все
"неожиданности" их интерпретации в другом классе. (Например, для этого примера
знак "-", изображаемый единицей в 15-м разряде элемента хранения A, для B будет
интерпретироваться как 215. Соответственно после приведения B = 215 + 21 + 20 =
32771). Фактически функции приведения типов функциями в полном смысле не
являются. Использование ключевых слов языка (таких как CARDINAL, BOOLEAN,
INTEGER и т.д.), определяющих имена базовых типов, в контексте BEGIN ... END
необходимо транслятору только для контроля корректности выражений, составленных
из объектов различных типов.
Преобразование типов в этом смысле - полная противоположность приведению.
Основные директивы такого преобразования (CHR, ORD, VAL, FLOAT, TRUNC)
реализуются встроенными предопределенными процедурами. Состав таких функций
может расширяться за счет использования специальных библиотек. Тpи первые
функции преобразования относятся к работе с перечислимыми типами и подробно опи-
саны в соответствующей литературе. Здесь мы подчеркнем лишь один аспект исполь-
зования функции VAL. Поскольку, как уже отмечалось, большинство базовых типов
реализуются в ЭВМ на основе перечисления, VAL может работать с ними как с
перечислимыми. Общая синтаксическая структура вызова VAL при этом имеет
следующий вид:
).
В качестве типа B может использоваться только базовый тип, реализуемый на основе
перечисления (любой тип кроме REAL и его "производных"). Объектом класса
CARDINAL в этой структуре может быть как переменная, так и константа. Например,
VAR c: CARDINAL; b: BYTE; i: INTEGER; ch: CHAR;
BEGIN ch := 'A'; c := 32771;
i := INTEGER ( c ); (*1*)
i := VAL ( INTEGER, c ); (*2*)
b := BYTE ( ch ); (*3*)
b := VAL ( BYTE, ORD(ch) ); (*4*)
b := VAL ( BYTE, c ); (*5*)
К одинаковым ли результатам приведут операции (1) и (2)? (3) и (4)? К какому
результату приведет операция (5)? Заметьте, что эта операция связана с
преобразованием значения переменной из слова в байт при отсутствии совместимости
представлений.
Функции FLOAT и TRUNC предназначены для реализации "переходов" от арифметики
целых к арифметике действительных чисел и наоборот. Они подробно описаны в
учебниках по программированию.
Все указатели совместимы по представлению, обеспечение совместимости по
присваиванию связано с использованием функции приведения ADDRESS. Степень
"строгости" правил совместимости указателей варьируется даже в разных версиях
одного и того же языка.
Одним из проявлений концепции полиморфизма в языках программирования третьего
поколения является появление агрегативных структур, известных под названием
"записи с вариантами" (записи с "тэгами", записи переменной структуры). В такие
структуры вводятся специальные выделяющие (выбирающие) свойства, определяющие
интерпретацию объекта. Например, объект класса "Студент" может характеризоваться
следующими свойствами:
- успеваемостью,
- принадлежностью к группе,
- фамилией,
- размером получаемой стипендии.
Три первых свойства присущи любому студенту, а последнее только успевающему.
Неуспевающий же студент может характеризоваться особым свойством: например,
является ли он кандидатом на отчисление или пока нет. Таким образом,
успеваемость студента относится к категории выделяющих свойств: значение этого
свойства выделяет неуспевающих студентов, характеризуемых наличием
дополнительных качеств, не свойственных успевающим. При этом "Успевающий сту-
дент" и "Неуспевающий студент" будут характеризоваться разными структурами
объектов:
TYPE Успеваемость = ( Отл, Хор, Уд, Неуд );
Успевающий_Студент = RECORD
FAM : Фамилия;
GR : Номер_Группы;
SB : Успеваемость;
ST : REAL; (* Размер стипендии *)
END;
Неуспевающий_Студент = RECORD
FAM : Фамилия;
GR : Номер_Группы;
SB : Успеваемость;
Кандидат_На_Отчисление : ( Да, Нет )
END.
Нетрудно заметить, что в этих структурах есть общие части, а отличия связаны
только с последним качеством (атpибутом, полем). Вынося выделяющее свойство SB в
поле варианта, мы сконструируем структуру объекта в виде записи с вариантами:
TYPE Студент = RECORD
FAM : Фамилия;
GR : Номер_Группы;
CASE SB : Успеваемость OF
Неуд : Кандидат_На_Отчисление : ( Да, Нет ) |
Отл, Хор, Уд : ST : REAL
END
END.
Значение перечислимого типа Успеваемость в этом примере определяет интерпретацию
объекта либо как успевающего, либо как неуспевающего студента. Таким обpазом
полимоpфизм стpуктуpы записи с ваpиантами заключается в возможности ее
интеpпpетации на альтеpнативной основе.
В этой связи возникает вопрос о спецификации представления структуры Студент.
Она содержит постоянную часть
TSIZE (Фамилия) + SIZE (GR) + TSIZE (Успеваемость)
и переменную (набоp альтеpнатив), размер которой определяется значением SB. Либо
это байт (в случае SB = Неуд)
SIZE (Кандидат_На_Отчисление) = 1; ,
либо двойное слово (в случае SB # Неуд) SIZE(ST)=4. Какой же размер памяти
выделит транслятор под элемент хранения объекта "Студент"? Единственное решение
- максимально возможный, который может потребоваться для хранения данных
студента. Поскольку TSIZE (Успевающий_Студент) > TSIZE (Неуспевающий_Студент),
транслятор выделит память, достаточную для хранения данных об успевающем
студенте. Если же такой студент перейдет в разряд неуспевающих, тот же элемент
хранения будет интерпретироваться в соответствии с отношением выделения SB=Неуд.
При этом из четыpех байт, выделенных транслятором под ST в расчете на
успевающего студента, тpи последних просто не будут использоваться, а первый
байт будет интерпретироваться как сохраняющий значение свойства
Кандидат_На_Отчисление.
Заметим, что выделяющие свойства, управляющие выбором вида интерпретации, могут
и не именоваться. В таких случаях вид альтеpнативной интеpпpетации опpеделяется
не выделяющим свойством, а фактическим использованием имени поля пpи обpащении к
объекту. Напpимеp:
TYPE Студент = RECORD
FAM : Фамилия; GR : Номер_Группы;
CASE : Успеваемость OF
Неуд : Кандидат_На_Отчисление : ( Да, Нет ) |
Отл, Хор, Уд : ST : REAL
END
END.
Пусть VAR V: Студент. Пpи этом в элементе хpанения для V выделяющее поле вообще
отсутствует, постоянная часть имеет pазмеp TSIZE(Фамилия)+SIZE(GR), а
альтеpнативная имеет pазмеp
max {SIZE(Кандидат_На_Отчисление), SIZE(ST)}.
Обpащение к объекту чеpез квалидент V.Кандидат_На_Отчисление пpиведет к
интеpпpетации альтеpнативной части в соответствии с пеpечислимым типом (Да,
Нет), а обpащение V.ST - к интеpпpетации той же части в соответствии с типом
REAL. Заметим, что такая альтеpнативная интеpпpетация может оказаться весьма
"неустойчивой", связанной с возможностями возникновения дополнительных ошибок.
Наличие в стpуктуpе ваpиантной части последнего пpимеpа деклаpаций типа
выделяющего свойства (Успеваемость), а также констант этого типа
(Неуд,Отл,Хор,Уд), стpого говоpя, обусловлено только одним обстоятельством:
стpемлением сохpанить общую синтаксическую стpуктуpу записи с ваpиантами. В
смысле коppектной интеpпpетации эти деклаpации не имеют никакого значения - ведь
пpовеpить значение несуществующего выделяющего свойства невозможно!
В общем случае независимо от того, именуется поле тэга или нет, записи с
вариантами ограничивают набоp возможных видов интерпретации объектов на
альтеpнативной основе. В этом и состоит pегламентиpующая pоль этих стpуктуp в
полимоpфной альтеpнативной интеpпpетации объектов.
Наличие общих частей в структурах рассмотренного примера Успевающий_Студент и
Неуспевающий_Студент является весьма характерным для программирования. В этом
смысле записи с вариантами можно рассматривать как форму лаконичного описания
типов, позволяющую избавиться от повторов в описании свойств объектов. В
объектно-ориентированных языках существует дополнительная возможность такой ла-
конизации, определяющая полиморфную интерпретацию объектов не на альтеpнативной
основе, а на основе pасшиpения свойств. Эта возможность связана с механизмом
наследования свойств.
Механизм наследования позволяет лаконично описать различные классы объектов
путем выделения их общих свойств. Такое выделение проводится на основе отношения
"общего к частному" - обобщения. Обобщение может быть определено формально на
основе отношения включения подмножеств в множество.
Пусть А - класс объектов с имманентными свойствами Р(A): A = {a/P(A)}, a B =
{b/P(B)}. Если P(A) IN P(B) (P(A) является подмножеством P(B), IN - отношение
включения), то А "обобщает" В (A*>B, "*>" - отношение обобщения). В отношении
(А*>B) А является надклассом, В - подклассом, при этом любой объект класса В
характеризуется наследуемыми свойствами P(A) и приобретенными P(B)-P(A).
Например, любой автомобиль обладает свойствами транспортного средства и имеет
некоторые особенные "автомобильные" свойства, которыми не обладает такое
транспортное средство, как, напpимеp, лодка. В этом смысле
Транспортное_Средство *> Автомобиль, Лодка.
Причем Р(Автомобиль)^P(Лодка) = P(Транспортное_Средство). (Здесь символ "^"
используется как "пересечение множеств"). Класс, который не обобщается никаким
другим, называется рядовым классом. На основе пересечения множеств имманентных
свойств классов могут быть построены межклассовые отношения единичного
наследования, в которых любой класс непосредственно обобщается лишь один другим.
Например,
Транспортное_Средство
*
¦
-------------------+---------------------¬
¦ ¦
¦Автомобиль ¦Лодка
------*-----¬ ------*-----¬
¦ ¦ ¦ ¦
¦ ¦ ¦ ¦
* * * *
Грузовик Легковой Байдарка Ял
автомобиль
¦
¦
¦
*
Самосвал
Семантика обобщения как отношения общего к частному и стремление повысить
лаконичность описания классов на основе единичного наследования не всегда
"выглядят" адекватно. Например,
TYPE Узел = RECORD
A: Болт; B: Гайка;
END; .
Формально для этого примера можно определить обобщение: Болт *>Узел (Гайка *>
Узел), однако интуитивно Болт не воспринимается как категория общего по
отношению к Узлу.
Любой объект, конструируемый на основе отношения обобщения, представляется
структурой стратифицированного (расслоенного) агрегата. Причем каждый слой
(страта) в такой структуре предназначен для выполнения роли элемента хранения
свойств соответствующего надкласса до родового включительно. Например, любой
объект класса "Ял" (см. схему выше) будет определяться структурой:
TYPE Структура Яла = RECORD
А: Транспортное_Средство;
В: Лодка;
С: Ял;
END; .
Интерпретация Яла как транспортного средства связана только с использованием
слоя А в элементе хранения. Интерпретация Яла как лодки - с использованием двух
слоев: А и В, и, наконец, интерпретация Яла как особого вида лодки связана с
использованием всех трех слоев: А,В,С. Декларация вида "Структура_Яла" в
объектно-ориентированном языке заменяется отношением
Ял <* Лодка <* Транспортное_Средство.
Такая декларация определяет три возможные интерпретации объекта на разных
уровнях обобщения (pасшиpения свойств).
Еще pаз подчеpкнем, что между двумя рассмотренными видами полиморфной интер-
претации объектов (записи с вариантами и наследование свойств) существует
принципиальное различие: записи с вариантами реализуют полиморфную интерпретацию
на альтернативной основе, а механизм наследованиния - на основе расширения
свойств классов.
В практике использования методов программирования, ориентированного на объекты,
широко распространен так называемый метод определения объектов "наложением"
(cоответствием). Этот метод может быть реализован разными способами, мы его
рассмотрим на примерах, используя концепцию типа как "трафарета" (маски), опре-
деляющего вид интерпретации объекта "под маской". Конструируя средствами языка
различные "маски", программист получает возможности полиморфной интерпретации
объекта.
Пример1.
TYPE POINT = RECORD X,Y: INTEGER END;
Point = RECORD Y,X: INTEGER END;
VAR A: ARRAY[1..2] OF WORD;
P: POINTER TO POINT;
p: POINTER TO Point;
X,Y: INTEGER;
BEGIN X:=1; Y:=5;
P:=ADR(A); (*1*)
P^.X:=X; P^.Y:=Y; (*2*)
p:=ADDRESS(P); (*3*)
X:=p^.X; Y:=p^.Y (*4*)
Этот пример реализует "трансформацию" объекта-точки с декартовыми координататами
(1,5) в объект-точку с координатами (5,1). В программе задан элемент хранения А
размером в два слова, "маска" POINT, "привязанная" к указателю Р, и "маска"
Point, связанная с ограниченным указателем р. Операция (1) связана с
"наложением" маски POINT на элемент хранения А и записью "через трафарет" значе-
ний координат точки в область памяти А. Операция (3) связана с наложением на ту
же область памяти маски (трафарета) Point и чтением координат точки через новый
трафарет. Таким образом, один и тот же объект, размещенный в А, интерпретируется
в этом примере двояко: как точка с координатами (1,5) и симметричная ей точка с
координатами (5,1). Заметим, что реально никакого преобразования координат не
происходит, - все определяетсся структурой трафарета - маски, через которуюю мы
смотрим на объект. (Расссматривая этот пример, ответьте на вопрос, почему для
записи операторов (2) и (4) не используется присоединение?)
Поскольку множественность интерпретаций объекта определяется множеством масок,
которые могут накладываться на одну и ту же область памяти, использование метода
наложения связано с контролем размеров таких масок, соответствия их размерам
элементов хранения и т.д. "Выход" маски за пределы элемента хранения интерпрети-
руемого объекта чреват непредсказуемыми ошибками (работа с "чужой" областью
памяти). Наложение нескольких масок на один и тот же объект желательно выполнять
по адресу элемента хранения объекта без дополнительных смещений "внутрь"
структуры объекта. Если несколько разных масок частично совместны (имеют части с
идентичными атрибутами, одинаково интерпретируемые части), желательно общие
идентичные части располагать в начале маски (вверху), а не в середине или в
конце (внизу). Эти простые рекомендации помогают избежать многих ошибок,
связанных с полиморфной интерпретацией объекта. (Заметим, что такие ошибки имеют
свойства скрытого "проявления", очень трудно обнаруживаются и идентифицируются).
Во многих прикладных задачах метод наложения связан с использованием масок,
определяемых структурами различных массивов. Например, задан массив кардинальных
чисел и требуется его "трансформировать" в массив символов. Наложение в этом
случае является наиболее "естественным" методом такой трансформации:
VAR C: ARRAY [1..100] OF CARDINAL;
P: POINTER TO ARRAY [1..200] OF CHAR;
CH: ARRAY [1..200] OF CHAR;
BEGIN
P := ADR(C); FOR I:=1 TO 200 DO CH[I]:=P^[I] END;...
Такие задачи связаны, как правило, с перекодировкой, преобразованием,
трансформацией и т.п. больших массивов. Успех использования метода наложения
здесь полностью определяется тем, удастся ли подобрать адекватную структуру
маски-трафарета. Если удастся, то подобные преобразования могут быть выполнены
очень просто, без использования специальных вычислений, связанных с различными
форматами хранения данных, и неизменно сопутствующей им адресной арифметики.
Попутно заметим, что использование метода наложения может помочь "обойти" многие
ограничения, связанные с языком программирования. Например, используя наложение
при интерпретации объектов, размещаемых в классе динамической памяти, можно
"обойти" ограничения, связанные со статическими (константно - определяемыми)
размерами массивов.
В заключение этой главы остановимся на самоинтерпретируемых объектах.
Возможности самоинтерпретации связаны с использованием объектов процедурного
типа, объектов-действий. Эта разновидность объектов сравнительно мало
используется в технике "повседневного" программирования, в методологии же
объектно-ориентированного подхода им отводится особая роль, роль активных
объектов - акторов, определяющих динамику параллельно развивающихся процессов
интерпретации.
Процедурный тип (или сигнатура, см. pазд. II) определяет множество возможных
действий, видов активности. Например,
TYPE Действие = PROCEDURE (Станок);
определяет сигнатуру для класса Станок. Пусть множество действий над Станком
ограничивается двумя:
PROCEDURE Включить (С: Станок);
PROCEDURE Выключить (С: Станок); .
Декларация VAR D: Действие определяет объект класса Действие. Такой объект может
хранить потенциально возможное действие над Станком (т.е. "помнить", что нужно
сделать) и (в подходящее время) активизироваться (самоинтерпретироваться) по
отношению к станку:
VAR D: Действие; C: Станок;
BEGIN...
D:=Включить;...
D(C);... D:= Выключить;... D(C); .
Операторы D(C) в этом фрагменте определяют самоинтерпретацию объекта D в
отношении объекта С, а операторы присваивания - определение объекта D
потенциально возможным действием. Образно говоря, операторы присваивания здесь
"взводят курок" D, а когда D "выстрелит" и какой будет эффект от этого
"выстрела" (включает он станок С или выключает) определяется в общем случае
логикой программы. Использование в программе переменных класса Действие анало-
гично наличию множества взведенных курков, при этом отдельные "выстрелы"
превращаются в треск автоматных очередей - самоинтерпpетаций. Учитывая, что
любое действие, связанное с такой самоинтерпретацией, может переопределить
объекты-действия, логика выполнения подобных программ становится весьма
запутанной. Основное применение этого механизма - моделирование сложных систем.
V. СОЗДАНИЕ / УНИЧТОЖЕНИЕ ОБЪЕКТОВ
"Время жизни" объекта. - Классы памяти. - Управление динамической памятью. -
Фрагментация. - Проблемы "висячих" ссылок и мусора. - Автоматическая память. -
Локальная среда. - Активации объекта.
Объекты, существующие в программе, делятся на две категории: статические и
динамические. Эти категории определяются по-разному: на основе изменения
состояния объектов модели и на основе "времени жизни" объектов. Первое
определение предполагает, что любой объект, изменяющий свое состояние в процессе
работы программы, является динамическим. В этом отношении, строго говоря,
статическими объектами являются только константы, все объекты-переменные могут
считаться динамическими. Второе определение предполагает возможность временного
существования объектов, возможности создания и уничтожения объектов. В этом
смысле объекты, время существования которых равно времени выполнения программы,
расцениваются как постоянно существующие (статические), объекты же, время
существования (жизни) которых меньше времени выполнения программы - как динами-
ческие. Второе определение касается объектов, которые идентифицируются только
через указатели. Объекты, идентифицированные именем, в этом отношении всегда
должны расцениваться как статические, поскольку их "создание" подготавливается
транслятором и ассоциация между именем и элементом хранения объекта существует
до окончания вpемени pаботы программы.
Создание объекта следует интерпретировать как выделение памяти под его элемент
хранения. Такая интерпретация подразумевает разделение всего рабочего
пространства памяти ЭВМ на две категории, два класса - статическую память и
динамическую. Первый класс памяти, как следует из этого контекста, полностью на-
ходится под упpавлением тpанслятоpа и pаспpеделяется под статические объекты,
существующие в системе постоянно. Например, декларация
VAR A: POINTER TO CARDINAL;
B: CARDINAL;
сообщает транслятору о необходимости "зарезервировать" в классе статической
памяти два слова под элемент хранения объекта с именем А и одно слово под
элемент хранения объекта с именем В.
Динамическая память предназначается для создания временно существующих объектов.
Этот класс памяти имеет две разновидности: собственно динамическую и
автоматическую. Собственно динамическая память (в отличие от статической)
полностью находится в распоряжении программиста: по его директивам происходит
выделение элементов хранения (создание объектов) и возврат ранее выделенных
элементов в "зону" свободной памяти (пул "свободных" элементов), что в этом смы-
сле равносильно "уничтожению" объекта.
Автоматическая память - особая разновидность динамической, которая также
управляется директивами программиста, связанными с интерпретацией активных
объектов (переменных пpоцедуpных типов). В этом смысле две разновидности
динамической памяти делят этот класс памяти на два подкласса: память для
интерпретации пассивных объектов (собственно динамическая) и память для интер-
претации активных объектов (автоматическая). Несмотря на общность класса (дина-
мическая память), распределение памяти в этих подклассах основано на разных
принципах и реализуется совершенно разными алгоритмами.
Управление динамической памятью для пасссивных объектов (в дальнейшем просто
динамической памятью) реализуется на основе двух основных процедур (обычно
импортируемых из системного модуля):
PROCEDURE ALLOCATE (VAR A: ADDRESS; N: CARDINAL);
PROCEDURE DEALLOCATE (VAR A: ADDRESS; N: CARDINAL); .
Здесь А - свободный указатель, который укажет на выделенную область памяти
(элемент хранения размером N байт) при вызове ALLOCATE и получит значение NIL
(т.е. никуда не будет указывать) при освобождении этой области "из-под" А путем
вызова DEALLOCATE.
Использование ограниченных указателей делает во многих отношениях
целесообразным использование специальных вызовов: NEW(P) и DISPOSE(P), где VAR
P: POINTER TO . (NEW и DISPOSE - псевдопроцедуры, их вызовы
транслируются в вызовы ALLOCATE и DEALLOCATE соответственно). Использование NEW
и DISPOSE позволяет избежать многих семантических ошибок, связанных с различными
значениями N в последовательности вызовов ALLOCATE...DEALLOCATE, определяющей
создание/уничтожение одного и того же объекта.
В целом последовательность вызовов NEW...DISPOSE (или соответственно
ALLOCATE...DEALLOCATE), в общем случае полностью определяемая логикой
программиста, порождает ряд проблем, связанных с организацией и распределением
свободного пространства динамической памяти. Одной из таких проблем является
проблема фрагментации. Эффект фрагментации заключается в том, что рабочая
область динамической памяти "дробится" на части - фрагменты различной длины.
Какие-то из них "заняты" - используются программистом под элементы хранения его
объектов, какие-то "свободны", причем характер чередования свободных и занятых
фрагментов в общем случае может быть совершенно произвольным. Любой запрос
программиста на создание нового объекта приводит к тому, что система управления
динамической памятью "подбирает" ему фрагмент, подходящий по размерам. Правила
такого подбора могут быть различны, но общая закономерность одна: такой фрагмент
должен иметь размер, не меньший, чем запрашиваемый программистом. Если
подходящий фрагмент имеет больший размер, чем требуется, в прикладную программу
будет отдана его часть, котоpая тепеpь будет pассматpиваться системой как
занятый фpагмент, а остаток останется в свободной зоне в качестве свободного
фpагмента. При этом проблема фрагментации заключается в том, что эффект "дробле-
ния" может привести к тому, что в свободной зоне будет находиться множество
"маленьких" разрозненных свободных фрагментов, в совокупности составляющих
достаточный объем. Тем не менее, несмотря на такой объем, запрос программиста на
новый элемент памяти может получить отказ по причине отсутствия целого
подходящего элемента. Ниже приведен фрагмент программы и схема распределения ди-
намической памяти, иллюстрирующие эффект фрагментации. При этом для простоты
предполагается, что общий объем динамической памяти составляет 20 байт.
TYPE Треугольник = POINTER TO Фигура_1
Фигура_1 = RECORD
Сторона_1, Сторона_2, Сторона_3:CARDINAL
END;
Четырехугольник = POINTER TO Фигура_2;
Фигура_2 = RECORD
Сторона_1, Сторона_2, Сторона_3, Сторона_4:
CARDINAL
ЕND
VAR T1, T2: Треугольник; М1, М2: Четырехугольник;
BEGIN NEW(T1);... NEW(M1);... NEW(T2);...
DISPOSE(T1);... DISPOSE(T2); NEW(M2);...
--------------------¬ -¬
¦ WORD ¦ ¦
+-------------------+ ¦
¦ ¦ > Свободный фрагмент, ранее
+-------------------+ ¦ использованный под
¦ ¦ ¦ объект Т1^
+-------------------+ ---¬
¦-------------------¦ ¦
+-------------------+ ¦
¦-------------------¦ ¦
+-------------------+ > Фрагмент, занятый
¦-------------------¦ ¦ под объект М1^
+-------------------+ ¦
¦-------------------¦ ¦
+-------------------+ -¬--
¦ ¦ ¦
+-------------------+ ¦
¦ ¦ > Свободный фрагмент, ранее
+-------------------+ ¦ использованный под
¦ ¦ ¦ объект Т2^
L-------------------- --
Иллюстрация построена для момента обработки запроса NEW(M2). В этот момент
времени в динамической памяти имеются два свободных фрагмента общим объемом
шесть слов, которых достаточно для выполнения запроса на выделение элемента
хранения под объект М2^ (т.е. для объекта, на котоpый будет указывать M2),
однако фрагментация не позволяет системе выделить память под объект М2^.
Система управления динамической памятью ведет специальный список свободных
фpагментов - пул памяти. При возвращении какого-либо элемента хранения,
используемого в прикладной программе, в пул свободной памяти может быть
реализовано "склеивание" соседних свободных фpагментов в один фpагмент большего
объема. Например, если в предыдущей программе изменить последовательность
обращений к динамической памяти на приведенную ниже, то описанного выше отказа
по памяти не произойдет:
BEGIN NEW(T1);...NEW(T2);...NEW(M1);...
DISPOSE(T1);...DISPOSE(T2);... NEW(M2);...
Здесь при обработке запроса NEW(M2) в пуле динамической памяти будет находиться
один свободный фрагмент объема шесть слов, образованный "склеиванием" элементов
Т1^ и T2^, выполненным при обработке запроса DISPOSE(T2). В общем случае вопросы
эффективной реализации управления динамической памятью, обеспечивающей минимум
отказов при ограниченном объеме, составляют отдельную проблему. Здесь мы только
заметим, что с организацией выделения "первого подходящего" фрагмента памяти в
программировании связывают такие термины как "хип" или "куча", относящиеся
скорее к профессиональному жаргону, чем к научно-методической терминологии. Тем
не менее эти термины довольно образно характеризуют принципы организации
динамической памяти.
Организация корректной последовательности запросов связана, кроме того, как
минимум еще с двумя проблемами. На том же жаргоне их называют проблемы "висячих
ссылок" и "мусора", а определяют они две стороны одной и той же ошибки,
заключающейся в некорректной работе с указателями. Следующий фрагмент программы
иллюстрирует возникновение таких ошибок (тип "Треугольник" описан выше).
VAR T1, T2:Треугольник;
BEGIN NEW(T1);...T2:=T1;...
DISPOSE(T1); (* T2-"висячая ссылка" *)
............
NEW(T1);...NEW(T2);...
T1:=T2; (* Остался "мусор" *)
Из этого примера понятно, что "висячая ссылка" - это указатель прикладной
программы, указывающий на свободный фрагмент динамической памяти. Поскольку этот
фрагмент может быть выделен системой по какому-либо запросу другой прикладной
программе, Т2 может открыть доступ к "чужим" данным и "разрешить" их интерпре-
тацию как треугольника. Последствия такой интерпретации в общем случае непред-
сказуемы. Заметим, что "висячая" ссылка и "пустая" ссылка (имеющая значение NIL,
см. pазд.III) являются совершенно разными понятиями. "Мусор" - это занятый
фрагмент динамической памяти, к которому в прикладной программе потерян доступ.
В приведенном примере мусором оказался старый треугольник Т1^, на который
указывал Т1 до передвижки (установки на Т2). Этот мусор неустраним: программист
не имеет к нему доступа, а система управления "считает" мусор занятым фрагментом
памяти.
Объединяет эти два вида ошибок одно общее обстоятельство: они не обнаруживаются
исполнительной средой. Идентифицировать подобные ошибки можно только путем
тщательной проверки и отладки программы. И, наконец, по своим возможным влияниям
на работу программы мусор гораздо "безобиднее" висячей ссылки. Он фактически
приводит только к увеличенному расходу памяти, в то время как висячая ссылка
способна при определенных условиях полностью парализовать процесс выполнения
программы. В сложных системах "цена" висячей ссылки может оказаться очень
высокой.
Использование автоматической памяти связано с созданием / уничтожением
специальных элементов хранения, связанных с активными объектами - действиями или
процедурами. Любая процедура тpебует для выполнения собственной индивидуальной
локальной среды. Подобную среду образуют локальные переменные, объявленные в
процедуре, формальные параметры, элемент хранения адреса возврата в процедуру,
т.е. набор объектов, обеспечивающих выполнение действий, связанных с процедурой.
Необходимость в локальной среде возникает только в момент вызова процедуры -
момент интерпретации объекта процедурного типа. После завершения такой интерпре-
тации необходимость в локальной среде исчезает. Таким образом, время жизни
локальной среды ограничивается временем отработки программы, в которой она
описана. Соответственно запрос на создание локальной среды связан с вызовом про-
цедуры, а запрос на уничтожение - с окончанием фазы активности объекта (оператор
RETURN или END в теле процедуры). Например:
VAR W1, W2: PROC;
PROCEDURE Работа_1;
VAR A: INTEGER;... BEGIN... W2;...
END Работа_1;
PROCEDURE Работа_2;
VAR A: INTEGER;... BEGIN... W2;...
END Работа_2;
BEGIN... W1:=Работа_1;... W2:=Работа_2;... W1;...
В этом фрагменте описаны два активных объекта процедурного типа PROC =
PROCEDURE(): W1 и W2 и две процедуры без параметров: Работа_1 и Работа_2,
которые могут использоваться как константы типа PROC. Интерпретация
(активизация) W1 приведет к вызову Работы_1 и созданию локальной среды
(содержащей переменную А). В процессе выполнения Работы_1 производится
активизация объекта W2 и соответственно создание локальной среды для Работы_2.
В любой текущий момент времени в системе могут быть активны несколько объектов.
(В этом примере активизация W1 приводит к активизации W2, затем они оба остаются
в активном состоянии и затем теряют свою активность в обратной
последовательности: сначала пассивируется W2, затем W1). Последовательность
активации и пассивации связана с вложенностью вызовов процедур, соответственно
управление автоматической памятью основывается на использовании стека -
структуры, поддерживающей такую вложенность. Ниже для этого фрагмента приведена
иллюстрация распределения автоматической памяти, существующего в течение
совместной активности объектов W1 и W2.
-- --------------------¬ -¬
¦ ¦ Переменная А ¦ ¦
¦ +-------------------+ > Локальная среда
¦ ¦ Адрес возврата ¦ ¦ для W1
Занятое прост- < +-------------------+ -+
ранство ¦ ¦ Переменная А ¦ ¦
¦ +-------------------+ > Локальная среда
¦ ¦ Адрес возврата ¦ ¦ для W2
Вершина --> L- ¦-------------------+ -+
стека ¦ ¦ ¦
автоматической ¦ ¦ ¦
памяти ¦ ¦ ¦ Свободное
¦ ¦ > пространство
Пассивация ¦ ¦ ¦ памяти
¦ ^ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦
¦ ¦ ¦ ¦ ¦
v ¦ L-------------------- --
Активация
При активации каждого нового объекта вершина стека "опускается вниз" на
величину, определяемую размерами локальной среды этого объекта,- при его
пассивации вершина стека "поднимается вверх". С использованием автоматической
памяти связаны две основные проблемы: рекурсии и множественности ассоциаций.
Рекурсия - механизм, позволяющий объекту совершать самоактивац-ию. Например, по
схеме:
W1-->W1 (прямая рекурсия)
или W1-->W2 ...-->W1 (косвенная рекурсия).
Прямая рекурсия связана с непосредственной повторной (вложенной) активацией, а
косвенная - с опосредованной (причем число посредников в схеме W1-->...-->W1
может быть произвольным). Использование рекурсии напрямую связано с размерами
рабочего пространства автоматической памяти. Использование рекурсивных активаций
объектов, с одной стороны, позволяет иметь очень лаконичные и емкие по со-
держанию программы, с другой стороны, в рекурсивных схемах (особенно в косвенной
рекурсии) возрастает вероятность появления трудно идентифицируемых ошибок.
Множественность ассоциаций заключается в том, что в классе автоматической памяти
могут быть одновременно размещены несколько одноименных объектов, имеющих в
общем случае различные значения и относящиеся к разным активностям одного и того
же или опять-таки разных объектов. В приведенном примере существуют два одно-
именных объекта: переменная А, связанная (ассоциированная) с активностью W1, и
переменная А, ассоциированная с активностью объекта W2. В соответствии с
принципом стека система упpавления автоматической памятью всегда pассматpивает в
качестве активной последнюю созданную ассоциацию (самую "ближнюю" к вершине
стека автоматической памяти). Возникновение множественности ассоциаций
обусловлено только использованием в прикладных программах одноименных переменных
с различной областью действия (областью видимости). Если уж использование таких
переменных и является необходимым (в чем всегда стоит усомниться), то при их
интерпретации следует помнить о множественности ассоциаций.
------------------------------------А Б v Г Д q U Г m - -
h T ¤ e L ¦ b е T _ Z @
@ @ - x о + s ч ¦ n Ф й i з ¦ d L ¦-
_ w" Ы" Z B# B# C# t j# k# m r#
s# f а# б# _ Ў# ў# X •# ·# Q Н% w" Ы" Ї Ї
Ї Ї Ї Ї
Н% О% t с& т& m =' >' f P' Q' _ 0( 1( X 3( 4( Q q( w"
Ы" Ї Ї Ї Ї Ї Ї
q( ( v к( +( q ¬* ¦* l /+ N+ g S+ T+ ` я+ , [ , 5,
V 0 Ї
0 *0 v 51 X1 q Q9 b9 n ; у; k O< T< f У< Я< a Y= v=
\ OA
OA _A x yA ИA u -B -B p ЕC ЩC k -C ьC f TD eD a УD жD
\ 3J
3J CJ v ~J ЮJ q WK sK l ёL ўL g VN gN b hN iN _ "O 2O
Z +T
+T ;T v +T
3c 5c t Уc Фc m f f f g g a -g
щg ^ ak ik Y jk V +k +T
+k -k t
l #l o /m 0m h гp ·p c ]q nq a Чq ¦q _ +q Zr ] -t
Вu Z 7 7 7
Вu pv zv v
w 1w q +x яx l нy +y g |z Иz d +{ -{ a F~ b~ ^ BД
BД DД y dД eД w ЭД ЯД u +Д +Д s уД
фД q Е Е o >Е @Е m `Е aЕ k ПЕ СЕ i 7 7 7 7 7 7 7 7 7 С
Е ШЕ нЕ y +Е +Е w хЕ цЕ u Ж Ж s ЭЗ ¦З n Й -
Й i zЙ МЙ d YЛ ПЕ СЕ 7 7 7 7 YЛ jЛ v Л М q -
М уМ l шМ яМ g шН ЄН b UО aО ] Т Т V Т YЛ
Т Т t эТ r мЧ TЧ p +Ч -Ч n єЧ vЧ l Ш 4Ш j 6Ш `Ш h bШ
eШ f gШ КШ d 7 7 7 7 7 7 7
КШ МШ еШ y жШ оШ w ¬Ш -Ш u -Ш -Ш s уШ Щ q #Щ MЩ o OЩ
RЩ m _Щ ЙЩ k НЩ 7 7 7 7 7 7 7 7 7 7 НЩ ¬Щ y ¦Щ -Щ w =Щ ўЩ
u Ъ 2Ъ s 4Ъ ^Ъ q -Ы эЫ l +Э 'Ю j -
Ю .Ю h 6Ю 7Ю f 7 7 7 7 7 7 7 7 7Ю HЮ IЮ y RЮ SЮ w ]Ю ^
Ю u цЮ чЮ s ыЮ ЇЮ q ¤Ю Я o Я Я m Я XЯ k ZЯ 7 7 7 7
7 7 7 7 7 7 ZЯ ХЯ y ЧЯ TЯ w LЯ а u а Hа s Jа Ба q ъл м
l
- ¦- i b+ n+ f S¦ ZЯ 7 7 7 7 7 S¦ _¦ v "¦ A¦ q t
¦ П¦ l p- - g у+ х+ ` ¦ ¦ Y ¦ ¦ R b+
¦ ¦ ¦ t У¦ ж¦ o Я+ ¬+ j u¦ Л¦ e +¦
¦ ` Y- }- [ ф "ф X
"ф Aх [х x Qц mц s нц Tц n +ш тш i шш Єш d #щ :щ _ Bщ
Pщ Z ы ы &ы v Оы еы q бь вь
o -ь -ь m э Pё k ~ё f zў d вў _ \ ]
ы 7 6 7 6 7 7 7
v \
c
s F
p K W m Z f j ¦ - g + C b \ s ]
s ъ v В М q L с l = h g - !-
b k- Ж- ] а# ¦# Z ь( ь( є( v 5,
N, t P, ?0 r A0 у1 p ц1 k @ i #@ d TB b -B ] ^G [ sG V ь( 6
7 6 7 6 7 7 7 7
sG НG y ЧG t LG
H o ¦M m -M h сM f уM a ыM ^ ?N +P \ ЄP Y СQ S W ь( 7 7 6
7 6 7 6 6 7
S :S v T t T o )T -T m -T сM f уM a ыM ^ ?N +P \ ЄP Y СQ
S W ь( 7 7 6 7 6 7 6 7 6 А Г i Ж W г J с J у
H +P \ ЄP Y C
B ! 7 р l L
_ U ] Г [ р < - ? C
B ! 7 р C
B ! 7 р Г Е n Ц k Ш i Ъ i Ь i Ю i а i в i
B ! 7 C <
B ! 7 р в д y ж y и y к y м y о y - l -
B ! 7 C
B ! 7 р C - L i ¦ g T e U c j c Ц c c Т c
B ! I C I y 3 w *
u E u . u T u = u
- Ё C ? I
= М y + w O u п u Б u 7" c F$ a з% a
C C - Ё C ? C з% +% y & y T& y f&
y Я& y ¦& y р& y ( y •* y -
y ? C
- ?-
y ¦. y ф0 y Н5 y к9 y -: y ; w у; u х; u
C ? C
х; ? y щ@ y &A y УA y ·B y лD y УG y -H y хH y I y
? C
I
I y N y ЇS y LU y ·U y +V y [V y wV y +W y TW y
? C
TW
X y +X y эZ y X[ y [ y ¬[ y т[ y ·[ y ,\ y +] y
? C
+]
^ y =^ y ?^ y &_ y Q_ y S_ y a y 7d y mg y Bh y
? C
Bh sh y uh y Hi y k y кk y мk y 1l y Nl y }l y +l y
? C
+l ъl y лm y Tm y ¦n y ·n y Зo y ¬o y Gp y [q y
? C
[q ]q y Йq y +q y q y +r y Xr y -s w Уt w -t u
? C G -t Вu y Дu y -
v y Jw y qw y Єy y ¦z y Їz y ({ y A{ y
C C
A{ e{ y k| y П| y ¦| y ¦| y Ь} y d~ y Я~ y б~ y + y
C C
+ tА y А y ¬А y +А y №А y Б y #Б y )Б y хБ y уГ y
C C
уГ хГ y
Д w Д w ,Д w .Д w PД w ЙД w лД w нД w
G C
нД ¦Д y Е y (Е y *Е y LЕ y {Е y ШЕ y пЕ y TЕ y Ж y
G G
Ж Ж y -
Ж y еИ w ўК w Л w {О w ХП w уП w Р w
C G Р Р y -Р y
С y 5С y lС y эТ y +У y dУ y ИУ y +У y
C C
+У ¦У y шФ w 2Ч u 4Ч u oЧ s qЧ s бЧ s =Ч s Ш s
G C I C
Ш 6Ш y gШ y МШ y -Ш y уШ y #Щ y _Щ y НЩ y =Щ y Ъ y
I G
Ъ 4Ъ y `Ъ y bЪ y vЫ w ЫЬ w ¬Ь w ьЬ w *Э w LЭ w
C G
LЭ -Э y +Э y 'Ю w рЮ w Я w ZЯ w ЧЯ w LЯ w а w
G C
а Jа y Га y Еа y ¬а w ¦а w Kв w 7д w tд w -д w
C G
-д щд y е y ле y -е y ж y <з y Bи y Уи y си y %й y
C C
%й [й y ¦й w єй u bм s dм q Жм q -м q -м q н q
C I C I C
н Hн y |н y Йн y Лн y &п y Є- y
- w ¦- u T- u C I
C ? C
T- є- y + y 9¦ y P¬ y Т¦ y ¬ y в- y +- y 5- y ~+ y
? C
~+ Ж+ y И+ y н+ y р+ y ў+ y z¦ y P¦ y +¦ y йT y -T y
? C
-T ¦ y \¦ y Ф¦ y ¦¦ y = y <= y 1+ y ю+ y Є¦ y вT y
? C
вT +T y TT y ¦T y T y %L y SL y vL y ПL y нL y TL y
? C
TL •L y - y - y ,- y F- y d- y В- y -- y -- y L- y
? C
L- пг y -г y ¦г y фг y + y '+ y d+ y М+ y Ы+ y и+ y
? C
и+ -+ y -
- y e- y г- w - u #¦ s 6¦ q O¦ q |¦ q
C I C I C |¦ Я¦ y -¦ y - y - y
- y -- y
р y Oу y hф y нц y
I C
нц +ч y 2ъ y hъ y Ўы y °ы y Vь w Бь w дь w
э w G C
э Dэ y Вэ y +э y ю y ?ю y ~ю y ¦ю y тю y ью y Ўю y
G G
Ўю я y
я y я y я w +я w •я w +Ё w PЁ w •Ё w
C G
•Ё {Є y }Є y Є y БЄ y є y 7є y \є y ~є y Ює y ї y
C C
ї @ї y ¦ї y ў y ў° y • y .• y [• y Б• y д• y ¦• y
C C
¦• у• y v• y 0· y e· y Ъ· y ¦· y T¦ y Ї y 2 y Z y
C C
Z Й y о y - y ^ y Ъ y - y +
y +
y Z
y L
y C C
L
Ё
y #
y ) y U y n y У y T y " y F w
? C F
y
y ы y ¦ y р y y - w ¦ u $- u
C I C $- ф- y & y d y c
y f" y с) y у) y * y 3* y o* y
I C
o* В* y ¬* y +* y + y U+ y i+ y д+ y -+ y $, y
I C
$, &, y (, y *, y P, y v, y Ы, y -, y - y R- y y-
y I G
y- а- y ¦- y ю-
y ). y b. y Й. y -. y +. y №. y !/ y
I G
!/ c/ y г/ y -/ y 0 y 0 w Й1 w x3 w и3 w с3 w
C G
с3 у3 y г6 y c8 y e8 y Ж8 y л8 y щ8 y 9 y +9 y e9 y
C C
e9 g9 y ю< y #? y C y 8C y XC y МC y жC y ¦C y ·C y
C C
·C D y RD y TD y кH y мH y ¦H w
I w QI w ПI w
G C
ПI LI y ёI y 4J y rJ y гJ y LJ y K y BK y ВK y ¬K y
G G
¬K ЎK y -
L y dL y ЫL y нL y уM w ?N w iN w аN w
C G
аN вN y +P y -T y -T ¦T
C C T =;L, C6К Л$ -: T
=;L, C6К Л$ ¦7------------------------------------------------------------
----------------------7
= ж C
п ' L- -4
; A гG N •T Z Р` jg jl +r ¦x -
~ ОГ К YР 8Ц ¦Ь 0д эй еп W¦ L¬ @T ¦L r¦ ЗL х+ а¦ #х vы Є w
° ¦ 0 @
в ш д 5$ X* ¬1 х7 +> LC -
L ЩR \T k B R u v
[ U
*
i
e [
< ъ X A Г -
] 2 z
9 ї = b - O ¦
! - " % # q $ ¦ %
& ' Б (
) P * о + 0 , н -
M . L / , 0 ? 1 9 2 ! 3 x 4 5
6 6 + 7 ---------------------------------------------------------
------------------------------------------------------------- =
\T ¦ ---------------------------------------------------
----------------------------- = Б \T Б ]T -----------------
-----------------------------------------------------------------------------
( 01/01/9412/03/93\T ---------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-----------------