Текст книги "Песни о Паскале (СИ)"
Автор книги: Олег Деревенец
Жанр:
Драматургия
сообщить о нарушении
Текущая страница: 25 (всего у книги 29 страниц)
Сборочный цех
Оглядев структуру модуля, войдем теперь в сборочный цех IDE и рассмотрим порядок соединения модулей в единую программу – исполняемый файл.
Рис. 149 – «Цех» компиляции и сборки проекта
Перед сборкой проекта все входящие в него библиотечные модули компилируются, в результате получаются файлы, расширения которых зависит от используемого компилятора. Так, для Borland Pascal файлы получат расширение TPU (это сокращение от «Turbo Pascal Unit»). Для Free Pascal это будут пары файлов с расширениями O и PPU. Модули можно компилировать как по отдельности, так и вместе со всем проектом. Рассмотрим оба случая.
Для компиляции отдельного модуля откройте его в редакторе и нажмите сочетание Alt+F9, или выберите пункт меню Compile –> Compile. Компилятор выполнит свою обычную работу по проверке ошибок и, при отсутствии таковых, сформирует библиотечный файл. На экране появится сообщение об успешной компиляции (рис. 150).
Рис.150 – Сообщение об успешной компиляции модуля
Если же выявятся синтаксические ошибки, вам придется устранить их.
Модули компилируются и в ходе сборки проекта. При нажатии клавиши F9 (или при выборе в меню Compile –> Make) компилятор просматривает списки импорта USES как в главной программе, так и в модулях. Обнаружив очередной модуль, компилятор сравнивает время редакции его исходного файла (PAS) со временем создания откомпилированного файла. Если исходный файл оказался свежее откомпилированного или последний пока не существует, то модуль компилируется. Так или иначе, но перед сборкой проекта все его модули будут скомпилированы. Только после удачной компиляции первичного файла и всех связанных с ним модулей создаётся исполняемый EXE–файл.
Фирменные библиотеки
Я уже упоминал о библиотеках, входящих в состав IDE, – они поставляются и в исходном, и в откомпилированном виде. Вы можете применять эти библиотеки наряду со своими, предварительно ознакомившись с ними по документации или по встроенной справке. Ощутить полезность фирменных библиотек можно по этой небольшой программе.
uses CRT; { Из CRT импортируются процедуры Sound, NoSound, Delay, ClrScr }
procedure Beep; { короткий гудок }
begin
Sound(300); { включение динамика на частоте 300 Гц }
Delay(500); { задержка на полсекунды }
NoSound; { отключение динамика }
end;
begin {– Главная программа –}
ClrScr; { очистка экрана }
Writeln(’Привет, Мартышка!’);
Beep; { короткий гудок }
Readln;
end.
Здесь на предварительно очищенный экран выводится приветствие, сопровождаемое коротким гудком. В программе используется ряд процедур из библиотеки CRT, – там собраны средства для работы с экраном. Для успешной компиляции надо указать компилятору путь к файлу «CRT.TPU». При установке среды программирования фирменные библиотеки обычно попадают в папку «…Units» (многоточием обозначена папка установки IDE). Уточнив положение библиотек, подскажите компилятору путь к месту их проживания через пункт меню Options –> Directories… (рис. 151).
Рис.151 – Указание пути к фирменным библиотекам
В данном примере предполагаем, что компилятор установлен в директорию «C:BP», а библиотечные модули размещены в папке «C:BPUNITS».
Динамически загружаемые библиотеки (DLL)
Порой несколько разных программ используют общие для них процедуры и функции. Если при их компиляции подключить общую библиотеку, то процедуры из неё войдут в каждую из программ, увеличивая их общий «вес». Кому-то пришла в голову мысль отделить библиотеку от использующих её программ так, чтобы библиотека загружалась в память лишь единожды в момент запуска первой из применяющих её программ. И тогда, при старте последующих программ, нужные им средства оказываются уже загруженными в память. Это уменьшает общий объём оперативной памяти, потребляемой всеми работающими программами. Динамически загружаемые библиотеки (DLL) могут разрабатываться не только на Паскале, но и на других языках (например, на Си или Ассемблере).
Итоги
• В программировании принято разделение труда, и для этого используют модульную технологию. Современные программы собирают из модулей, разработанных разными программистами.
• Модуль содержит все необходимое для выполнения логически связанных действий: константы, типы, переменные, процедуры и функции.
• Каждый модуль обладает именем и содержит две обязательные секции: секцию интерфейса и секцию реализации.
• Имя модуля должно совпадать с именем файла без расширения.
• Секция интерфейса содержит объявления, видимые за пределами модуля.
• Секция реализации содержит невидимые за пределами модуля объявления, а также тела процедур и функций.
• Для установки начальных значений глобальных переменных модуля применяют секцию инициализации.
А слабо?
А) Разбейте на два модуля проект «P_58_1» – обход графа в ширину. Что должно быть видимо за пределами модуля? Что поместить в секцию инициализации?
Задачи на темы предыдущих глав
Б) Императорские заботы. После постройки империи (главы 57 и 58) бывшие независимые государства стали провинциями и породили новые проблемы. Для доставки туда правительственных бумаг император нанял гонцов. Чтобы доставка была по возможности скорой, гонцы следовали кратчайшими путями лишь в одном направлении – от центра к окраинам империи. Сколько гонцов для этого нужно? – вот первый вопрос. Сколько времени потребуется для достижения самых дальних окраин, если переход из провинции в провинцию отнимает сутки? – это второй вопрос. В конечных пунктах (на окраинах) перед возвращением гонцам нужен отдых, что это за окраины, где надо построить гостиницы? – это третий вопрос.
Подсказка: возьмите за основу программу «P_58_1» – обход графа в ширину – и внесите необходимые дополнения в процедуру Expand.
Глава 60
Мелкие хитрости
Нелегко совладать с крупным проектом, и тут не грех прибегнуть ко всяким уловкам и хитростям!
Включаемые файлы
Рассмотрим ещё одно средство дробления программного проекта – включаемые файлы, которые называют ещё INCLUDE–файлами. В сравнении с библиотечными модулями возможности этих файлов скромны, но каждая вещь хороша на своем месте.
Механизм включаемых файлов до безобразия прост: содержимое такого файла как бы вставляется в другой. Место вставки определяется директивой $I, за которой следует имя вставляемого файла. Вы скажете, что вставку можно сделать иначе – редактором текста. Но ценность директивы $I в том, что вставки как таковой не происходит, – оба файла не изменяются. Но в момент компиляции проекта включаемый файл как бы составит часть того файла, в который он «вставлен».
Вот пример. Создадим и сохраним в рабочей папке два файла, первый из которых назовем «HELLO.INC», и в нём будет лишь одна строка.
Writeln(’Привет!’);
Второй файл – «HELLO.PAS» – будет таким.
begin {– Главная программа HELLO.PAS –}
{$I Hello}
end.
Компиляция файла «HELLO.PAS» породит приветливую программу. Здесь в директиве $I указано имя вставляемого файла без расширения, поскольку расширение INC берется по умолчанию. Разумеется, что INCLUDE–файл не вставишь куда попало, – его содержимое должно сочетаться с тем окружением, в которое его погружают.
Незамысловатый механизм включаемых файлов даёт ощутимую пользу, вот пример. Предположим, вы работаете над крупным проектом, состоящим из нескольких модулей. Время от времени вам надо компилировать эти модули вместе с первичным файлом так, чтобы опции компилятора для всех файлов совпадали. Такого совпадения можно добиться следующим образом:
Сначала настройте нужные опции компилятора через пункт меню Options –> Compiler…. Затем создайте новый файл и вставьте в него директивы компиляции нажатием комбинации Ctrl+O+O; в результате в файле могут оказаться такие, например, строки.
{$A+,B-,D+,E-,F-,G+,I-,L+,N+,O-,P-,Q-,R-,S-,T+,V-,X+,Y+}
{$M 16384,0,655360}
Сохраните этот файл, пусть он называется «Options.inc» (не забудьте указать расширение). Затем в первой строке каждого модуля, где вы намерены применить эти опции, вставьте директиву {$I Options}.
{$I Options}
...
Теперь компиляция всех файлов с одинаковыми настройками гарантирована, поскольку опции, заданные в директивах, преобладают над «менюшными». Потребовалось изменить настройки? – тогда исправьте только файл «Options.inc» и повторно откомпилируйте проект.
Условная компиляция
Моряка украшает загрубелое лицо, землекопа выдают мозолистые руки, а программиста – шишки, набитые при отладке программ. И это не шутка! Отладка – пожалуй, самая сложная часть работы, и здесь уместны разные хитрости.
Одно из таких ухищрений – печать промежуточных результатов или так называемая трассировка, – вы знакомы с этим приемом. По завершении отладки, расставленные там и сям, операторы трассировки только мешают, – их приходится удалять. Умные программисты не убирают их навсегда, а комментируют, то есть заключают в фигурные скобки, – а вдруг ещё пригодятся? А хитрые поступают иначе. «Зачем мне копаться в файлах проекта, выискивая лишние операторы? – рассуждают они, – пусть компилятор сделает это сам». Здесь они уповают на условную компиляцию.
Условная компиляция – это механизм, встроенный в компиляторы многих современных языков. Через него можно указать части программы, которые, в определенных случаях, компилировать не следует. Пропущенные таким образом куски программы равносильны комментариям. Условная компиляция организуется двумя директивами, с которыми мы сейчас ознакомимся.
Первая из них – $DEFINE – определяет некоторое имя. Это имя никак не связано с именами переменных, процедур и прочих объектов программы и может даже совпадать с ними – это не опасно. Определенное директивой имя используется лишь для условной компиляции так, как это будет показано далее. Вот парочка примеров определения таких имен.
{ $define Test }
{ $define Print }
Вторая директива – это собственно директива условной компиляции. Она похожа на условный оператор Паскаля, – не путайте их! Условный оператор срабатывает при исполнении программы, а директива – при компиляции проекта. Повторяю: директива условной компиляции – это всего лишь подсказка компилятору со стороны программиста!
Подобно условному оператору, такая директива выражается тремя словами, образующими две ветви компиляции.
{ $ifdef ABC – начало директивы }
{ эта часть скомпилируется, если имя ABC определено }
{ $else }
{ эта часть скомпилируется, если имя ABC НЕ определено }
{ $endif }
Посредством $IFDEF компилятор проверяет, определено ли где-то ранее директивой $DEFINE некоторое имя. Если да, то следующие за директивой операторы, вплоть до $ELSE будут откомпилированы, а иначе – пропущены. Операторы, следующие за $ELSE, ждет обратная участь. Возможен и сокращенный вариант директивы, содержащий лишь одну ветвь компиляции.
{ $ifdef ABC – начало директивы }
{ эта часть скомпилируется, если имя ABC определено }
{ $endif }
Таким образом, пара директив $DEFINE и $IFDEF-$ELSE-$ENDIF совместно образуют механизм условной компиляции.
Рассмотрим ещё пример. Предположим, вы пишите программу, выводящую результат в дисковый файл, однако при отладке вам хочется наблюдать результат на экране. Ну что ж, перенаправить вывод на экран совсем несложно, достаточно указать для файла пустое имя. Но при этом надо ещё организовать остановку программы после вывода на экран, чтобы успеть рассмотреть что-то. По окончании отладки надо восстановить имя дискового файла и удалить лишний оператор. Все эти хитрости легко устроить директивами условной компиляции.
{$define Debug – Определяем признак отладочной компиляции }
const
{$ifdef Debug}
FName = ''; { Предстоит вывод на экран }
{$else}
FName = 'Hello.out'; { Предстоит вывод в файл на диске }
{$endif}
var F : text;
begin
Assign (F, FName); Rewrite(F);
Writeln(F, ’Привет, мартышка!');
{$ifdef Debug} Readln; {$endif}
Close(F);
end.
Здесь определено некое условное имя Debug (отладка), а программа содержит два варианта вывода: на экран и в файл. Разумеется, что после компиляции такой программы вывод пойдет на экран. Но переделка программы в боевую версию будет элементарна: достаточно удалить знак доллара в первой строке, и тогда директива $DEFINE превратится в безобидный комментарий.
{ define Debug – это всего лишь комментарий, а не директива! }
Теперь, когда условное имя Debug не определено, при повторной компиляции константа FName примет значение «Hello.out», оператор Readln не откомпилируется, и мы получим вывод в дисковый файл.
А что, если надо компилировать многофайловый проект в разных вариантах: отладочном и боевом? Здесь разумно сосредоточить определения условных имен в одном месте, разместив их во включаемом файле (как мы сделали это с опциями компилятора). Возьмем, например, созданный ранее файл опций «Options.inc». Добавив в него определения условных имен, мы сможем воздействовать на компиляцию сразу всех файлов проекта.
{$A+,B-,D+,E-,F-,G+,I-,L+,N+,O-,P-,Q-,R-,S-,T+,V-,X+,Y+}
{$M 16384,0,655360}
{$define Test – действует на условия типа $IFDEF Test }
{$define Print – действует на условия типа $IFDEF Print }
Разумеется, что в модулях проекта должны быть расставлены надлежащие директивы условной компиляции.
Итоги
• Включаемые (INCLUDE) файлы – это части программы, которые в момент компиляции автоматически вставляются в указанные директивами $I места. Содержимое включаемого файла должно сочетаться с окружением, в которое оно вставляется.
• Условная компиляция – это удобное средство создания различных версий одной программы. Собрав условные имена и опции во включаемом файле, можно централизовано управлять компиляцией крупного проекта.
А слабо?
А) Создайте отладочный вариант программы обработки классного журнала (глава 31), в котором вывод результатов будет выполняться на экран. Примените условную компиляцию.
Задачи на темы предыдущих глав
Б) Контрразведка перехватила несколько зашифрованных файлов, и подозревала, что это тексты написанных на Паскале вирусов. Позвали Шерлока Ивановича Холмского в надежде, что тот расшифрует их. Шерлок Иванович предположил, что шифровали методом Юлия Цезаря (вспомните главу 24). Нужен ключ! После недолгих раздумий Шерлок Иванович создал программу для подбора ключей к таким текстам. Повторите ещё один «подвиг контрразведчика», или слабо? Подсказка: в таких файлах после расшифровки обязательно встречаются ключевые слова BEGIN и END – воспользуйтесь этим.
В) Рейтинговое голосование. Избирательный закон Иксляндии даёт каждому избирателю право голосовать за всех кандидатов, расставляя их в порядке своего предпочтения. Побеждает кандидат, набравший наименьшую сумму мест (если таковых несколько, то проводят второй тур). Предположим, баллотируются четыре кандидата с номерами 1-4, а бюллетени содержат следующие предпочтения избирателей:
3 4 2 1
2 4 3 1
4 1 3 2
Здесь первый кандидат набирает сумму 10, второй – 8, третий – 7, четвертый – 5. Таким образом, побеждает четвертый кандидат в списке.
Количество кандидатов известно и равно пяти. Ваша программа принимает файл, каждая строка которого содержит 5 чисел – данные одного бюллетеня. Надо выдать список победителей голосования (одного или нескольких).
Глава 61
«Кубики» программиста (ООП)
А напоследок отведайте волшебного объектно-ориентированного программирования (ООП). Эта технология преобразила ремесло программиста, – так пройдем ли мимо?
Фокус-покус
Вначале дадим слово Паскалю. Если вы работаете в IDE Borland Pascal, введите и запустите следующую программку. Только убедитесь в том, что библиотечный файл «APP.TPU» доступен компилятору (обычно он находится в папке «UNITS», где собраны фирменные библиотечные модули).
{P_61_1 – демонстрация работы Turbo Vision }
uses App;
var A : TApplication;
begin
A.Init;
A.Run;
A.Done;
end.
Как это работает? – не спрашивайте, ведь программка очень проста, что ещё надо? После ее запуска вам откроется следующая картина (рис. 152).
Рис.152 – Окно программы MyApp
Неужто «сломалась» IDE? В самом деле, где меню и окно с текстом программы? Да и статусная строка совсем не та. Но мышка по-прежнему бегает, и клавиатура жива. Можно щелкнуть по слову «Exit» и выйти из программы, или сделать то же самое нажатием Alt+X. Да, друзья, вы наблюдаете действие той самой малюсенькой программки! Ее поведение чудесно, но возможности этим не исчерпаны. Своей мощью она обязана объектам из библиотеки Turbo Vision, на которой построена вся IDE Borland Pascal.
Вместо паяльника
Все восторгаются объектным программированием. А откуда оно взялось?
Представьте, что при покупке телевизора вместо работающего изделия вам вручают его схему и коробку с деталями. И предлагают собрать телевизор самому! Примерно в таком же положении находились когда-то и программисты. Используемые ими библиотеки хранили массу полезных процедур и функций, – своего рода «схемы» для сборки программ. А «деталями» были обрабатываемые данные. Программист распределял эти данные в программе, придавая им нужную структуру, применял к данным в надлежащем порядке процедуры и функции, отслеживая при этом влияние одних данных на другие. Работа эта сродни сборке телевизора! Плодовитость программистов и качество их изделий оставляли желать лучшего, ненадежные программы было трудно править, да и пользоваться ими было неудобно.
Так вернемся к телевизору; что нужно знать мне, его владельцу? Всего лишь несколько кнопок: включить, отключить, выбрать канал, настроить громкость. И все! Остальное пусть будет спрятано. Вот бы и в программировании добиться такого удобства! Изобретатели ООП стремились именно к этой цели – упростить работу со сложной совокупностью данных. Они догадались объединить в одно целое данные и процедуры, их обрабатывающие. Совокупность данных и процедур назвали объектом.
На первый взгляд объект похож на запись. Но, в отличие от записи, большинство данных и процедур объекта спрятано внутри и не видно за его пределами. Снаружи доступно лишь то, что интересует пользователя объекта, – в этом объект похож на модуль (или на собранный телевизор).
На трех китах
Основу ООП составляют три идеи, три «кита», а именно:
• инкапсуляция;
• наследование;
• полиморфизм.
Рассмотрим их в этом порядке.
Примечание. Для примеров этой главы настройте компилятор в режим, совместимый с Borland Pascal.
Инкапсуляция
Инкапсуляция – это объединение данных и обрабатывающих их процедур. Рассмотрим простой пример: построим объект для хранения и обработки информации о человеке. Человеку свойственны такие атрибуты как год рождения, имя и фамилия. Поставим цель упростить работу с этими атрибутами, – создадим объект, способный хранить и распечатывать эту информацию.
Объявление объекта
Объявление объекта похоже на объявление записи, с той разницей, что ключевое слово RECORD заменяют словом OBJECT. В Delphi и совместимом с ним режиме Free Pascal применяют ключевое слово CLASS. Итак, «застолбим» место хранения информации о человеке тремя полями, как это показано ниже.
type TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
end;
Здесь объявлен тип данных TPerson (персона), содержащий три поля с данными о человеке. Для распечатки данных учредим процедуру по имени Report. Но процедура эта особая! Её заголовок помещен внутрь описания объекта следующим образом:
type TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
procedure Report; { процедура распечатки объекта }
end;
Методы
Процедуры и функции, объявленные внутри объекта, называют методами объекта. Методы, как и поля, – неотъемлемая часть объекта. Но объявить метод недостаточно, надо создать и его тело или, как принято говорить, реализацию метода. Реализация – это подпрограмма (процедура или функция), которая от обычной подпрограммы отличается заголовком: там к имени метода добавляется приставка, указывающая тип объекта, которому принадлежит метод. Реализация метода Report будет очень простой.
procedure TPerson.Report;
begin
Writeln(mBearing:6, 'Фамилия: '+mFam:20, ' Имя: '+mName);
end;
Процедура распечатывает атрибуты человека. Но откуда она берет их? – эти данные не передаются через параметры, и не хранятся в глобальных переменных. Они объявлены как поля объекта, и этого достаточно, чтобы метод объекта получил доступ к ним.
Инициализация, конструктор
Поля объекта, как любые переменные, нуждаются в инициализации. Как проще осуществить её? Можно присвоить значения полям так, как это делается для записей.
var P : TPerson; { переменная-объект }
begin
P.mFam:=’Сидоров’;
P.mName:= ’Тимофей’;
end.
Но, когда полей много, вы забудете что-то – в этом слабость идеи. Куда надежней учредить особый метод для инициализации полей. Такой метод и назван особо – конструктор. Вместо слова PROCEDURE перед именем конструктора так и пишут: CONSTRUCTOR. Назвать конструктор можно как угодно, но по традиции ему дают имена Init (инициализировать) или Create (создать). Например, для нашего объекта объявить конструктор и реализовать его тело можно так:
type TPerson = object
{... }
{ заголовок конструктора внутри объекта }
constructor Init(aBearing: integer; const aName, aFam : string);
end;
{ реализация конструктора }
constructor TPerson.Init(aBearing: integer; const aName, aFam : string);
begin
mBearing:= aBearing; mName:= aName; mFam:= aFam;
end;
В этом примере конструктор Init копирует три своих параметра в поля объекта. Теперь переменную-объект P можно инициализировать вызовом конструктора.
var P : TPerson; { переменная-объект }
begin
P.Init(1995, 'Мария', 'Рыбкина');
Так ни одно поле объекта не будет пропущено, – за этим присмотрит компилятор!
Вот пока все, что следует сказать об инкапсуляции. Приведенный ниже пример «P_61_2» демонстрирует объект типа TPerson: здесь описана его структура и реализация методов, а затем объявлены две переменные, выполнена их инициализация и распечатка полей.
{ P_61_2 Программа с применением объекта типа «человек» (персона) }
type TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
constructor Init(aBearing: integer; const aName, aFam : string);
procedure Report; { процедура распечатки объекта }
end;
{– Реализация двух методов объекта –}
constructor TPerson.Init(aBearing: integer; const aName, aFam : string);
begin
mBearing := aBearing; mName := aName; mFam := aFam;
end;
procedure TPerson.Report;
begin
Writeln(mBearing:6, 'Фамилия: '+mFam:20, ' Имя: '+mName);
end;
var P1, P2 : TPerson; { две переменных объектного типа }
begin {– Главная программа –}
P1.Init(1985, 'Иван', 'Грозный');
P2.Init(1995, 'Мария', 'Рыбкина');
P1.Report;
P2.Report;
Readln;
end.
Наследование
Кажется, что инкапсуляция не упростила программирование. Да, это так, если рассматривать её в отрыве от других механизмов ООП: наследования и полиморфизма. Выигрыш мы ощутим, когда в ход пойдут все рычаги.
Наследование даёт возможность создавать новые типы объектов на основе существующих. Вновь создаваемые типы объектов – потомки – приобретают в наследство поля и методы своих предков. И вдобавок могут содержать новые поля и методы, а также изменять унаследованные.
Например, взяв почти готовый объект – окно в библиотеке, – программист добавляет к нему свои поля, методы и получает другой тип окна, работающий схожим образом, но с учетом потребностей программиста. При этом ему не придется вникать в тонкости объекта-предка, достаточно ознакомиться лишь с несколькими основными методами (подобно тому, как пользователю телевизора хватает лишь нескольких кнопок). Не нужен даже исходный текст модуля с описанием объекта-предка!
И это не все. Постройка одних объектов на основе других формирует иерархию родственных объектов. С разными объектами в этой иерархии можно обращаться сходным образом, – это и есть полиморфизм. Буквальный перевод этого слова – «многоструктурность» – почти ничего не объясняет. Принципы наследования и полиморфизма легче понять на примере.
Приборостроение
Я знаю, чем напичкан ваш дом, – электрическими приборами. И простыми, такими, как лампочка или утюг. И сложными, – телевизор, стиральная машина, компьютер, наконец. Взглянем на них глазами программиста: любой такой прибор, выражаясь языком ООП, обладает, по крайней мере, двумя общими «методами» – включить и отключить. В разных приборах эти операции выполняются по-разному, но в целом они сходны. Можно сказать, что эти методы – общие свойства всех электроприборов.
Если бы приборы создавал программист, то построил бы их на базе общего предка – абстрактного (воображаемого) электрического прибора. Этот прибор обладал бы двумя методами: включить и отключить. На Паскале этот абстрактный электроприбор был бы объявлен так:
type Электроприбор = object
procedure Включить; virtual;
procedure Отключить; virtual;
end;
Здесь встречаем новое «волшебное» словечко – VIRTUAL, что значит «воображаемый». Это ключевое слово Паскаля следует за объявлением тех методов объекта, которые разрешено изменять в его наследниках. Изменение метода в наследниках называют переопределением метода. Итак, слово VIRTUAL указывает компилятору, что в наследниках методы включения и отключения прибора могут быть изменены в соответствии с особенностями этих наследников. К примеру, лампочка и телевизор включаются по-разному.
Основав абстрактный электроприбор, построим на нём прибор «чисто конкретный», например, телевизор.
type Телевизор = object (Электроприбор)
procedure Включить; virtual;
procedure Отключить; virtual;
procedure Выбрать_канал;
procedure Настроить_громкость;
procedure Настроить_яркость;
end;
Поскольку телевизор порожден от электроприбора, название его предка – «электроприбор» – указано в скобках за ключевым словом OBJECT. Наследник обязан помнить о предке, ссылаться на него, иначе не получит своего наследства – полей и методов. Виртуальные методы включить и отключить объявлены в наследнике точно так же, но будут реализованы иначе. К ним добавлены ещё три метода, характерные именно для телевизора. Схожим образом строятся и другие «конкретные» электроприборы. В результате сформируется иерархия родственных объектов, показанная на рис. 153.
Рис.153 – Иерархия электрических приборов
Гражданское строительство
Но все это лишь присказка, теперь испытаем наследование и полиморфизм в деле. Создадим на базе спроектированного ранее объекта TPerson (человек) два новых типа данных: военнослужащий (TMilitary) и гражданский чиновник (TCivil), иерархия этих типов изображена на рис. 154. Эти новые типы «людей» будут содержать дополнительные поля с характерной для наследников информацией. Вдобавок изменим конструктор Init и метод Report с тем, чтобы учесть наличие новых полей. Конструктор будет содержать дополнительный параметр, а процедура распечатки – выводить на экран ещё одно поле объекта.
Рис.154 – Иерархия «человеческих» типов
Объявление
Начнем с военнослужащего, чем разнится он от простых смертных? Гордым воинским званием – от рядового до маршала. Для хранения воинского звания в объекте TMilitary добавим строковое поле mRank (Rank – звание). Ясно, что при создании объекта конструктором надо указать этот элемент. Добавим ещё один параметр конструктору объекта Init – параметр aRank, и тогда заголовок конструктора в объекте TMilitary станет таким.
constructor Init(aBearing: integer; const aName, aFam, aRank : string);
В новом конструкторе больше параметров, и работать он будет, в сравнении с предком, чуть иначе. Другими словами, в наследнике он переопределен. А если так, то где же волшебное слово VIRTUAL? Его здесь нет и не должно быть, поскольку конструктор виртуален по определению.
Теперь обратимся к процедуре распечатки Report. В наследнике она, кроме прочего, должна распечатать поле воинского звания, а значит, будет переопределена. Поэтому и объявлена виртуальной, причем и в наследнике TMilitary, и в его предке TPerson. Это необходимо, поскольку лишь виртуальный метод предка может быть виртуальным у наследника: виртуальность передается по наследству. С учетом всего сказанного, объявления типов TPerson и TMilitary теперь будут такими.
TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
constructor Init(aBearing: integer; const aName, aFam : string);
procedure Report; virtual;
end;
TMilitary = object (TPerson)
mRank : string; { воинское звание }
constructor Init(aBearing: integer; const aName, aFam,
aRank : string);
procedure Report; virtual;
end;
Подытожим все изменения. В предке TPerson процедура Report стала виртуальной. В наследнике TMilitary добавлено поле mRank, а также изменены два метода: конструктор и процедура Report.
«Отселение» в отдельный модуль
Настало время реализовать методы наследника. Но прежде, чем взяться за это, совершим одно полезное дельце – переместим объект-предок TPerson в отдельный модуль. Именно так поступают профессионалы, создавая библиотеки объектов. Порядок создания программного модуля подробно изложен в главе 59, вкратце я напомню основные шаги.
Итак, создайте новый файл, перенесите туда через буфер обмена объявление типа TPerson и реализацию его методов. Объявление объекта разместите в секции INTERFACE модуля, а реализацию – в секции IMPLEMENTATION. И не забудьте объявить виртуальной процедуру Report. Дайте модулю имя PERSON и сохраните под именем «PERSON.PAS». У вас получится файл, показанный ниже. В нём объявлен ещё один тип данных – указатель на объект PPerson, но к нему обратимся позже.
unit Person; { Модуль, содержащий описание и реализацию объекта «ЧЕЛОВЕК» }
interface
type PPerson = ^TPerson; { указатель на объект «ЧЕЛОВЕК» }
TPerson = object
mBearing : integer; { год рождения }
mName : string; { имя }
mFam : string; { фамилия }
constructor Init(aBearing: integer; const aName, aFam : string);
