К. Ю.

Поляков

ПРОГРАММИРОВАНИЕ
 К. Ю. Поляков. Программирование. Python. C++. Часть 1
К. Ю. Поляков. Программирование. Python. C++. Часть 2
К. Ю. Поляков. Программирование. Python. C++. Часть 3
К. Ю. Поляков. Программирование. Python. C++. Часть 4

12+
К. Ю. Поляков

ПРОГРАММИРОВАНИЕ
Python
C++

Часть 4

Учебное пособие
для общеобразовательных
организаций

Москва
БИНОМ. Лаборатория знаний
*4* 2019
УДК 004.9
ББК 32.97
П54

Поляков К. Ю.
П54 Программирование. Python. C++. Часть 4 : учебное
пособие / К. Ю. Поляков. — М. : БИНОМ. Лаборатория
знаний, 2019. — 192 с. : ил.
ISBN 978-5-9963-4137-5
Книга представляет собой завершающую, четвёртую часть серии
учебных пособий по программированию. В отличие от большинства
аналогичных изданий, в ней представлены два языка программирова­
ния высокого уровня — Python и C++.
Главные темы пособия — объектно-ориентированное программиро­
вание и создание программ с графическим интерфейсом. Изучаются ос­
новные принципы объектного подхода к созданию программ: абстрак­
ция, инкапсуляция, наследование, полиморфизм. Изложение ведётся
на примерах программирования игр, в которых моделируются системы
взаимодействующих объектов.
Для демонстрации возможностей сред быстрой разработки про­
грамм в последней части пособия рассмотрены примеры приложений
на языке С#.
После каждого параграфа приводится большое число заданий для
самостоятельного выполнения разной сложности и вариантов проек­
тных работ.
Пособие предназначено для учащихся средних школ.
УДК 004.9
ББК 32.97

Учебное издание
Поляков Константин Юрьевич

ПРОГРАММИРОВАНИЕ
Python. C++
Часть 4
Учебное пособие
Ведущий редактор О. А. Полежаева
Концепция внешнего оформления В. А. Андрианов
Художественный редактор Н, А. Новак
Технический редактор Е. В. Денюкова
Корректор Е. Н. Клишина
Компьютерная верстка: В. А. Носенко
(12+)
Подписано в печать 06.09.2018. Формат 84x108/16. Усл. печ. л. 20,16
Тираж 3 000 экз. Заказ № м7023.
ООО «БИНОМ. Лаборатория знаний»
127473, Москва, ул. Краснопролетарская, д. 16, стр. 3,
тел. (495)181-53-44, e-mail: [email protected]
http://Lbz.ru, http://metodist.Lbz.ru
Отпечатано в филиале «Смоленский полиграфический комбинат»
ОАО «Издательство «Высшая школа». 214020, Смоленск, ул. Смольянинова, 1
Тел.: +7 (4812) 31-11-96. Факс: +7 (4812) 31-31-70
E-mail: [email protected] http://www.smolpk.ru

© ООО «БИНОМ. Лаборатория знаний», 2019

© Художественное оформление
ООО «БИНОМ. Лаборатория знаний», 2019
ISBN 978-5-9963-4137-5 Все права защищены
ПРЕДИСЛОВИЕ

Перед вами — последняя, четвёртая часть учебного пособия по про­

граммированию на языках Python и C++. Она посвящена очень важ­
ному подходу к разработке программ — объектно-ориентированному
программированию (ООП). Именно переход к ООП в конце XX века
позволил повысить скорость разработки и надёжность больших и слож­
ных программ, код которых состоит из сотен тысяч и даже миллионов
строк. Большинство современных профессиональных программ построе­
ны на принципах ООП.
С точки зрения ООП, вся программа — это множество объектов,
взаимодействующих между собой. Каждый объект относится к некото­
рому классу — группе объектов с общими свойствами. Класс объеди­
няет вместе данные и методы их обработки. Более того, объекты, как
правило, «не разрешают» другим объектам работать со своими данны­
ми, и это уменьшает вероятность ошибок.
Создание объектно-ориентированной программы начинается с анали­
за: нужно выделить в задаче объекты, описать их данные (свойства)
и методы управления этими данными, т. е. те команды, на которые
будет «откликаться» объект. И только после этого приступают к коди­
рованию алгоритмов на каком-либо объектно-ориентированном языке.
Мы будем рассматривать все идеи ООП на практических примерах,
в том числе применим эти идеи для программирования игр. С помо­
щью пособия вы сможете построить «каркас» игры, который потом не­
сложно будет доработать так, как вам захочется.
Сначала, как и в предыдущих частях пособия, мы рассмотрим язык
Python. Он использует «неклассическую» модель работы с объектами,
которая позволяет полностью управлять каждым объектом из любой
точки программы. В то же время злоупотребление этой свободой мо­
жет привести к неожиданным и трудно обнаруживаемым ошибкам.
Во второй главе мы продолжим изучать язык C++. Объектно-ори­
ентированные возможности C++ — это классика программирования и
обязательный материал, которым должен владеть любой профессио­
нальный разработчик. После Python вам может показаться, что в C++
слишком много ограничений. Но на самом деле разработчики языка
сделали всё возможное, чтобы у вас было как можно меньше шансов
сделать ошибку, которая может привести к серьёзному сбою в работе
программы. Все возможности языка C++, описанные в пособии, соот­
ветствуют стандарту С++11.

3
 Предисловие

В наше время самый ценный ресурс — это время работы програм­

миста. Для того чтобы сократить сроки разработки сложных программ
с графическим интерфейсом, применяют среды быстрой разработки
(англ. RAD: Rapid Application Development).
Одна из популярных профессиональных RAD-сред, которые можно
использовать бесплатно, — это Visual Studio Community. В ней можно
программировать на разных языках; в конце пособия мы создадим не­
сколько оконных приложений на языке С#, который очень похож на
C++.
Язык C# — это современный объектно-ориентированный язык про­
граммирования общего назначения. На нём можно разрабатывать различ­
ные программы для операционной системы Windows, веб-приложения,
программы для мобильных устройств и игровых консолей.
Вы увидите, насколько удобно строить весь интерфейс программы на
C# с помощью мыши, расставляя в окне программы элементы управ­
ления: кнопки, поля ввода, текстовые метки, списки и т. п. Програм­
мисту остаётся только определить, как программа будет реагировать на
действия пользователя, например на щелчок мышью по кнопке.
Дополнительные материалы к пособию, в том числе файлы с про­
граммами, можно загрузить с сайта автора:
http://kpolyakov.spb.ru/school/pycpp.htm .
Автор хочет поблагодарить своих коллег за внимательное чтение
рукописи этого пособия и полезные критические замечания, которые
позволили устранить неточности и существенно улучшить содержание:
• Д. В. Богданова, старшего преподавателя кафедры бизнес-инфор-
матики МЭИ;
• М. Д. Полежаеву, разработчика веб-сайтов.

4
Глава 1
ПРОГРАММИРОВАНИЕ НА ЯЗЫКЕ PYTHON

§1
Что такое ООП?
Ключевые слова:
• декомпозиция • процедурное программирование
• объект • объектно-ориентированное
• абстракция программирование

Проблема сложности программ

Во второй половине XX века компьютеры стали применять для
моделирования сложных систем, как технических (системы связи), так
и информационных (склады, банки, системы бронирования билетов и
др.). Новые задачи требовали более сложных алгоритмов, размеры про­
грамм выросли до десятков и сотен тысяч строк кода, число перемен­
ных и массивов измерялось в тысячах.
Программисты столкнулись с проблемой сложности, которая превы­
сила возможности человеческого разума. Один человек уже неспособен
написать надёжно работающую серьёзную программу, так как не мо­
жет «охватить взглядом» все её детали. Поэтому в разработке совре­
менных программ, как правило, принимает участие множество специ­
алистов. При этом возникает новая проблема: нужно разделить работу
между ними так, чтобы каждый мог работать независимо от других, а
потом готовую программу можно было бы собрать вместе из готовых
блоков, как из кубиков.
Как отмечал известный нидерландский программист Эдсгер Дейк-
стра, человечество ещё в древности придумало способ управления
сложными системами: «разделяй и властвуй». Это означает, что исход­
ную систему нужно разбить на подсистемы (выполнить декомпозицию)
так, чтобы работу каждой из них можно было рассматривать и совер­
шенствовать независимо от других.

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

5
 Программирование на языке Python

ду ними. Программисту, который отлаживает какую-то подпрограмму,

совершенно не обязательно знать все детали работы остальных под­
программ. Ему нужно только обеспечить согласованный со всеми
интерфейс — способ связи «его» подпрограммы с другими. Интерфейс
подпрограммы определяет:
• какие данные принимает подпрограмма от других подпрограмм;
• какие данные передаёт подпрограмма другим подпрограммам.
В остальном для программиста «чужие» подпрограммы — это «чёрные
ящики», которые решают свои задачи.
Процедурное программирование во многом позволило справиться с
проблемой сложности программ. Но оно не решило ещё одну пробле­
му: данные и методы их обработки остались разделены. В большинстве
программ использовались глобальные переменные и массивы, которые
описывали состояние программы. Любая процедура и функция могли
изменить глобальные данные. Это приводило к трудноуловимым ошиб­
кам и снижало надёжность программ. Проблема становилась всё более
острой с увеличением объёма программ, которые нередко состояли из
сотен тысяч строк кода.

Объектный подход
Следующая замечательная идея появилась в конце 60-х годов XX века —
применить в разработке программ тот подход, который использует
человек в повседневной жизни.
Как отмечал ещё в XVII веке французский математик и философ
Рене Декарт, люди воспринимают мир как множество объектов: пред­
метов, животных, людей. Все объекты имеют внутреннее устройство
и состояние, свойства (внешние характеристики) и поведение. Чтобы
справиться со сложностью окружающего мира, люди часто игнорируют
внутреннее строение объектов, обращая внимание только на те свой­
ства, которые необходимы для решения их практических задач. Такой
приём называется абстракцией.

Абстракция — это выделение существенных характеристик объекта,

отличающих его от других объектов.

Для разных задач существенные свойства могут быть совершенно

разными. Например, услышав слово «кошка», многие подумают о пу­
шистом усатом животном, которое мурлычет, когда его гладят. В то
же время ветеринарный врач представляет скелет, ткани и внутренние
органы кошки, которую ему нужно лечить. Для изготовителей коша­
чьего корма кошка — это объект, который потребляет корм и, таким
образом, приносит им доход. В каждом из этих случаев применение
абстракции даёт разные модели одного и того же объекта, отражаю­
щие его различные свойства и цели моделирования.

6
Что такое ООП? §1

Как применить принцип абстракции в программировании? Форму­

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

Взаимодействие объектов
Каждый объект «закрыт» в том смысле, что его внутреннее устройство
другим объектам неизвестно. Но объекты могут обмениваться данными
с другими объектами, используя заранее согласованные каналы связи
(рис. 1.1, а).

Рис. 1.1
Для решения задачи «на верхнем уровне» достаточно определить,
что делает тот или иной объект, не заботясь о том, как именно он это
делает. Таким образом, для преодоления сложности мы используем аб­
стракцию, т. е. сознательно отбрасываем второстепенные детали.
Если всё-таки «заглянуть внутрь» такого объекта, часто можно обна­
ружить, что он, в свою очередь, тоже состоит из объектов (рис. 1.1, б).
Но важно, что объект сам работает со своими внутренними данными,
не допуская к ним другие объекты. Таким образом, данные и методы
их обработки объединены — вместе они составляют объект.

Объект — это данные плюс методы их обработки.

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

7
1 Программирование на языке Python

Программирование, основанное на моделировании задачи реального

мира как множества взаимодействующих объектов, называют объектно-
ориентированным программированием (ООП). Более строгое определе­
ние мы дадим немного позже.

Выводы
• Программисты столкнулись с проблемой сложности программ,
которая превысила возможности человеческого разума.
• Процедурное программирование (декомпозиция по алгоритмам) —
это пример использования принципа «разделяй и властвуй» для
борьбы со сложностью программ.
• Абстракция — это выделение характеристик объекта, существенных
в данной задаче и отличающих этот объект от других объектов.
• Объект — это данные плюс методы их обработки.
• Объектный подход — это декомпозиция задачи по объектам.
• Программирование, основанное на моделировании задачи реально­
го мира как множества взаимодействующих объектов, называют
объектно-ориентированным программированием (ООП).
Вопросы и задания
1. Почему со временем неизбежно изменяются методы программирова­
ния?
2. Что такое декомпозиция, зачем она применяется?
3. Какие виды декомпозиции в программировании вы знаете?
4. Что такое процедурное программирование? Какой вид декомпози­
ции в нём используется?
5. Какие проблемы в программировании привели к появлению ООП?
6. Что такое абстракция? Зачем она используется в обычной жизни?
7. Объясните, почему один и тот же объект может иметь много раз­
ных моделей. Какую роль здесь играет абстракция?
8. Какой вид декомпозиции используется в ООП?
9. Какие преимущества даёт объектный подход в программировании?
10. Что такое интерфейс? Приведите примеры объектов, у которых оди­
наковый интерфейс и разное устройство.

§2
Модель задачи: классы и объекты
Ключевые слова:
• объектно-ориентированный анализ • свойство
• объект • метод
• класс

8
 Модель задачи: классы и объекты §2

Объектно-ориентированный анализ
Для того чтобы построить объектно-ориентированную модель, нужно:
• выделить взаимодействующие объекты, с помощью которых мож­
но описать поведение моделируемой системы;
• определить их свойства, существенные в данной задаче;
• описать поведение (возможные действия) объектов, т. е. команды,
которые объекты могут выполнить.
Этап разработки модели, на котором решаются перечисленные зада­
чи, называется объектно-ориентированным анализом (00А). Он вы­
полняется до того, как программисты напишут самую первую строку
кода, и во многом определяет качество и надёжность будущей про­
граммы.

«Торпедная атака»
Выполним объектно-ориентированный анализ простой игры «Торпед­
ная атака». На горизонте проходят вражеские корабли, которые нужно
атаковать с помощью торпед (и потопить) — рис. 1.2.

Рис. 1.2
Игрок, управляющий торпедным аппаратом, может:
• поворачивать торпедный аппарат влево и вправо, изменяя точку
прицеливания;
• давать команду на пуск торпеды (нажимая клавишу «пробел»).

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

Объектом можно назвать то, что имеет чёткие границы и обладает

состоянием и поведением.

Состояние объекта — это набор его свойств и текущие значения этих

свойств. Например, автомобиль имеет свойства «масса», «скорость»,
«цвет»; их значения в какой-то момент могут быть равны 1510 кг,
60 км/ч, «синий».

9
 Программирование на языке Python

Поведение определяется тем, как объект может воздействовать на

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

Класс — это описание множества объектов, имеющих общий набор

свойств и общее поведение.

Класс выполняет роль чертежа или шаблона — по нему можно

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

Классы объектов в игре

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

Метод класса — это процедура или функция, принадлежащая клас­

О су объектов.

Другими словами, метод класса определяет некоторое действие,

которое могут выполнять все объекты этого класса.

10
 Модель задачи: классы и объекты §2

а) Корабль б) Торпеда
координаты координаты
скорость скорость
изображение курс
двигаться изображение
взорваться двигаться

Торпедный аппарат
координаты
угол поворота
повернуться
выстрелить
Рис. 1.3
Класс Торпеда — это описание общих свойств и методов торпед
(рис. 1.3, б). Основные свойства торпеды — это координаты, скорость,
курс и изображение, а метод один — двигаться в заданном направлении.
Класс Торпедный аппарат (рис. 1.3, в) содержит два свойства —
координаты и угол поворота, и два метода — повернуться и выстре­
лить.
Взаимодействие объектов
Пока мы только описали модели отдельных объектов (точнее, классов).
Теперь нужно разобраться, как эти объекты взаимодействуют между
собой и с игроком.
Игрок может выполнять два действия:
• менять угол поворота торпедного аппарата (точку прицеливания);
• выполнять пуск торпеды (применять метод выстрелить торпедно­
го аппарата).
По команде выстрелить из торпедного аппарата выходит торпеда,
причём направление движения торпеды совпадает с текущим направле­
нием торпедного аппарата.
Когда торпеда достигнет линии движения кораблей, нужно будет
проверить, попала ли она в зону изображения какого-нибудь корабля.
Если попала, подбитый корабль взрывается и тонет, если не попала,
она просто исчезает с экрана.
Взаимодействие игрока с объектами в игре и объектов между собой
показано на рис. 1.4.
Конечно, здесь показан простейший вариант связей. Если совершен­
ствовать программу, нужно учесть, например, что корабль с помощью
своих акустических средств способен заранее обнаружить торпеду и
применить манёвр по уходу от неё. Вместе с тем, торпеда может иметь
блок самонаведения и, обнаружив корабль, преследовать его.

11
1 Программирование на языке Python

поворот

выстрел

Рис. 1.4
Таким образом, мы построили объектную модель игры: выделили
классы объектов, определили их свойства и методы. Обратите внима­
ние, что мы пока ничего не говорили о том, как устроены объекты и
как именно они будут действовать.
Теперь можно поручить разработку этих классов разным программи­
стам. Согласно принципам ООП, ни один объект не должен зависеть
от внутреннего устройства и алгоритмов работы других объектов. По­
этому каждый из программистов может решать свою задачу независи­
мо от других. Важно только, чтобы все они точно соблюдали интер­
фейсы — правила, описывающие взаимодействие «своих» объектов с
остальными.

Выводы
• Объектно-ориентированный анализ состоит в том, чтобы выделить
взаимодействующие объекты и описать их свойства и поведение.
• Объектом можно назвать то, что имеет чёткие границы и обладает
состоянием и поведением. Объект объединяет данные и методы их
обработки.
• Любой объект относится к какому-то классу. Класс — это описа­
ние множества объектов, имеющих общий набор свойств и общее
поведение.
• Метод класса — это процедура или функция, принадлежащая
классу объектов.
• Ни один объект не должен зависеть от внутреннего устройства и
алгоритмов работы других объектов.
• Интерфейсы — это правила, описывающие взаимодействие объек­
тов в программе.

Вопросы и задания
1. Какие задачи решает объектно-ориентированный анализ?
2. Чем различаются понятия «класс» и «объект»?
3. Что такое метод? Чем различаются понятия «метод» и «функция»?
4. Как изображаются классы на диаграмме?
5. Почему при объектно-ориентированном анализе не уточняют, как
именно объекты будут устроены и как они будут решать свои
задачи?

12
 Классы и объекты в программе §3

6. Подумайте, какими свойствами и методами могли бы обладать объ­

екты следующих классов: Ученик, Учитель, Школа, Экзамен, Тур­
нир, Урок, Страна, Президент, Браузер, Редактор, Яхта, Птица.
Придумайте свои классы объектов и выполните их анализ.
7. Постройте объектно-ориентированную модель для задачи моделирова­
ния дорожного движения. Рассмотрите классы объектов Дорога, Све­
тофор, Машина и их взаимосвязь.
8. Придумайте свою задачу и выполните её объектно-ориентированный
анализ. Примеры: моделирование работы магазина, банка, библиоте­
ки, склада; гонки автомобилей или яхт, и т. п.

§3
Классы и объекты в программе
Ключевые слова'.
• класс • экземпляр
• объект • конструктор
• свойство • параметры
• метод • переменные класса
• атрибут класса • анимация

Объявление класса
Программа, использующая объектно-ориентированный подход, начина­
ется с описания классов объектов.
Класс — это новый тип данных, который вводит программист.
Как и структура (вспомните материал третьей части пособия), класс
может объединять данные различных типов в единый блок. Кроме
того, класс содержит ещё и описание методов работы со своими
данными. Свойства описывают состояние объектов данного класса,
а методы — их поведение. В программе, о которой мы говорили в
предыдущем параграфе, есть класс Корабль (англ. ship). Его можно
объявить так:
class TShip:
pass
Эти строки вводят новый тип данных (класс) TShip1’, т. е. сообща­
ют компилятору, что в программе, возможно, будут использоваться
объекты этого класса. При этом в памяти пока не создаётся ни одно­
го объекта класса TShip. Это описание — как чертёж, по которому в
нужный момент можно построить сколько угодно таких объектов.

Буква Т в начале названия класса - это сокращение от слова type — тип.

13
1 Программирование на языке Python

Чтобы создать объект класса TShip, нужно вызвать специальную

функцию без параметров, имя которой совпадает с именем класса:
ship = TShip()
Созданный объект относится к классу TShip, поэтому его называют эк­
земпляром класса TShip или объектом класса TShip.

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

Поле — это переменная, принадлежащая объекту.

Поля и методы класса в языке Python называются атрибутами

класса.
В языке Python в любой точке программы вы можете добавить
поля объектам с помощью точечной записи, например:
ship = TShip()
ship.x =30 # х-координата
ship.v =3 # скорость
ship.image = image( ship.x, 150, "ship.gif" )
В последней строке в поле image записывается ссылка на объект-изо­
бражение, которое загружается из файла. Функция image объявлена в
модуле graph, поэтому в самом верху программы нужно импортиро­
вать все функции из этого модуля1*:
from graph import *
При «ручном» заполнении полей (так, как показано выше, отдель­
но для каждого объекта) у всех объектов класса TShip может оказать­
ся разный набор полей. Как ни странно, транслятор Python «ничего
не имеет против» этого и успешно выполнит такую программу. Но
при этом во время выполнения программы могут произойти серьёзные
ошибки. Чтобы этого не случилось, нужно соблюдать один из главных
принципов объектно-ориентированного программирования: объект ра­
ботает со своими данными только сам. Другие объекты (в том числе
и другие процедуры и функции) могут обращаться к данным объекта
только через его методы.
г* Модуль graph может быть загружен с сайта автора: http://kpolyakov.spb.ru/
school/probook/python.htm.

14
 Классы и объекты в программе §3

Конструктор
Вернёмся к записи
ship = TShip()
Внешне это выглядит как вызов функции без параметров — после
имени TShip стоят пустые скобки. И действительно, здесь вызывается
функция, которая создаёт объект. Она называется конструктором.

Конструктор — это метод класса, который вызывается для создания

объекта этого класса.

Мы не определили конструктор в описании класса, поэтому транс­

лятор добавил его автоматически. Такой конструктор называется кон­
структором по умолчанию.
Если мы хотим, чтобы у всех объектов класса TShip был одинако­
вый набор полей, нам нужно заменить конструктор по умолчанию на
свой конструктор.
Конструктор класса всегда имеет специальное имя_ init__ (от англ.
initialization — инициализация, начальные установки). По два символа
подчёркивания в начале и конце имени говорят о том, что конструк­
тор — это функция, имеющая специальное значение в языке Python.
Добавим конструктор в класс TShip:
class TShip:
def _ init__ ( self ): # конструктор
self.x = 0
self.v = 0
self.image = None
Обратите внимание, что функция _ init__ записана со смещением
вправо. Такой сдвиг делает её частью описания класса TShip. Получа­
ется, что это не просто функция, а метод класса TShip, внутри кото­
рого она расположена.
Первый (и здесь — единственный) параметр конструктора, как и
любого метода класса, — это ссылка на сам объект, который создаёт­
ся. По традиции он всегда называется self (от англ, self — «сам»).
С помощью этой ссылки мы обращаемся к полям объекта, например
self.x означает «поле х текущего объекта». Если вместо этого напи­
сать просто х, транслятор будет считать, что речь идёт о локальной
или глобальной переменной, а не о поле объекта.
В нашем конструкторе создаются три поля {атрибута)’, координата
х, скорость v и изображение image. Первые два заполняются нулями,
а в поле image записывается специальное значение None («ничего»);
которое говорит о том, что изображения пока нет.

15
1 Программирование на языке Python

Свойствам корабля по-прежнему можно присваивать новые значения с

помощью точечной записи, как мы делали это раньше. Что же измени­
лось? Теперь любой объект класса TShip обязательно имеет поля х, v и
image, потому что они создаются в конструкторе, при создании объекта.
Полная программа, которая строит объект класса Корабль (и пока
больше ничего не делает), выглядит так:
class TShip:
def _init__ ( self ): # конструктор
self.x = 0
self.v = 0
self.image = None

ship = TShip() # (1)

ship.x = 30
ship.v = 3
ship.image = image ( ship.x, 150, "ship.gif" )
He удивляйтесь, что в заголовке конструктора есть один параметр
(self), а при создании объекта (в строке 1) мы вызвали конструк­
тор без аргументов. В языке Python при вызове метода класса первый
аргумент — ссылку на текущий экземпляр объекта — компилятор
добавляет автоматически.

Конструктор с параметрами
Начальные значения полей можно задавать прямо при создании объек­
та. Для этого необходимо изменить конструктор, добавив дополнитель­
ные параметры — начальные значения свойств:
class TShip:
def _init__ ( self, xO, vO, fileName ):
self.x = xO if xO >= 0 else 0
self.v = vO
self.image = image( self.x, 150, fileName )
В конструкторе можно проверять правильность переданных парамет­
ров. Например, здесь гарантируется, что х-координата не окажется
отрицательной. Теперь создавать объект будет проще:
ship = TShip( 30, 3, "ship.gif" )
Координата этого корабля х = 30, его скорость равна трём условным
единицам, а изображение загружается из файла ship.gif в текущем
каталоге.
Мы передали конструктору только три аргумента, а не четыре, как
указано в заголовке метода _ init__ . Первый аргумент self — ссыл­
ку на только что созданный объект — компилятор добавит автомати­
чески.

16
 Классы и объекты в программе §3

Таким образом, конструктор класса выполняет роль «фабрики»,

которая при вызове конструктора «выпускает» (создаёт) объекты по
«чертежу» — описанию класса.

Данные класса
В конструкторе класса TShip есть одно «магическое» число — 150.
Можно выполнить рефакторинг — сделать это число константой.
Будем считать, что все корабли имеют одну и ту же 1/-координату,
поэтому эта константа должна принадлежать не конкретному экзем­
пляру, а всем кораблям. Вместе с тем, делать её глобальной тоже не
хочется: любая функция сможет её изменить, и из-за этого могут воз­
никнуть ошибки во время работы программы.
Выход есть — нужно указать, что эта константа (назовём её SHIP_Y)
принадлежит всему классу, а не отдельному объекту. В языке Python
нет констант, и мы вынуждены ввести её как переменную. Обычно пе­
ременные, имена которых состоят только из прописных букв, считают­
ся константами — все договариваются, что изменять их не будут.
Переменная, принадлежащая классу, называется переменной класса.
Её нужно определить внутри описания класса на том же уровне, что и
конструктор:
class TShip:
SHIP_Y = 150
def _ init__ ( self, x, v, fileName ):
self.x = x if x >= 0 else 0
self.v = v
self.image = image( self.x, TShip.SHIP_Y , fileName )
При обращении к переменной класса записывают название класса и
через точку — имя переменной: TShip. SHIP_Y.

Методы
Теперь научимся добавлять в класс методы. Самый простой метод
класса Корабль — метод двигаться (англ. move). Изображение корабля
нужно просто переместить по оси х вправо на величину, равную ско­
рости:
class TShip:
SHIP_Y = 150
def _init__ ( self, xO, vO, fileName ):

def move( self ):

moveObjectBy( self.image, self.v, 0 )
Многоточие обозначает тело конструктора, которое мы не стали
повторять. Обратим внимание на некоторые особенности:

17
1 Программирование на языке Python

• метод move записан с отступом, который говорит о том, что он вхо­

дит в класс TShip; этот отступ такой же, как и у конструктора;
• у метода move есть параметр self — это ссылка на текущий объ­
ект; для обращения к полям этого объекта нужно использовать
точечную запись, например self-image.
В нашем методе move корабль перемещается по холсту с помощью
функции moveObjectBy из модуля graph. Её первый аргумент — ссыл­
ка на перемещаемый объект, второй — смещение по оси х, третий —
смещение по оси у (здесь он всегда равен 0).

Анимация
Напомним, как программируется анимация в Python. Программа
запускает таймер, который срабатывает с заданным периодом, т. е. че­
рез равные интервалы времени. Срабатывание таймера — это событие,
на которое программа должна отреагировать, — изменить изображе­
ние на экране. Для этого в программе нужно установить обработчик
события, т. е. определить процедуру, которая будет вызываться при
каждом срабатывании таймера.
Сначала выберем нужное количество кадров в секунду и определим
соответствующий период обновления картинки:
fps = 20
updatePeriod = round( 1000 / fps )
Количество кадров в секунду записано в глобальную переменную fps (от
англ, frames per second — кадры в секунду), а период обновления — в
переменную updatePeriod (от англ, update — обновить). Чтобы вычис­
лить период обновления в миллисекундах, мы делим величину ин­
тервала 1 с = 1000 мс на количество кадров в секунду и округляем
результат с помощью функции round.
Будем считать, что изображение корабля хранится в файле ship.gif,
который сохранён в том же каталоге, что и наша программа. Создадим
объект-корабль:
ship = TShip( 30, 3, "ship.gif" )
и построим новую функцию, которая должна вызываться по таймеру:
def update():
ship.move()
Остаётся установить таймер на нужное время, настроить его на
вызов нужной функции и запустить анимацию:
onTimer( update, updatePeriod )
run ()
Если вы сделали всё правильно, изображение корабля будет двигать­
ся слева направо.

18
 Классы и объекты в программе §3

Строим флотилию
Попробуем создать флотилию кораблей. Сначала в основной программе
определяем константу — количество кораблей:
NUMBER_OF_SHIPS = 3
Затем строим массив кораблей ships, которые начинают движение с
разных точек с разными скоростями:
ships = []
for i in range(NUMBER_OF_SHIPS) :
ships.append( TShip(100*i, 3+i, "ship.gif") )
Остаётся изменить функцию update так, чтобы она вызывала метод
move для всех кораблей из массива ships:
def update ():
for ship in ships:
ship.move()
Нам не потребовалось работать с массивами, где хранятся отдельные
свойства объектов. Каждый объект класса TShip при создании (так
сказать, «от рождения») «знает», как он устроен и что ему нужно
делать по команде move, поэтому никаких сложностей не возникает.
Можно ли было написать такую же программу, не используя объ­
екты? Конечно, да. И она, возможно, получилась бы короче, чем наш
объектный вариант (с учётом описания классов). В чём же преиму­
щества ООП? Дело в том, что ООП — это средство разработки боль­
ших программ, моделирующих работу сложных систем. В этом случае
очень важно, что:
• задачи реального мира проще всего описываются именно с помо­
щью понятий «объект», «свойства», «действия» (методы);
• основная программа, описывающая решение задачи в целом, полу­
чается простой и понятной; все команды (вызовы методов) напо­
минают действия в реальном мире;
• легко разделить работу между программистами в команде: каж­
дый программирует свой класс и может работать независимо от
других;
• если объект Корабль понадобится в других проектах, можно будет
легко использовать уже готовый класс TShip со всеми его свойст­
вами и методами.

Выводы
• В отличие от структуры класс содержит не только данные, но и
методы работы с этими данными.
• Поле — это переменная, принадлежащая объекту. Метод — это
процедура или функция, принадлежащая объекту.

19
1 Программирование на языке Python

• Поля и методы класса в языке Python называются атрибутами.

• Конструктор — это метод класса, который вызывается для созда­
ния объекта этого класса. Если конструктор не задан при описа­
нии класса, транслятор автоматически добавляет конструктор по
умолчанию.
• Конструктор в языке Python всегда называется _ init__ .
• Первый параметр любого метода класса, в том числе и конструк­
тора, — это ссылка на текущий объект. По традиции он назы­
вается self. При вызове метода значение этого параметра не ука­
зывается.
• Данные, которые объявлены внутри описания класса, но вне его
методов, — это данные класса. При обращении к ним нужно ука­
зывать имя класса.

Вопросы и задания
1. Чем различаются понятия «структура» и «класс»?
2. Как можно присвоить полям объекта начальные значения? Сравни­
те разные способы.
3. Почему лучше создавать все поля объекта в конструкторе класса?
4. Может ли быть у одного класса несколько конструкторов? Обоснуй­
те ответ и проверьте его экспериментально.
5. Проверьте, можно ли обращаться к приведённой в параграфе пере­
менной класса SHIP Y не через класс, а через объект: ship.SHIP_Y.
6. Проект. Закончите программу, рассмотренную в тексте параграфа.
Добавьте в окно программы фоновый рисунок, сделайте так, чтобы
корабли двигались справа налево. Что, по-вашему, нужно делать,
когда корабль выходит за левый край холста?
7. Проект. Добавьте в программу новый класс Торпедный аппарат.
Изображение прицела должно перемещаться при нажатии на кла­
виши-стрелки (обработчик события можно установить с помощью
функции опКеу из модуля graph).
*8. Проект. Добавьте в программу класс Торпеда. Торпеда должна вы­
ходить из торпедного аппарата при нажатии на пробел. Когда тор­
педа дойдёт до линии, по которой двигаются корабли, нужно про­
верить, не попала ли она в какой-нибудь корабль. Если попала,
корабль должен взорваться, если не попала, торпеда пропадает с
экрана.
Указания'.
• используйте массивы (списки) для хранения объектов-кораблей
и объектов-торпед;
• в процедуре update для каждой пары «корабль — торпеда»
проверяйте, не попала ли торпеда в цель;

20
 Скрытие внутреннего устройства §4

• если торпеда попала в цель, корабль взрывается (картинка ме­

няется и через некоторое время исчезает), торпеда удаляется с
экрана;
• торпеда, прошедшая линию движения кораблей и не попавшая
в цель, удаляется с экрана.

Интересный сайт
younglinux.info/oopython.php — Python. Введение в объектно-ориен­
тированное программирование

§4
Скрытие внутреннего устройства
Ключевые слова:
интерфейс свойство
• инкапсуляция

Зачем это делать?

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

Методы

Рис. 1.5
Такой подход позволяет:
• обезопасить внутренние данные (поля) объекта от изменений (воз­
можно, разрушительных) со стороны других объектов;
• проверять правильность данных, поступающих от других объек­
тов, тем самым повышая надёжность программы;
• переделывать внутреннюю структуру и код объекта любым спосо­
бом, не меняя интерфейса; при этом никакой переделки других
объектов не потребуется.
Всё это становится действительно важно, когда разрабатывается боль­
шая программа и необходимо обеспечить её надёжность.

21
1 Программирование на языке Python

Скрытие внутреннего устройства объектов называется инкапсуляцией

О («помещением в капсулу»). Инкапсуляцией также называют объеди­
нение в одном объекте данных и методов работы с ними.

Скрытие полей
Разберём простой пример. Во многих системах программирования есть
класс, описывающий свойства «пера», которое используется при рисо­
вании линий в графическом режиме. Назовём этот класс ТРеп, в прос­
тейшем варианте он будет содержать только одно поле color, которое
определяет цвет.
Будем хранить информацию о цвете в виде символьной строки, в
которой записан шестнадцатеричный код составляющих цвета в моде­
ли RGB. Например, "00FF7F" — это светло-зелёный цвет, его красная
(R) составляющая равна 0, зелёная (G) — FF16 = 255 и синяя (В) —
7F16 = 127.
Класс Перо можно объявить так:
class ТРеп:
def _ init__ ( self ) :
self.color = "000000"
По умолчанию в Python все атрибуты класса (поля и методы)
открытые, общедоступные (англ, public). Это значит, что к полю color
может обратиться (и изменить его!) любая функция и объект любого
класса. Например, некоторая функция может случайно записать в это
поле ошибочное значение "Abra cadabra", которое потом приведёт к
ошибке в самый неожиданный момент.
Для повышения надёжности программы лучше сделать все поля объ­
ектов закрытыми, чтобы их не смогли изменить другие объекты про­
граммы. Имена тех атрибутов, которые нужно скрыть, в языке Python
должны начинаться с двух знаков подчёркивания, например так:
class ТРеп:
def _ init__ ( self ) :
self.__ color = "000000"
В этом примере поле _ color — закрытое, или частное (как част­
ная собственность, англ, private). Теперь никакой другой объект или
подпрограмма не сможет его случайно изменить. К закрытым полям
нельзя обратиться извне (это могут делать только методы самого объ­
екта), поэтому теперь (обычными средствами) невозможно не только
изменить поле объекта, но и просто узнать его значение.
Итак, все поля и методы, названия которых начинаются с двух зна­
ков подчёркивания, — закрытые. Вы наверняка заметили, что конструк­
тор — метод _ init__ — тоже начинается с двух знаков подчёркива­
ния. Это особый метод: он никогда не вызывается по имени, транслятор
выполняет его автоматически при создании каждого нового объекта.

22
 Скрытие внутреннего устройства §4

Иногда в программах на языке Python вы можете увидеть поля и

методы классов, имена которых начинаются не с двух, а с одного зна­
ка подчёркивания. Хотя они доступны другим объектам, знак подчёр­
кивания говорит о том, что, по мнению программиста, обращаться к
ним напрямую не следует.

Доступ к полям через методы

Чтобы всё-таки можно было работать со скрытым полем (читать и/
или изменять его значение), нужно добавить к классу ещё два мето­
да. Один из них будет возвращать текущее значение закрытого поля
__ color, а второй — присваивать полю новое значение.
Метод для чтения значения поля иногда называют «геттером» (от
англ, get — получать), а метод записи нового значения — «сетте­
ром» (от англ, set — устанавливать). Мы дадим им имена getColor и
setColor:
class ТРеп:
def _init__ ( self ):
self.__ color = "000000"
def getColor ( self ):
return self.__ color
def setColor ( self, newColor ):
if len ( newColor ) == 6:
self.__ color = newColor
else: self.__ color = "000000"
Метод getColor — это функция, которая просто возвращает значе­
ние внутреннего поля _ color. А вот в методе setColor мы выпол­
няем проверку данных, не разрешая присваивать полю недопустимые
значения1*. Если длина переданной символьной строки newColor не
равна 6, в поле _ color записывается значение по умолчанию — код
чёрного цвета 000000.
Что же улучшилось в сравнении с первым вариантом (когда поле
было открытым)? Согласно принципам ООП, обращаться к данным
объекта можно только с помощью методов. В этом случае внутреннее
устройство объекта можно в любой момент изменить, и это не повлия­
ет на другие объекты.
Теперь для записи и чтения цвета любого объекта класса ТРеп
необходимо использовать методы:
реп = ТРеп()
pen.setColor( "FFFF00" )
print ( "Цвет пера:", реп.getColor() )

Конечно, такая простая проверка сделана только для того, чтобы не усложнять
пример. В реальной программе нужно ещё проверить, что все 6 символов —
шестнадцатеричные цифры.

23
 Программирование на языке Python

Таким образом, мы скрыли (защитили) внутренние данные,

но одновременно обращение к свойствам стало выглядеть несколь­
ко неуклюже: вместо pen. color="FFFF00" теперь нужно писать
pen.setColor("FFFF00").

Свойства (property)
Чтобы упростить запись при обращении к полям через методы, во
многие языки программирования ввели понятие свойства (англ, pro­
perty). Внешне обращение к свойству выглядит так же, как обраще­
ние к полю объекта. Но на самом деле при записи и чтении значения
свойства вызываются методы объекта, определённые программистом.

Свойство — это способ доступа к внутреннему состоянию объекта,

имитирующий обращение к его полю.

Свойство color в нашем случае можно определить так:

class ТРеп:
def _init__ ( self ):
self.__ color = "000000"
def _ getColor ( self ) :
return self.__ color
def _ setColor ( self, newColor ):
if len ( newColor ) == 6:
self.__ color = newColor
else: self.__ color = "000000"
color = property ( __ getColor, __ setColor )
Здесь мы добавили два подчёркивания в начало названий методов
getColor и setColor. Следовательно, они стали частными (англ, pri­
vate), скрытыми от других объектов.
Строка, выделенная фоном, определяет общедоступное свойство
с названием color. При чтении этого свойства вызывается метод
__ getColor, а при записи нового значения — метод _ setColor.
В программе можно использовать свойство color так, как будто это
общедоступное поле:
pen.color = "FFFF00"
print( "Цвет пера:", pen.color )
Поскольку функция _ getColor просто возвращает значение поля
__ color и не выполняет никаких дополнительных действий, можно
было вообще удалить метод _ getColor и вместо него использовать
лямбда-функцию:

24
 Скрытие внутреннего устройства §4

class ТРеп:
def _init__ ( self ):
self.__ color = "000000"
def _ setColor ( self, newColor ):
if len ( newColor ) == 6:
self.__ color = newColor
else: self.__ color = "000000"
color = property( lambda x: x.__ color , __ setColor )

Лямбда-функция (она выделена фоном) принимает единственный

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

Меняем внутреннее устройство

При сохранении интерфейса можно как угодно менять внутреннюю
структуру данных и код методов, и это никак не будет влиять на дру­
гие объекты.
Как мы увидели выше, с помощью свойства color другие объек­
ты могут изменять и читать цвет объектов класса ТРеп. Для обмена
данными с «внешним миром» важно лишь то, что свойство color —
символьного типа, и оно содержит 6-символьный код цвета. При этом
внутреннее устройство объектов ТРеп может быть любым, и его можно
изменять, как угодно. Покажем это на примере.
Представление цвета в виде символьной строки неэкономно и
неудобно, поэтому на практике с кодом цвета чаще всего работают как с
целым числом. Для хранения этого числа введём скрытое поле _ color:
self.__ color = 0
При этом мы хотим сохранить интерфейс, т. е. сделать так, чтобы
другие объекты даже не заподозрили о внутренних изменениях в клас­
се ТРеп.
Допустим, мы раньше договорились о том, что свойство color
класса ТРеп — это символьная строка длиной 6 символов. Посколь­
ку теперь цвет хранится как целое число, необходимо поменять ме­
тоды _ getColor и _ setColor, которые работают с этим полем. Ме­
тод _ getColor должен вернуть код цвета, преобразованный в строку
из 6 символов, а метод _ setColor должен преобразовать получен­
ную символьную строку в числовой код и записать этот код в поле
color.

25
1 Программирование на языке Python

class TPen:
def __init__ ( self ):
self.__ color = 0
def _ getColor ( self ) :
return "{:06X}". format( self.__ color )
def _ setColor( self, newColor ):
if len( newColor ) == 6:
self.__ color = int( newColor, 16 )
else: self.__ color = 0
color = property ( __ getColor, __ setColor )
Для перевода числового кода в символьную запись используется
функция format. Формат 06Х означает «вывести значение в шестнад­
цатеричной системе (X) в 6 позициях, свободные позиции слева за­
полнить нулями». Для обратного преобразования применяем функцию
int, которой передаётся второй аргумент 16 — основание системы
счисления.
В этом примере мы принципиально изменили внутреннее устройство
объекта — вместо строкового поля для хранения цвета теперь исполь­
зуется целочисленное. Однако другие объекты даже не «догадаются» о
такой замене, потому что сохранился интерфейс — свойство color по-
прежнему имеет строковый тип. Таким образом, инкапсуляция позво­
ляет как угодно изменять внутреннее устройство объектов, не затраги­
вая интерфейс. При этом все остальные объекты изменять не требуется.
Скрытие данных чаще всего увеличивает длину программы, однако
мы получаем и важные преимущества. Код, связанный с объектом, раз­
делён на две части: общедоступную часть (интерфейс) и закрытую. Их
можно сравнить с надводной и подводной частями айсберга (рис. 1.6).

Рис. 1.6

Свойство «только для чтения»

Иногда нужно запретить другим объектам менять какое-то свойство
объекта. Другими словами, требуется сделать свойство «только для
чтения» (англ, read-only).

26
 Скрытие внутреннего устройства §4

Пусть, например, мы строим программную модель автомобиля. Как

правило, другие объекты не могут непосредственно менять его ско­
рость, однако могут получить информацию о ней — «прочитать» зна­
чение скорости.
При описании такого свойства метод записи не указывают вообще
(или указывается пустое значение None):
class TCar:
def _init__ ( self, _v ):
self.__ v = _v
velocity = property ( lambda x: x.__v )
Теперь изменить поле _ v может только сам объект.
Возможен другой вариант записи:
class TCar:
def _ init__ ( self, _v ):
self.__ v = _v
@property
def velocity (self):
return self.__ v
Команда @property перед методом velocity говорит о том, что
создаётся свойство только для чтения с таким именем, и метод
velocity служит для чтения его значения1*.
Свойство не всегда может соответствовать значению какой-то пере­
менной. Например, в класс TRect, который описывает прямоугольник
(от англ, rectangle — прямоугольник), можно добавить свойство area
(по-английски — площадь):
class TRect():
def __init__ ( self, a, b ):
self.__ a = a
self.__ b = b
area = property( lambda x: x.__ a*x.__ b )
Понятно, что хранить площадь прямоугольника в отдельном поле
нет смысла — её всегда можно вычислить, перемножив длины сторон.
Кроме того, записывать значение в это поле тоже бессмысленно. Поэто­
му в строке, выделенной фоном, вводится новое свойство area «только
для чтения». При обращении к этому свойству результат вычисляется
с помощью лямбда-функции, перемножающей длины сторон — значе­
ния двух закрытых полей. При запуске программы
ret = TRect( 2, 3 )
print( ret.area )
на экран выводится число 6.
Такие инструкции, как @property, в языке Python называются декораторами.
Их обсуждение выходит за рамки пособия.

27
1 Программирование на языке Python

Выводы
• Обмен данными между объектами выполняется с помощью
общедоступных свойств и методов, которые составляют интерфейс
класса.
• Скрытие внутреннего устройства объектов называется инкапсуля­
цией. Инкапсуляцией также называют объединение в одном объ­
екте данных и методов работы с ними.
• Изменение внутреннего устройства объектов (реализации) не вли­
яет на взаимодействие с другими объектами, если не меняется
интерфейс.
• Имена закрытых (частных) полей и методов в Python должны
начинаться с двух знаков подчёркивания.
• Читать и изменять значения закрытых полей класса можно толь­
ко с помощью методов этого класса.
• Свойство — это способ доступа к внутреннему состоянию объек­
та, имитирующий обращение к его полю. При создании свойства
нужно указать метод чтения и метод записи.
• Свойство, предназначенное только для чтения, не имеет метода
записи. Другие объекты не могут изменить значение этого свойства.
Вопросы и задания
1. Что такое интерфейс объекта?
2. Что такое инкапсуляция? Оцените её достоинства и недостатки.
3. Как различить общедоступные и закрытые данные и методы в опи­
сании классов?
4. Почему рекомендуют делать доступ к полям объекта только с помо­
щью методов?
5. При каких ошибочных значениях параметра не сработает наша
защита от неправильных данных в методе setcolor (из парагра­
фа)? Исправьте метод так, чтобы исключить эту ошибку.
6. Что такое свойство? Зачем во многие языки программирования вве­
дено это понятие?
7. Почему методы чтения и записи, которые использует свойство,
обычно делают закрытыми?
8. Зачем нужны свойства «только для чтения»? Приведите свой пример.
9. Сравните два варианта вычисления площади прямоугольника в
классе TRect (из параграфа): с помощью метода-функции и с помо­
щью свойства. Какой из них вам больше нравится?
10. Подумайте, в каких ситуациях может быть нужно свойство «только
для записи» (которое нельзя прочитать). Предположите, как ввести
такое свойство в описание класса. Проверьте вашу догадку экспери­
ментально.
11. Проект. Измените программу игры «Торпедная атака» (из §2) так,
чтобы все поля у объектов были закрытыми. Используйте свойства
для доступа к данным.

28
 Иерархия классов §5

§5
Иерархия классов
Ключевые слова'.
• классификация • абстрактный класс
• базовый класс • абстрактный метод
• производный класс • полиморфизм
• класс-наследник • исключение
• иерархия

Наследование
Как в науке, так и в быту важную роль играет классификация —
разделение объектов на группы (классы), объединённые общими при­
знаками. Значительно проще не полностью описывать каждый объект
«с нуля», а сравнивать его с уже известными объектами.
Например, есть много видов фруктов1) (яблоки, груши, бананы,
апельсины и т. д.), но все они обладают некоторыми общими свой­
ствами. Если перевести этот пример на язык ООП, у нас есть класс
Фрукт. У этого класса есть производные классы {классы-наследни­
ки, классы-потомки, подклассы) — Яблоко, Груша, Банан, Апельсин
и др. В свою очередь, для этих классов класс Фрукт — это базовый
класс, суперкласс, класс-предок (рис. 1.7).

классы-наследники

Рис. 1.7
Стрелка с белым наконечником на рис. 1.7 указывает на базовый
класс. Например, класс Яблоко — это наследник класса Фрукт, а
класс Фрукт — базовый класс для класса Яблоко. Это означает, что
все объекты класса Яблоко обладают всеми свойствами и методами
класса Фрукт.
Классический пример научной классификации — классификация
животных или растений. Она представляет собой иерархию — много­
уровневую структуру. Например, лев — это вид рода пантер семей­
ства кошачьих отряда хищных и т. д. Говоря на языке ООП, класс
Лев — это наследник класса Пантеры, а тот, в свою очередь, наслед­
ник класса Кошачьи, который является наследником класса Хищные
ит. д. Часть этой классификации показана на рис. 1.8.

г) Фруктами называют сочные съедобные плоды деревьев и кустарников.

29
 Программирование на языке Python

Рис. 1.8

Класс Б является наследником класса А, если можно сказать, что

Б — это разновидность А.

Например, можно сказать, что яблоко — это фрукт, а лев — живот­

ное класса Кошачьи.
В то же время мы не можем сказать, что машина — это разновид­
ность двигателя, поэтому класс Машина не является наследником клас­
са Двигатель. Двигатель — это составная часть машины, поэтому объект
класса Машина содержит в себе объект класса Двигатель. Отношения
между двигателем и машиной — это отношение «часть — целое».

Иерархия объектов в игре

Игра, которую мы будем программировать, моделирует поведение и
взаимодействие разных объектов в космосе. Перечислим некоторые
классы объектов:
• Корабли — космические корабли, которые двигаются по прямой
линии и «отталкиваются» от стенок игрового поля;
• Странники — движутся так же, как и корабли, но в случайные
моменты времени меняют направление движения;
• Чёрные дыры — неподвижные области, которые поглощают кораб­
ли и странников;
• Пульсары — то же, что и Чёрные дыры, но их размер меняется в
случайные моменты времени;
Конечно, вы можете добавить какие-то другие классы в свою игру.
Перед тем как начать программировать, нужно выполнить объектно-
ориентированный анализ: выделить классы объектов, определить их
свойства и методы.
Каждый объект в нашей игре имеет координаты и размеры на экра­
не (высоту и ширину). Эти общие свойства можно описать в базовом
классе Игровой объект.
Среди объектов можно выделить неподвижные (Чёрные дыры и
Пульсары) и подвижные (Корабли и Странники). У подвижных объек-

30
 Иерархия классов §5

тов есть дополнительные свойства: направление и скорость движения.

Эти свойства добавим в новый класс Движущийся объект — наслед­
ник класса Игровой объект.
Странник — это особый Корабль, который меняет направление дви­
жения. Поэтому класс Странник должен быть наследником класса
Корабль, а класс Корабль — наследником класса Движущийся объект.
Объекты классов Чёрная дыра и Пульсар не двигаются, это наслед­
ники класса Игровой объект. Кроме того, Пульсар — это разновид­
ность Чёрной дыры (наследник этого класса). В итоге у нас получается
диаграмма классов, показанная на рис. 1.9.

Рис. 1.9
Итак, для того чтобы не описывать несколько раз одинаковые свой­
ства и методы, классы в программе должны быть построены в виде
иерархии. Теперь можно дать классическое определение объектно-
ориентированного программирования.

Объектно-ориентированное программирование — это такой подход к

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

Базовый класс
Начнём с описания класса Игровой объект (TGameObject). Он дол­
жен объединить общие свойства и методы всех объектов в игре. Свой­
ства — это координаты базовой точки (х и у), ширина (англ, width) и
высота (англ, height). Можно начать с такого варианта:
class TGameObject:
def __init ( self, x, у, width, height ):
self.__ x = x
self.__ у = у
self.__ width = width
self.__ height = height

31
1 Программирование на языке Python

@property
def х( self ): return self.__ x
@property
def y( self ): return self.__ у
@property
def width( self ): return self.__ width
@property
def height ( self ): return self.__ height
Все четыре поля (_ x, __ у, __ width и _ height) — закрытые,
они заполняются при создании объекта. Для чтения их значений мы
добавили четыре свойства «только для чтения», а изменять значения
полей могут только сами объекты класса TGameObject.
Заметим, что не существует игрового объекта «вообще», так же
как не существует «просто фрукта», не относящегося к какому-то
виду. Поэтому понятие «игровой объект» — это просто набор каких-
то свойств и методов, т. е. абстракция. А класс, описывающий та­
кую абстракцию, называется абстрактным. Создавать объекты такого
класса бессмысленно.

Абстрактный класс — это класс, который не предназначен для соз­

дания объектов (экземпляров). Абстрактный класс служит только
для создания классов-наследников.

Классы-наследники могут иметь дополнительные поля и свойства,

которых нет у базового класса TGameObject, но все поля и свойства
базового класса у них обязательно будут.
Теперь перейдём к общим методам. Все объекты участвуют в ани­
мации: меняют своё положение и/или свойства через небольшой ин­
тервал времени. Добавим в базовый класс TGameObject метод update
(в переводе с английского — обновить), который будет вызываться по­
сле окончания очередного интервала анимации (рис. 1.10). При вызове
этого метода объект должен «прожить» этот интервал, перейти в новое
состояние.

TGameObject
х
У
width
height
update

Рис. 1.10

Хотя метод update есть у всех объектов, наследники класса

TGameObject выполняют его по-разному: Корабли двигаются, Пульса­
ры изменяют свой размер, Чёрные дыры никак не меняются... Поэтому

32
 Иерархия классов §5

в базовом классе невозможно написать метод update, работающий для

всех классов.
Конечно, можно добавить пустой метод-«заглушку»:
class TGameObject:

def update( self ):

pass
Здесь pass — это пустой оператор, команда «ничего не делать». Он
обычно говорит о том, что в этом месте программы должны быть
какие-то команды, но пока их нет.
Использование «заглушки» — это не совсем правильно, поскольку
кто-то может создать объект класса TGameObject и пытаться его ис­
пользовать, а это бессмысленно. Поэтому мы вообще не будем опреде­
лять метод update. В этом случае метод update называют абстракт­
ным методом.

Абстрактный метод — это метод класса, реализация которого в

классе не приводится.
О
Пока в нашем классе TGameObject вообще нет методов (метод
update мы убрали). Как же сказать программе, что метод update дол­
жен быть, но пока не определён? В языке Python можно запретить
создание объектов класса TGameObject и его наследников, у которых
нет метода update. Этим мы покажем, что класс TGameObject —
абстрактный1).
В конструкторе класса проверим, есть ли у объекта метод update, и
если такого метода нет, искусственно создадим аварийную ситуацию —
исключение, — что приведёт к завершению программы:
class TGameObject:
def _init__ ( self, x, у, width, height ):
self.__ x = x
self.__ у = у
self.__ width = width
self.__ height = height
if not hasattr( self, "update" ):
raise NotlmplementedError(
"Нельзя создать такой объект!" )

Функция hasattr возвращает логическое значение True, если

у переданного ей объекта (здесь — self) есть указанный атрибут
(в нашем случае — поле или метод с именем update).
х) В Python есть и другие способы объявить класс абстрактным, например с
помощью модуля ABCMeta.

33
1 Программирование на языке Python

Служебное слово raise означает «создать исключение», тип этого

исключения — NotlmplementedError (ошибка «не реализовано»), в
скобках записана символьная строка, которую увидит пользователь в
сообщении об ошибке.
В конструкторе класса TGameObject мы требовали, чтобы все созда­
ваемые объекты имели метод update. Но такого метода в описа­
нии базового класса нет! Поэтому при попытке создать объект класса
TGameObject с помощью конструктора:
obj = TGameObject( 100, 20, 10, 10 ) # ошибка!
мы получим сообщение об ошибке. Этот класс — абстрактный.
Откуда же возьмётся метод update? Дело в том, что мы построи­
ли класс TGameObject только для того, чтобы создавать на его основе
классы-наследники. В этом классе мы объединили общие свойства всех
игровых объектов, чтобы не повторять их описание во всех остальных
классах.
Класс-наследник не будет абстрактным, если определит все абстракт­
ные методы базового класса, в нашем случае — метод update. Тогда
мы сможем создать объект такого класса.
Каждый класс-наследник может реализовать метод update по-своему.
Такая возможность называется полиморфизмом.

Полиморфизм (от греч. лоХи — много, и цорфт] — форма) — это воз­

О можность классов-наследников по-разному реализовать метод базово­
го класса.

Доступ к ПОЛЯМ
В приведённом варианте класса TGameObject все поля напрямую недо­
ступны, возможно только чтение их значений через свойства. Однако в
дальнейшем такая ситуация будет нам мешать. Например, движущим­
ся объектам нужно изменять свои координаты. Если поля закрыты и
нет методов для работы с ними, сделать это невозможно.
Для правильной работы классов-наследников можно обеспечить
им доступ к полям базового класса. Но желательно как-то отме­
тить, что никто другой, кроме наследников, не должен изменять
значения этих полей. Для этого в начале имени поля ставят одно
подчёркивание. По соглашению, принятому в сообществе Python-
программистов, это говорит о том, что переменную не следует изме­
нять, несмотря на то что она общедоступна. То же самое относится
и к методам, названия которых начинаются с одного подчёркива­
ния.
Вот окончательный вариант базового класса:

34
 Иерархия классов §5

class TGameObject:
def _ init__ ( self, x, y, width, height ):
self._x = x
self._y = у
self._width = width
self._height = height
if not hasattr( self, "update" ):
raise NotlmplementedError(
"Нельзя создать такой объект!" )
@property
def x( self ): return self._x
@property
def у( self ): return self._y
@property
def width( self ): return self._width
@property
def height( self ): return self._height
Во многих объектно-ориентированных языках программирования
(C++, С#, Java, Delphi) кроме общедоступных (англ, public) и за­
крытых (англ, private) элементов класса есть ещё защищённые (англ.
protected). Доступ к ним имеет сам класс, в котором объявлены эти
данные и методы, и наследники этого класса. К сожалению, в языке
Python защищённые поля и методы сделать невозможно.

Выводы
• Объектно-ориентированное программирование — это такой подход
к программированию, при котором программа представляет со­
бой множество взаимодействующих объектов, каждый из которых
является экземпляром определённого класса, а классы образуют
иерархию наследования.
• Классы-наследники обладают всеми свойствами и методами базово­
го класса. Они могут изменять методы базового класса или добав­
лять к ним собственные свойства и методы.
• Абстрактный метод — это метод класса, реализация которого в
классе не приводится.
• Абстрактный класс — это класс, который не предназначен для
создания объектов (экземпляров). Любой класс, в котором есть аб­
страктный метод, является абстрактным.
• Полиморфизм — это возможность классов-наследников по-разному
реализовать метод базового класса.
• Исключение — это аварийная ситуация, которая возникает в слу­
чае ошибки при выполнении программы. Программа может сама
создать (сгенерировать, «выбросить») исключение.
• Поля и методы, названия которых начинаются с одного знака
подчёркивания, предназначены для изменения только в данном
классе и его классах-наследниках.

35
 Программирование на языке Python

Вопросы и задания
1. Приведите свои примеры отношений «наследование» и «часть —
целое».
2. Как вы думаете, стоит ли в рассмотренной в параграфе игре вво­
дить ещё класс Неподвижный объект — наследник класса Игровой
объект?
3. Используя дополнительные источники, составьте свою классифика­
цию каких-то объектов (например, фотокамер, веб-сайтов, печатных
изданий и т. п.). Используйте 2-3 уровня наследования.
4. Постройте классификацию, в которую войдут: молоко, масло, говя­
дина, свинина, огурцы, помидоры, овсяная каша, хлеб.
5. Найдите ошибки в проектировании системы классов.

6. В программе нужно моделировать следующие классы: Корабль,

Подводная лодка, Самолёт, Вертолёт, Гидросамолёт, Мотоцикл,
Трактор. Постройте иерархию классов для этой задачи.
7. Что такое абстракция? Приведите примеры.
8. Зачем нужен абстрактный класс, если создать объекты такого клас­
са нельзя?
9. Как построить абстрактный класс в языке Python?
10. В каком случае класс-наследник абстрактного класса сам не будет
абстрактным классом?
11. Обсудите достоинства и недостатки методов-«заглушек», состоящих
из единственной команды pass.
12. Расскажите о разных способах, с помощью которых класс-наследник
может обратиться к полям базового класса. Сравните их, оцените
достоинства и недостатки каждого способа.
13. Можно ли в функции, не относящейся к классу, изменить значе­
ния полей объекта, имена которых начинаются с одного символа
подчёркивания?
14. Добавьте в иерархию объектов игры из параграфа (см. рис. 1.9)
свои классы объектов.

36
 Классы-наследники (I) §6

§6
Классы-наследники (I)
Ключевые слова:
• базовый класс • переопределение метода
• наследник • полиморфизм
• конструктор

Классы-наследники
Теперь будем строить классы-наследники. Начнём с простого клас­
са Чёрная дыра (TBlackHole). Как следует из диаграммы классов на
рис. 1.9, класс TBlackHole должен быть прямым наследником базово­
го класса TGameObject. При объявлении класса-наследника после его
имени в скобках записывается название базового класса:
class TBlackHole( TGameObject ):

Будем изображать на холсте чёрные дыры чёрными кругами. Чтобы

определить такой круг, нужно задать координаты его центра (назовём
их xCenter и yCenter) и радиус (radius). Уже можно написать заго­
ловок конструктора:
def _ init__ ( self, xCenter, yCenter, radius ):

При создании объекта класса-наследника в первую очередь вызы­

вается конструктор базового класса (TGameObject). Ему нужно пере­
дать координаты базовой точки и размеры объекта. За базовую точку
чёрной дыры удобно принять её центр, а высота и ширина равны диа­
метру, т. е. двум радиусам:
def _init__ ( self, xCenter, yCenter, radius ):
TGameObject.__ init__ ( self, xCenter, yCenter,
2*radius, 2*radius )

После того как отработает конструктор базового класса, нужно вы­

полнить дополнительные действия: создать объект-круг чёрного цвета,
запомнить ссылку на него во внутреннем поле и вывести объект на
экран:
brushColor ( "black" )
self._image = circle ( xCenter, yCenter, radius )

Приведём описание класса полностью:

37
1 Программирование на языке Python

class TBlackHole( TGameObject ):

def __init ( self, xCenter, yCenter, radius ):
TGameObject.__ init__ ( self, xCenter, yCenter,
2*radius, 2*radius )
brushColor("black")
self._image = circle( xCenter, yCenter,radius )
def update( self ):
pass
Обратите внимание, что мы добавили в конец описания класса метод
update, который ничего не делает. Действительно, во время анимации
чёрная дыра никак не изменяется. Если не добавить этот метод, класс
окажется абстрактным, так как в нём не будет реализации обязатель­
ного метода. Поэтому создать объекты этого класса будет невозможно.
Теперь мы готовы написать всю программу:
from random import randint
from graph import *
SCREEN_WIDTH = 600 # ширина окна
SCREEN_HEIGHT = 400 # высота окна
fps =20 # частота кадров
updatePeriod = round(1000 / fps)
# Здесь должны быть описания классов
# TGameObject и TBlackHole
windowsize(SCREEN_WIDTH, SCREEN_HEIGHT)
canvassize(SCREEN_WIDTH, SCREEN_HEIGHT)

NUMBER_OF_BLACKHOLES =10
blackHoles = []
for i in range(NUMBER_OF_BLACKHOLES):
blackHoles.append( TBlackHole(
randint(0, SCREEN_WIDTH),
randint(0, SCREEN_HEIGHT),
randint(10, 20) ) )

def update():
for bh in blackHoles:
bh.update();

onTimer( update, updatePeriod )

run ()
В программе создаётся массив blackHoles из объектов клас­
са TBlackHole, их количество определяется константой NUMBER_OF_
BLACKHOLES.

38
 Классы-наследники (I) §6

Координаты и радиусы этих объектов выбираются случайно с помо­

щью функции randint из модуля random.
Анимация выполняется с помощью процедуры update, которая
вызывается по таймеру с периодом update Period. В этой процеду­
ре в цикле перебираются все чёрные дыры из массива blackHoles,
для каждой из них вызывается метод update. В данном случае метод
update ничего не делает, так как чёрная дыра неподвижна и не меня­
ет свой размер.

Пульсар
Пульсар — это объект, который напоминает чёрную дыру, но его раз­
меры постоянно изменяются. Следовательно, можно сказать, что пуль­
сар — это разновидность объекта Чёрная дыра, или, говоря на языке
программистов, подкласс (производный класс, класс-наследник) класса
TBlackHole.
В отличие от чёрных дыр пульсары будем закрашивать коричневым
цветом. Получается такой класс:
class TPulsar( TBlackHole ):
def _ init__ ( self, xCenter, yCenter, radius ):
TBlackHole.__ init__ ( self, xCenter, yCenter, radius )
changeFillColor( self._image, "brown" )
В заголовке указываем, что TPulsar — это наследник клас­
са TBlackHole, т. е. он обладает всеми свойствами базового класса
TBlackHole. Заметим, что, кроме того, он является и наследником
класса TGameObject.
Конструктор нового класса принимает те же параметры, что и кон­
структор базового класса — координаты центра и начальный радиус
круга. После вызова конструктора базового класса мы меняем цвет за­
ливки на коричневый с помощью функции changeFillColor из моду­
ля graph.
Пока новый класс не отличается от базового ничем, кроме цвета
заливки. А должен отличаться тем, что радиус пульсара меняется слу­
чайным образом на каждом шаге анимации. Для этого нужно добавить
в класс TPulsar собственный метод update.
У класса TBlackHole, который служит базовым классом для
TPulsar, тоже есть метод update, поэтому мы выполняем переопреде­
ление метода (англ, override) — пишем новую версию метода с таким
же именем для класса-наследника.

Переопределение метода — это создание в классе-наследнике новой

версии метода, определённого ранее для базового класса.

Новый метод update будет вызывать скрытый метод_ changeRadius,

который устанавливает новый радиус:

39
1 Программирование на языке Python

class TPulsar ( TBlackHole ) :

def update ( self ):

self.__ changeRadius( randint(5, 20) )
def _ changeRadius( self, newRadius ):
self._width = 2*newRadius
self._height = 2*newRadius
changeCoords( self._image,
[(self._x-newRadius, self._y-newRadius),
(self._x+newRadius, self._y+newRadius)] )
В начале функции _ changeRadius мы изменяем свойства объекта,
которые хранятся в переменных базового класса TGameObject: ширину
и высоту.
Затем функция changeCoords из модуля graph изменяет координаты
рисунка на холсте. При обращении к ней первый аргумент — self._
image — это ссылка на рисунок, второй — массив из двух кортежей:
[(хр уг), (х2, у2)]. Эти кортежи содержат координаты двух противопо­
ложных углов прямоугольника, в который вписан круг: (хг, уг) — это
координаты левого верхнего угла, а (х2, у2) — координаты правого
нижнего угла.
Теперь можно создать массив из пульсаров:
NUMBER_OF_PULSARS =15
pulsars = []
for i in range(NUMBER_OF_PULSARS):
pulsars.append( TPulsar(
randint(0, SCREEN_WIDTH),
randint(0, SCREEN_HEIGHT),
randint(10, 20) ) )
Отметим, что изображения пульсаров сразу добавляются на холст.
Это происходит в конструкторе класса TBlackHole при создании объ­
екта-круга с помощью функции circle из модуля graph.
Чтобы пульсары обновлялись при моделировании, в процедуре
update для каждого из этих объектов нужно вызвать метод update:
def update():
for bh in blackHoles:
bh.update()
for ps in pulsars:
ps.update()

Полиморфизм
Интересно, что мы можем записывать чёрные дыры и пульсары в один
и тот же массив, и всё равно программа будет работать правильно:

40
 Классы-наследники (I) §6

NUMBER_OF_BLACKHOLES =10
allObjects = []
for i in range(NUMBER_OF_BLACKHOLES):
allObjects.append( TBlackHole(
randint ( 0, SCREEN_WIDTH ),
randint( 0, SCREEN_HEIGHT ),
randint(10, 20) ) )
NUMBER_OF_PULSARS =15
for i in range(NUMBER_OF_PULSARS) :
allObjects.append( TPulsar(
randint( 0, SCREEN_WIDTH ),
randint( 0, SCREEN_HEIGHT ),
randint( 10, 20) ) )
Теперь массив allObjects содержит как чёрные дыры, так и пуль­
сары. Причём каждый элемент массива «знает» свой тип. Это легко
проверить с помощью такого цикла:
for obj in allObjects:
print( type(obj) )
Для первых 10 элементов мы увидим сообщение
<class '__ main__ .TBlackHole'>
а для остальных:
<class '__ main__ .TPulsar’>
И поэтому в процедуре update пульсары и можно обрабатывать
вместе, в одном цикле:
def update () :
for obj in allObjects:
obj.update()
Для каждого объекта, попавшего в переменную obj, программа во
время выполнения определит тип и вызовет метод update того класса,
к которому этот объект принадлежит. Эта особенность — проявление
полиморфизма.

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

41
1 Программирование на языке Python

• Ссылки на объекты разных классов можно хранить в одном мас­

сиве. Если, например, для каждого элемента массива вызвать
метод update, программа определит тип конкретного объекта и
вызовет метод update того класса, к которому этот объект при­
надлежит. Эта особенность — проявление полиморфизма.

Вопросы и задания
1. Проект. Постройте полную программу (из параграфа), которая
выводит на экран чёрные дыры и пульсары и выполняет анимацию.
2. Проект. Напишите вариант программы из предыдущего задания,
в котором классы TBlackHole и Т Puls аг не связаны в иерархию,
а независимы. Сравните её с вариантом, который рассматривался в
параграфе. Какой подход вам больше нравится и почему?
3. Проект. Добавьте в программу из задания 1 ещё один класс непо­
движных объектов, которые изображаются квадратом или ромбом.
4. Проект. Добавьте в программу из задания 1 ещё один класс непо­
движных объектов, которые при анимации меняют цвет случайным
образом.

§7
Классы-наследники (II)
Ключевые слова'.
• базовый класс абстрактный класс
• класс-наследник суперкласс
• защищённое поле переменные модуля

Подвижные объекты
Класс Подвижный объект из нашей игры отличается от базового клас­
са Игровой объект тем, что у него есть два дополнительных свой­
ства — скорость и курс (направление движения). Будем хранить их
в защищённых полях _v и _course (по-английски — курс). Курсом
будем называть угол а между вектором скорости объекта и осью ОХ,
измеренный в радианах (рис. 1.11).

Рис.

42
 Классы-наследники (II) §7

Конструктор нового класса имеет 6 параметров (не считая ссылки

self на сам объект):
class TMovingObject( TGameObject ):
def _ init__ ( self, x, у, width, height,
v, course ):
TGameObject.__ init__ ( self, x, y, width, height )
self._v = v
self._course = course
В самом начале вызывается конструктор базового класса
TGameObject. Он создаёт в памяти новый объект и сохраняет его
свойства х, у, width и height. Затем выполняются дополнительные
действия по созданию объекта класса TMovingObj ect — сохранение
заданной начальной скорости и курса во внутренних полях.
У класса TMovingObject должен быть метод для движения — move.
При выполнении этого метода нужно вычислить горизонтальное и вер­
тикальное смещения объекта и передвинуть изображение объекта на
экране в нужное место.
Пусть наш объект движется со скоростью v курсом а (рис. 1.12).

X (*1, J/1)

v ■ cos а • Д/
Рис. 1.12
За время At объект проходит расстояние v • At, так что из точки
(х, у) перемещается в точку (хг, yj, где:
хг = х + v • cosa • At,
ух = у - v • sina • At.
Из-за того что ось OY на экране направлена вниз, во второй формуле
появился знак «минус».
Для использования математических функций в начале программы
нужно подключить модуль math:
import math
Удобно принять за единицу времени интервал между двумя последо­
вательными вызовами процедуры update (она вызывается по таймеру),
тогда At = 1. Будем считать, что в поле _course хранится значение
курса — угла а — в радианах. Тогда метод move можно написать так:
class TMovingObject( TGameObject ):

def move( self ) :

dx = self. v*math.cos( self, course )

43
1 Программирование на языке Python

dy = -self._v*math.sin( self._course )
self._x += dx
self._y += dy
moveObjectBy( self._image, dx, dy )
Сначала вычисляются смещения по осям х и у, они записываются
в локальные переменные dx и dy. В следующих строках изменяются
поля объекта _х и _у и вызывается функция moveObjectBy из модуля
graph, которая перемещает круг на холсте.
Обратите внимание, что создать объект класса TMovingObject нель­
зя — у него, как и у базового класса, нет метода update. Поэтому
TMovingObject — это тоже абстрактный класс, он объединяет все
свойства подвижных объектов и служит только для создания классов-
наследников.

Космические корабли
Космический корабль — это подвижный объект, т. е. наследник клас­
са TMovingObject:
class TSpaceship( TMovingObject ):

В конструкторе класса нужно, прежде всего, вызвать конструктор

базового класса TMovingObject, а затем — создать изображение (круг
с синей заливкой) и сохранить ссылку на него в поле image:
class TSpaceship( TMovingObject ):
def _ init__ ( self, xCenter, yCenter,
radius, v, course ):
TMovingObject.__ init__ ( self,
xCenter, yCenter, 2*radius, 2*radius,
v, course )
brushColor ( "blue" )
self._image = circle ( xCenter, yCenter, radius )
Этот класс уже не должен быть абстрактным, так как нам нужно
создавать объекты класса. Поэтому необходимо определить для него
метод update. В этом методе передвинем объект, вызвав метод move, и
затем проверим, не столкнулся ли корабль со стенкой. Проверку стол­
кновения будет выполнять метод bounce (по-английски — отскок), ко­
торый мы скоро напишем.
class TSpaceship ( TMovingObject ):

def update( self ):

self.moveO # движение
self.bounce () # проверка столкновения

44
 Классы-наследники (II) §7

Обратите внимание, что метода move в классе TSpaceship нет. Но

он есть у базового класса TMovingObject, поэтому при вызове self,
move () на самом деле будет выполнен метод базового класса.
Отскок происходит тогда, когда объект касается границ холста. Гра­
ницы объекта можно определить с помощью функции coords:
xl, yl, х2, у2 = coords( self._image )
Здесь (хр Уу) — координаты левого верхнего угла объекта на холсте и
(х2, у2) — координаты его правого нижнего угла.
При отталкивании от левой и правой границ холста по законам
физики (угол отражения равен углу падения), нужно вычесть текущий
курс из развёрнутого угла величиной л радиан:
if xl <= 0 or х2 >= SCREEN_WIDTH:
self._course = math.pi - self._course
При отталкивании от верхней и нижней границ мы просто изменя­
ем знак курса на противоположный:
if yl <= 0 or у2 >= SCREEN_HEIGHT:
self._course = - self._course
Теперь можно полностью написать метод bounce:
class TSpaceship ( TMovingObject ):

def bounce( self ):

xl, yl, x2, y2 = coords( self._image )
if xl <= 0 or x2 >= SCREEN_WIDTH:
self.—course = math.pi - self._course
if yl <= 0 or у2 >= SCREEN_HEIGHT:
self.—course = - self._course
Класс TSpaceship готов, и теперь можно создавать космические ко­
рабли, добавляя их в тот же массив all Objects, где хранятся ссылки
на другие объекты:
NUMBER—OF—SPACESHIPS = 10
SIZE_OF_SPACESHIP = 5
for i in range(NUMBER_ОF_SPACESHIPS):
allObjects.append( TSpaceship(
randint( 0, SCREEN_WIDTH ), # центр
randint( 0, SCREEN_HEIGHT ),
SIZE—OF_SPACESHIP, # размер
randint( 1, 5 ), # скорость
randint( 0, 359 )*math.pi/180 ) # направление
)
Константы NUMBER—OF_SPACESHIPS и SIZE_OF_SPACESHIP определя­
ют количество и размер космических кораблей. Скорость корабля —

45
1 Программирование на языке Python

случайное целое число на отрезке [1; 5]. Курс выбирается случайным

образом в диапазоне от 0° до 359° и сразу переводится в радианы:
randint( 0, 359 )*math.pi/180
Вспомните, что в процедуре update для каждого элемента массива
allObjects вызывается метод update. Благодаря полиморфизму, для
космических кораблей сработает метод update из класса TSpaceship.
Осталось написать класс Странник (TRanger) — это специальный
космический корабль, который меняет направление движения. Приве­
дём сразу код класса TRanger, который является наследником класса
TSpaceship:
class TRanger( TSpaceship ):
def _ init__ ( self, xCenter, yCenter,
radius, v, course ):
TSpaceship.__ init__ ( self, xCenter, yCenter,
radius, v, course )
changeFillColor ( self._image, "yellow" )
def update( self ):
if randint(1, 20) == 1:
self._course = randint(0,359)*math.pi/180
super () .update()
В конструкторе класса TRanger сначала вызывается конструктор
базового класса TSpaceship, а затем цвет заливки круга изменяется
на жёлтый.
В начале метода update мы изменяем направление движения —
значение поля _course. Причем делаем это только тогда, когда вызов
функции randint (1,20) вернёт значение, равное 1, т. е. в среднем 1
раз за 20 периодов обновления картинки.
После изменения направления нужно передвинуть объект и прове­
рить, не столкнулся ли он со стенками. Но всё это уже есть в методе
update базового класса TSpaceship! Поэтому нам нужно просто вы­
звать этот метод базового класса — в языке Python он ещё называется
суперклассом:
super.update()
Закончить программу вы можете самостоятельно.

Модуль с классами
Большие программы обычно разбивают на модули, каждый модуль
хранится как отдельный файл. В модуль объединяются функции, свя­
занные между собой. Такой подход используется как в классическом
программировании, так в ООП.
В нашей программе в отдельный модуль gameobjects (в файл
gameobj ects. ру) можно вынести описания всех классов:

46
 Классы-наследники (II) §7

class TGameObject:

class TBlackHole( TGameObject ):

class TPulsar ( TBlackHole ) :

class TMovingObject( TGameObject ):

class TSpaceship( TMovingObject ):

class TRanger( TSpaceship ):

Поскольку в этих классах используются функции из других модулей

(graph, math и random), в начале модуля нужно поместить команды
импорта:
from graph import *
from random import randint
import math
В основной программе импортируем модуль gameobjects:
from gameobjects import *
Вроде бы всё сделано правильно, но при запуске программы вы
получите сообщение об ошибке: переменная SCREEN_WIDTH не найде­
на. Дело в том, что глобальные переменные в Python — это перемен­
ные модуля, а не всей программы. То есть модуль gameobjects ничего
«не знает» о переменных, объявленных в файле с основной програм­
мой. Поэтому размеры игрового поля, которые нужны для выполнения
отскока в методе bounce, в модуле gameobjects неизвестны.
Самый простой способ решения этой проблемы — добавить в файл
gameobjects.ру новые переменные и процедуру для их изменения:
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
def gameScreenSize( width, height ) :
global SCREEN_WIDTH, SCREEN_HEIGHT
SCREEN_WIDTH = width
SCREEN_HEIGHT = height
По умолчанию в этом модуле считается, что поле имеет размер
800 х 600 пикселей. Но эти значения всегда можно поменять, вызвав
процедуру gameScreenSize:
gameScreenSize( SCREEN_WIDTH, SCREEN_HEIGHT )
Таким образом, мы можем из основной программы изменить значения
глобальных переменных модуля.

47
1 Программирование на языке Python

Выводы
• В методах класса-наследника можно вызывать открытые методы
базового класса.
• Чтобы в методе класса-наследника обратиться к объекту базового
класса, используют метод super.
• В больших программах описания классов выделяют в модули,
которые хранятся как отдельные файлы.
• Глобальные переменные в языке Python — это переменные моду­
ля, а не всей программы.

Вопросы и задания
1. Проект. Соберите в одном файле программу из параграфа, ко­
торая выводит на экран объекты четырёх типов и выполняет их
анимацию.
2. Проект. Измените программу из параграфа так, чтобы космиче­
ский корабль, который попал в чёрную дыру или в пульсар, унич­
тожался. Вместо него должен появиться новый корабль в случай­
ном месте.
3. Переделайте программу из параграфа так, чтобы описание всех
классов находилось в отдельном модуле.
* 4. Проект. Измените программу из параграфа так, чтобы чёрная
дыра постепенно уменьшалась «без пищи», т. е. тогда, когда в неё
долгое время не попадают корабли.
* 5. Проект. Добавьте в игру из параграфа объекты класса
TDestroyer — специальные боевые космические корабли, кото­
рые охотятся за кораблями и странниками и уничтожают их при
встрече.
* *6. Проект. Измените поведение объектов класса TDestroyer из пре­
дыдущего задания так, чтобы они двигались к ближайшему объек­
ту типа TSpaceship или TRanger и уничтожали его при встрече.
* *7.Проект. Придумайте и запрограммируйте собственную игру, где
будут неподвижные и движущиеся объекты. Один объект должен
управляться игроком с клавиатуры.

§8
Событийно-ориентированное программирование
Ключевые слова'.
• сообщение • обработчик события
• событие • форма
• очередь сообщений • виджет
• цикл обработкисообщений • приложение

48
 Событийно-ориентированное программирование §8

Особенности современных прикладных программ

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

Сообщение — это блок данных определённой структуры, который

используется для обмена информацией между объектами.

Сообщение содержит:
• адрес объекта, которому посылается сообщение;
• числовой код сообщения;
• параметры (дополнительные данные), например координаты щелч­
ка мышью или код нажатой клавиши.
Сообщение может быть широковещательным, в этом случае вместо
адресата указывается специальный код, и сообщение поступает всем объ­
ектам определённого типа (например, всем главным окнам программ).
В классических программах (рис. 1.13), последовательность действий
заранее определена — основная программа выполняется строка за
строкой, вызывая процедуры и функции; все ветвления выполняются с
помощью условных операторов.

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

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

49
 Программирование на языке Python

игр нужно учитывать взаимодействие многих объектов, информация о

которых передаётся по сети в случайные моменты времени.
Во всех этих примерах программа должна «включаться в работу»
только тогда, когда получит условный сигнал, т. е. когда произойдёт
некоторое событие (изменение состояния).

Событие — это переход какого-либо объекта из одного состояния в

другое.

События могут быть вызваны действиями пользователя (управле­

ние клавиатурой и мышью), сигналами от внешних устройств (переход
принтера в состояние готовности, получение данных из сети), получе­
нием сообщения от другой программы. При наступлении событий объ­
екты посылают друг другу сообщения.
Таким образом, весь ход выполнения современной программы опре­
деляется происходящими событиями, а не жёстко заданным алго­
ритмом. Поэтому говорят, что программы управляются событиями, а
соответствующий стиль программирования называют событийно-ориен­
тированным, т. е. основанным на обработке событий.
Нормальный режим работы событийно-ориентированной програм­
мы — это цикл обработки сообщений. Все сообщения (от мыши, кла­
виатуры и драйверов устройств ввода и вывода и т. п.) сначала посту­
пают в единую очередь сообщений операционной системы. Кроме того,
для каждой программы операционная система создаёт отдельную оче­
редь сообщений и помещает в неё все сообщения, предназначенные
этой программе (рис. 1.14).
Клавиатура, мышь, ...

Системная очередь
сообщений

Очередь Операционная
программы система

Основная
программа

Программа Обработчики сообщений

Рис. 1.14
Основная программа выбирает очередное сообщение из очереди и вы­
зывает специальную процедуру — обработчик этого сообщения (если
он есть). Когда пользователь закрывает окно программы, ей посылает­
 Событийно-ориентированное программирование §8

ся особое сообщение, при получении которого цикл обработки сообще­

ний (и работа всей программы) завершается (рис. 1.15).
Таким образом, главная задача программиста — написать содержа­
ние обработчиков всех сообщений, на которые должна реагировать про­
грамма. Если для полученного сообщения нет обработчика, вызывается
обработчик по умолчанию. Чаще всего при этом сообщение игнори­
руется.

Ещё раз подчеркнём, что последовательность вызовов обработчиков

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

Программы с графическим интерфейсом

В этом разделе рассматриваются основные принципы построения про­
грамм с графическим интерфейсом на языке Python. Для этого мы бу­
дем использовать графическую библиотеку tkinter, которая входит в
стандартную библиотеку Python. Существуют и другие библиотеки для
разработки интерфейсов на Python: wxPython, PyGTK, PyQt. Их нужно
устанавливать отдельно.
В программе с графическим интерфейсом может быть несколько
окон, которые обычно называют формами1^. На форме размещаются
элементы графического интерфейса: поля ввода, кнопки, списки и др.
Они называются виджетами (англ, widget — украшение, элемент) или
компонентами. Каждый компонент — это объект определённого клас­
са, у которого есть свойства и методы.
Для каждого события, которое происходит с компонентом, можно
задать процедуру-обработчик. Она будет автоматически вызвана, ког­
да произойдёт соответствующее событие. Примеры таких событий — это
щелчок мышью на кнопке (или другом объекте), выбор элемента списка,
изменение размеров формы, нажатие клавиши на клавиатуре и т. д.
В tkinter они называются окнами верхнего уровня (Toplevel).

51
1 Программирование на языке Python

Далее в этой главе основное внимание будет уделяться принци­

пам проектирования программ с графическим интерфейсом, а не осо­
бенностям библиотеки t kin ter. Мы будем применять так называе­
мую «обёртку» simpletk — специальный модуль, который упрощает
использование сложной библиотеки1*.

Простейшая программа
Простейшая программа с графическим интерфейсом состоит из трёх
строк:
from simpletk import * # (1)
арр = TApplication( "Первая форма" ) # (2)
app.runO # (3)
Вероятно, вам понятна первая строка: из модуля simpletk
импортируются все функции (для того, чтобы при их использовании
не нужно было каждый раз указывать название модуля). В строке 2
создаётся объект класса TApplication — это приложение (программа,
от англ, application — приложение). Конструктору передаётся заголо­
вок главного окна программы.
В последней строке с помощью метода run (по-английски — запуск)
запускается цикл обработки сообщений, скрытый внутри этого метода.
Таким образом, здесь тоже использован принцип инкапсуляции (скры­
тия внутреннего устройства).
Приведённую выше программу можно запустить, и вы увидите окно,
показанное на рис. 1.16.

, Первая форма

Рис. 1.16

Свойства формы
Класс TApplication — это класс-наследник класса Тк библиоте­
ки t kin ter. У него есть методы, позволяющие управлять свойствами
окна. Например, можно изменить начальное положение окна на экране
с помощью свойства position:
арр.position = (100, 300)
Позиция окна — это кортеж, состоящий из х-координаты и
1/-координаты левого верхнего угла окна на экране. Обе координаты
задаются в пикселях.
Модуль simpletk можно скачать на сайте автора http://kpolyakov.spb.ru/school/
probook/python.htm.

52
 Событийно-ориентированное программирование §8

Аналогично изменяются и размеры окна:

арр.size = (500, 200)
Здесь первый элемент кортежа — ширина окна, а второй — высота
окна (в пикселях).
Свойство resizable (от англ, изменяемый размер) позволяет запре­
тить изменение размеров окна по одному или обоим направлениям.
Например, вызов
арр.resizable = (True, False)
разрешает только изменение ширины (первый аргумент — True), а из­
менить высоту окна будет невозможно (второй аргумент — False).
С помощью свойств minsize и maxsize можно установить мини­
мальные и максимальные размеры формы:
арр.minsize = (100, 200)
Теперь ширина формы не может быть меньше 100 пикселей, а высо­
та — меньше 200 пикселей.

Обработчик события
Рассмотрим простой пример. Многие программы запрашивают под­
тверждение, когда пользователь завершает их работу. Это делается для
того, чтобы по ошибке не потерять нужные данные.
Когда пользователь закрывает окно, происходит событие «запрос на
закрытие окна». При обработке этого события нужно спросить пользо­
вателя, не ошибся ли он, т. е. выдать сообщение в диалоговом окне
(рис. 1.17) и обработать ответ.

/ Подтверждение

• Вы действительно хотите выйти из программы?

ОК Отмена

Рис- 1.17

Работа программы завершается только в том случае, если пользова­

тель щёлкнет по кнопке ОК.
Для вывода диалогового окна можно использовать готовую функцию
askokcancel из модуля messagebox пакета tkinter. По-английски
ask — спросить, ОК — кнопка OK, cancel обозначает кнопку «Отме­
на». Импортировать эту функцию (подключить к нашей программе)
можно так:
from tkinter.messagebox import askokcancel

53
1 Программирование на языке Python

Теперь можно написать процедуру-обработчик:

def askOnExit():
if askokcancel( "Подтверждение",
"Вы действительно хотите выйти из программы?" ):
арр.destroy()
Функция askokcancel принимает два аргумента: заголовок окна и
сообщение для пользователя. Она возвращает ненулевое значение, если
пользователь щёлкнул по кнопке ОК. В этом случае вызывается метод
destroy (в переводе с английского — разрушить): окно удаляется из
памяти, и работа программы завершается.
Теперь нужно установить обработчик, т. е. связать только что напи­
санную процедуру с нужным событием:
арр.onCloseQuery = askOnExit
Здесь onCloseQuery — название обработчика события (от англ, on
close query — «при запросе на закрытие»). Справа от оператора при­
сваивания записано название нашей процедуры-обработчика.

Выводы
• Обмен данными между современными программами происходит с
помощью сообщений.
• Сообщение — это блок данных определённой структуры, который
используется для обмена информацией между объектами.
• Событие — это переход какого-либо объекта из одного состояния
в другое.
• Современные программы с графическим интерфейсом основаны на
обработке событий, вызванных действиями пользователя и посту­
плением данных из других источников. События могут происхо­
дить в любой последовательности.
• С любым событием можно связать процедуру — обработчик собы­
тия, — которая будет вызываться при наступлении этого события.
• Окна в программе с графическим интерфейсом называют формами
или окнами верхнего уровня.
• Элементы графического интерфейса (поля ввода, списки, кнопки и
др.) называются виджетами или компонентами.
• Для построения программ с графическим интерфейсом в Python
можно использовать библиотеку tkinter.

Вопросы и задания
1. Что такое графический интерфейс?
2. Как графический интерфейс связан с объектно-ориентированным
подходом к программированию?
3. Что такое сообщение? Какие данные в него входят?
4. Что такое широковещательное сообщение?

54
 Использование компонентов (виджетов) §9

5. Чем принципиально отличаются современные программы от клас­

сических?
6. Что такое событие? Какое программирование называют событийно­
ориентированным?
7. Что такое обработчик события?
8. Объясните разницу между понятиями «событие» и «сообщение».
9. В чём различие между работой событийно-ориентированной и
«обычной» программы?
10. Что такое форма?
11. В чём проявляется объектно-ориентированный подход к разработке
интерфейса?
12. Что такое объект-приложение?
13. Почему в основной программе, приведённой в параграфе, не виден
цикл обработки сообщений?
14. Назовите известные вам свойства формы. Как можно их изменять?
15. Проект. Постройте программу, которая запрашивает разрешение на
завершение работы. Попробуйте изменять свойства главного окна.
*16. Проект. Найдите в дополнительных источниках информацию о дру­
гих свойствах главного окна Toplevel и попробуйте их изменять.
*17. Проект. Найдите в дополнительных источниках информацию о
дугих стандартных диалогах, входящих в модуль messagebox.
Попробуйте их использовать.

Интересные сайты
kpolyakov.spb.ru/school/probook/python.htm — модуль simp let к для
создания приложений с графическим интерфейсом на Python
wxpython.org — библиотека wxPython
pygtk.org — библиотека PyGTK
riverbankcomputing.com/software/pyqt/intro — библиотека PyQt

§9
Использование компонентов (виджетов)
Ключевые слова:
» виджет • обработчик события
•. компонент • исключение
родительский объект

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

55
 Программирование на языке Python

исходные данные), в это окно нужно добавить элементы интерфейса —

надписи (метки), кнопки, выпадающие списки, флажки, переключате­
ли и т. п. Каждый такой элемент — это объект, имеющий свой набор
свойств и методов. Объекты, размещаемые на форме, называются вид­
жетами или компонентами.
Мы построим программу для просмотра изображений, которая умеет
открывать графические файлы и показывать их в левом верхнем углу
или по центру рабочей области (рис. 1.18 и см. цветной рисунок на
обороте обложки).
Флажок
TCheckBox
Кнопка / Просмотр рисунков/ / Просмотр рисунков
TButton Открыть файл * В центре Открыть файл v В центре

Панель
Рисунок TPanel
Т Image

Рис. 1.18

К сожалению, наша программа будет гарантированно работать толь­

ко с файлами формата GIF. С остальными распространёнными форма­
тами (JPEG, PNG, BMP) библиотека tkinter работать не умеет. Для
поддержки файлов этих форматов нужно установить бесплатную би­
блиотеку Pillow (PIL). Модуль simpletk при загрузке автоматически
подключит её, если она установлена.
На форме (см. рис. 1.18) размещены четыре компонента:
• кнопка с надписью «Открыть файл» (компонент TButton, наслед­
ник класса Button библиотеки tkinter);
• флажок с текстом «В центре» (компонент TCheckBox, наследник
класса Checkbox библиотеки tkinter);
• панель, на которой расположены кнопка и флажок (компонент
TPanel, наследник класса Frame библиотеки tkinter);
• поле для рисунка, заполняющее всё остальное место на форме
(компонент Tlmage, наследник класса Canvas библиотеки tkinter).
Начнем с простой программы, которая устанавливает свойства глав­
ного окна:
from simpletk import *
арр = TApplication( "Просмотр рисунков" )
арр.position = (200, 200)
арр.size = (300, 300)
арр.run()
Напомним, что вызов метода run должен стоять в самом конце тек­
ста программы. Поэтому все команды, рассмотренные далее, нужно до­
бавлять выше него.

56
 Использование компонентов (виджетов) §9

Добавим верхнюю панель, на которой будут расположены кнопка и

флажок:
panel = TPanel( арр, relief = "raised", height = 35, bd = 1 )
Конструктору класса TPanel передаётся несколько параметров:
арр — ссылка на родительский объект — главное окно;
relief — объёмный вид, значение "raised" означает «при­
поднятый»; этот параметр может принимать также значения "flat"
(плоский, по умолчанию), "sunken" («утопленный») и др.;
height — высота в пикселях;
bd (от англ, border — граница) — толщина границы в пикселях.
Родительский объект — это объект, отвечающий за перемещение
и вывод на экран всех своих дочерних объектов. Здесь панель — это
дочерний объект для главного окна.
Разместим панель на форме, прижав её к верхней границе:
panel.align = "top"
Свойство align задаёт расположение панели внутри родительско­
го окна: "top" означает прижать вверх, "bottom" — вниз, "left" —
влево, "right" — вправо.
Далее нужно добавить на панель компоненты TButton (кнопка) и
TCheckBox (флажок). Для них «родителем» уже будет не главное окно,
а панель panel. Начнём с кнопки:
openBtn = TButton( panel, width = 13,
text = "Открыть файл" )
openBtn.position = (5, 5)

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

параметр — это родительский объект (панель), параметр width задаёт
ширину кнопки в символах (не в пикселях!), а параметр text — над­
пись на кнопке. В следующей строке с помощью свойства position
задаются координаты левого верхнего угла кнопки на панели.
Используя тот же подход, создаём и размещаем флажок:
centerCb = TCheckBox( panel, text = "В центре" )
centerCb.position = (115, 5)
Сейчас уже можно запустить программу и убедиться, что все компо­
ненты появляются на форме, но пока не работают. И это неудивитель­
но, ведь мы не определили, как они должны реагировать на события.
В нижнюю часть формы нужно «упаковать» поле для рисунка —
объект класса Tlmage — так, чтобы он занимал все оставшееся место.
Создаём такой объект:
image = Tlmage( арр, bg = "white" )

57
1 Программирование на языке Python

Его «родителем» будет главное окно арр, параметр bg (от англ, back­
ground — фон) задаёт цвет холста (англ, white — белый). Затем «упа­
ковываем» этот объект в окно так, чтобы он заполнял всю оставшуюся
область по вертикали и горизонтали:
image.align = "client"
Теперь построим обработчики событий. Нас интересуют два события:
• щелчок по кнопке (после него должен появиться диалог выбора
файла);
• переключение флажка (при этом нужно изменить режим показа
рисунка).
Сначала определим, что нужно сделать в случае щелчка мышью по
кнопке. Псевдокод выглядит так:
выбрать файл с рисунком
if файл выбран:
загрузить рисунок в компонент image
Для выбора файла используем стандартный диалог операцион­
ной системы. Его вызывает функция askopenfilename из модуля
filedialog библиотеки tkinter. Этот модуль нужно импортировать в
начале программы:
from tkinter import filedialog
Теперь вызываем функцию askopenfilename и передаём ей расши­
рения, которые будут показаны в выпадающем списке Тип файла'.
fname = filedialog.askopenfilename (
filetypes = [("Файлы GIF", "*.gif"),
("Все файлы", "*.*")] )
Именованный аргумент filetypes — это список, составленный из
кортежей. Каждый кортеж содержит два элемента: текстовое описание
и маску для выбора имён файлов.
После вызова этой функции в переменную fname будет записан
результат её работы — имя выбранного файла или пустая строка, если
пользователь отказался от выбора (нажал на кнопку Отмена). Если
файл всё-таки выбран (строка fname не пустая), записываем имя фай­
ла в свойство picture объекта TImage:
if fname:
image.picture = fname
При изменении этого свойства файл будет автоматически загружен
и выведен на экран, эту операцию выполняет класс TImage. Обрати­
те внимание, что пустая строка в Python воспринимается как ложное
значение. Поэтому если пользователь не выбрал файл, условие в опе­
раторе if будет ложно и рисунок не изменится.

58
 Использование компонентов (виджетов) §9

Теперь можно составить всю процедуру-обработчик:

def selectFile( sender ):
fname = filedialog.askopenfilename(
filetypes = [("Файлы GIF", "*.gif"),
("Все файлы", "*.*")] )
if fname:
image.picture = fname
Она должна принимать единственный параметр sender — ссылку на
объект, с которым произошло событие. Эта ссылка нужна тогда, когда
один обработчик «обслуживает» несколько компонентов. Тогда в обработ­
чике мы сможем определить, какой из них стал источником события.
В нашем случае эта ссылка не нужна, и мы её использовать не будем.
Установим обработчик события: сделаем так, чтобы после щелчка по
кнопке вызывалась процедура selectFile. Свойство, определяющее об­
работчик события «щелчок мышью», называется onClick (от англ, on
click — в ответ на щелчок):
openBtn.onClick = selectFile
Если сейчас запустить программу, то можно проверить, как загру­
жаются файлы.
Остаётся добавить второй обработчик события, который при измене­
нии состояния флажка centered переключает режим вывода рисунка.
Напишем код такого обработчика:
def cbChanged( sender ) :
image.center = sender.checked
image.redrawlmage()
У объекта Tlmage есть логическое свойство center, которое долж­
но быть равно True, если нужно вывести рисунок по центру поля и
False, если рисунок выводится в левом верхнем углу холста.
Вместе с тем, у флажка TCheckBox есть логическое свойство
checked, которое равно True, если флажок включён.
В первой строке процедуры cbChanged мы задали значение свойства
center в соответствии с состоянием флажка. Затем вызывается метод
redrawlmage (от англ, redraw image — перерисовать рисунок), кото­
рый выводит рисунок в новой позиции.
Этот обработчик нужно установить, т. е. подключить к событию «из­
менение состояния флажка». Для этого необходимо записать ссылку на
него (адрес обработчика) в свойство onChange (от англ, on change —
при изменении):
centerCb.onChange = cbChanged
Теперь, запустив программу, мы должны увидеть правильную работу
всех элементов управления. Более того, при изменении размеров окна
перерисовка выполняется автоматически (за это также «отвечает» ком­
понент Tlmage).

59
1 Программирование на языке Python

Отметим следующие важные особенности:

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

Новый класс: всё в одном

Доведём объектный подход до логического завершения, собрав все
элементы интерфейса в новый класс TlmageViewer — оконное прило­
жение для просмотра рисунков. При этом основная программа будет
состоять всего из двух строк: создания главного окна и запуска про­
граммы:
class TlmageViewer ( TApplication ):
... # здесь будет описание класса TimageViewer

арр = TlmageViewer()
арр.run()
Вместо многоточия нужно добавить описание класса: конструктор,
который создаёт и размещает на форме все компоненты, и обработчики
событий.
Начнём с конструктора:
class TlmageViewer ( TApplication ):
def _init__ (self):
TApplication.__ init__ ( self, "Просмотр рисунков" )
self.position = (200, 200)
self.size = (300, 300)
self.panel = TPanel(self, relief = "raised",
height = 35, bd = 1)
self.panel.align = "top"
self.image = TImage( self, bg = "white" )
self.image.align = "client"
self.openBtn = TButton( self.panel,
width = 15, text = "Открыть файл" )
self.openBtn.position = (5, 5)
self.openBtn.onClick = self.selectFile
self.centerCb = TCheckBox( self.panel,
text = "В центре" )
self.centerCb.position = (115, 5)
self.centerCb.onChange = self.cbChanged
Сначала мы вызываем конструктор базового класса TApplication и
настраиваем свойства окна. Вместо имени объекта арр в предыдущей
программе используем self — ссылку на текущий объект.

60
 Использование компонентов (виджетов) §9

Затем строятся и размещаются компоненты, причём ссылки на них

становятся полями объекта (см. «приставку» self, перед именами). Ина­
че мы не сможем обратиться к компонентам в обработчиках событий.
Обработчики событий — функции selectFile и cbChanged — тоже
должны быть членами класса TlmageViewer, поэтому их первым пара­
метром будет self, а вторым — ссылка sender на объект — источник
события:
class TlmageViewer ( TApplication ):
... # здесь должен быть конструктор __ init__
def selectFile ( self, sender ):
fname = filedialog.askopenfilename (
filetypes = [("Файлы GIF", "*.gif"),
("Все файлы", "*.*••)] )
if fname:
self.image.picture = fname
def cbChanged( self, sender ):
self.image.center = sender.checked
self.image.redrawlmage()
Поскольку при создании объекта в конструкторе мы запомнили
ссылки на все элементы в полях объекта, теперь можно к ним обра­
щаться через ссылку self для изменения свойств.
В итоге получилась программа, полностью построенная на принци­
пах объектно-ориентированного программирования: все данные и мето­
ды работы с ними объединены в классе TlmageViewer.

Ввод и вывод данных

Во многих программах нужно, чтобы пользователь вводил тексто­
вую или числовую информацию. Чаще всего для этого применяют
поле ввода — компонент TEdit (наследник класса Entry библиотеки
tkinter). Для доступа к введённой строке используется его свойство
text (в переводе с английского — текст).
Построим программу для перевода составляющих цвета модели RGB
в соответствующий шестнадцатеричный код, который применяется для
задания цвета в языке HTML1’ (рис. 1.19 и см. цветной рисунок на
обороте обложки).
Код цвета в языке HTML начинается знаком #, за ним записывают
без разделителей три двузначных числа в шестнадцатеричной системе
счисления — яркости красной, зелёной и синей составляющих цвета в
модели RGB. Например, при R = 123, G = 56 и В = 80 мы должны
получить код #7В3850, поскольку 123 = 7В16, 56 = 3816 и 80 = 5016.

’’ Язык HTML (англ. HyperText Markup Language — язык разметки гипертекста)

используется для оформления информации на веб-страницах.

61
 Программирование на языке Python

Поле ввода г Edit

TEdit

Q RGB-коди, p'i's Метка r rbLabel

R= 123 #7B3850 TLabel
Метки G=
TLabel B=
Метка rgbRect
TLabel
Поле ввода bEdit Поле ввода gEdit
TEdit TEdit
Рис. 1.19
На форме (см. рис. 1.19) расположены:
• три поля ввода (в них пользователь может задать значения крас­
ной, зелёной и синей составляющих цвета в модели RGB);
• прямоугольник (компонент TLabel), цвет которого изменяется со­
гласно введённым значениям;
• несколько меток (компонентов TLabel).
Метки — это надписи, которые пользователь редактировать не мо­
жет, однако из программы их содержание можно изменять через
свойство text.
Во время работы программы будут использоваться:
• поля ввода rEdit, gEdit и bEdit;
• метка rgbLabel, с помощью которой будет выводиться резуль­
тат — код цвета;
• метка без текста rgbRect — прямоугольник, закрашенный нуж­
ным цветом.
В качестве начальных значений в свойство text полей ввода можно
записать любые целые числа от 0 до 255.
При изменении содержимого одного из трёх полей ввода нужно
обработать введённые данные, вывести HTML-код цвета в свойство text
метки rgbLabel, а также изменить цвет фона для метки rgbRect.
Обработчик события, которое происходит при изменении текста в
поле ввода, называется onChange. Так как при изменении любого из
трёх полей нужно выполнить одинаковые действия, можно установить
один и тот же обработчик события onChange для всех трёх компонен-
тов. Процедура-обработчик может выглядеть так:
def onChange ( sender ) :
г = int( rEdit.text ) # (1)
g = int( gEdit.text ) # (2)
b = int( bEdit.text ) # (3)
s = "#{:02X}{:02X}{: 02X} . format (r, g, b) # (4)
rgbRect.background =■- s # (5)
rgbLabel.text = s # (6)

62
 Использование компонентов (виджетов) §9

Содержимое всех полей ввода преобразуется в числа с помощью

функции int (строки 1-3). Затем в строке 4 строится символьная
строка — шестнадцатеричная запись цвета в HTML-формате. Значения
красной, зелёной и синей составляющих (переменные г, g и Ь) выво­
дятся по формату 02Х, т. е. в шестнадцатеричной записи, состоящей
из двух цифр с заполнением пустых позиций нулями. В строке 5 из­
меняется фон метки-прямоугольника rgbRect, а в строке 6 код цвета
заносится в метку rgbLabel.
В основной программе создаём объект-приложение с главным
окном:
арр = TApplication ( "RGB-кодирование" )
app.size = (210, 90)
арр.position = (200, 200)
и метки слева от полей ввода:
fSans = ( "MS Sans Serif", 12 )
IblR = TLabel( app, text = "R =", font = fSans )
IblR.position = (5, 5)

IblG = TLabel( app, text = "G = ", font = fSans )

IblG.position = (5, 30)

IblB = TLabel( app, text = "B =", font = fSans )

IblB.position = (5, 55)
Мы определили шрифт для меток с помощью параметра font. Его
значение — это кортеж fSans, который в данном случае состоит из
двух элементов: названия шрифта ("MS Sans Serif") и его размера
в пунктах (12).
Далее создадим метку для вывода кода цвета:
fCourier = ( "Courier New", 16, "bold" )
rgbLabel = TLabel( app, text = "#000000",
font = fCourier, fg = "navy" )
rgbLabel.position = (100, 5)

и прямоугольник, который будет закрашен выбранным цветом:

rgbRect = TLabel( арр, text = width = 15, height = 3 )

rgbRect.position = (105, 35)
Размеры меток — ширина (англ, width) и высота (англ, height) —
указываются не в пикселях, а в символах.
Шрифт для метки rgbLabel задаётся в виде кортежа fCourier из
трёх элементов: названия шрифта ("Courier New"), размера (16) и
свойства «жирный» (англ. — bold).

63
1 Программирование на языке Python

Параметр fg (от англ, foreground — цвет переднего плана) при вы­

зове конструктора определяет цвет символов ("navy" — тёмно-синий,
от англ, navy — военно-морской).
Добавляем на форму три поля ввода:
rEdit = TEdit( арр, font = fSans, width = 5 )
rEdit.position = (45, 5)
rEdit.text = "123"
gEdit = TEdit( app, font = fSans, width = 5 )
gEdit.position = (45, 30)
gEdit.text = "56"
bEdit = TEdit( app, font = fSans, width = 5 )
bEdit.text = "80"
bEdit.position = (45, 55)
Для каждого из них устанавливаем один и тот же обработчик
onChange, который вызывается при любом изменении текста в поле
ввода:
rEdit.onChange = onChange
gEdit.onChange = onChange
bEdit.onChange = onChange
После этого запускаем программу:
app.run()
Обратите внимание, что установку обработчика события нужно
делать тогда, когда все объекты, используемые в обработчике onChange
(поля ввода rEdit, gEdit, bEdit и метки rgbLabel и rgbRect) уже
созданы.
При желании можно переписать программу в стиле ООП, как это
мы сделали в конце предыдущего примера. Попробуйте выполнить это
задание самостоятельно.

Обработка ошибок
Если в предыдущей программе пользователь введёт в поле ввода не
цифры, а другие символы или пустую строку, программа выдаст сооб­
щение о необработанной ошибке и аварийно завершит работу. Хорошая
программа никогда не должна завершаться аварийно. Поэтому нужно
обрабатывать все ошибки, которые можно заранее предусмотреть.
В современных языках программирования для обработки ошибок
применяют исключения. Исключение — это исключительная (ошибоч­
ная, аварийная, непредвиденная) ситуация, из-за которой программа
не может нормально продолжать работу.
Все «опасные» участки кода, при выполнении которых может воз­
никнуть ошибка, нужно поместить в блок try-except:

64
 Использование компонентов (виджетов) §9

try:
# "опасные" команды
except:
# обработка ошибки
Слово try по-английски означает «попытаться», except — «исклю­
чать». Программа попадает в блок except только тогда, когда при
выполнении команд между try и except произошла ошибка.
В нашей программе «опасные» команды — это преобразование дан­
ных из текста в числа (вызовы функции int). В случае ошибки мы вы­
ведем вместо кода цвета знак вопроса, а цвет фона метки-прямоуголь­
ника rgbRect изменим на стандартное значение "SystemButtonFace",
которое означает «системный цвет кнопки». При этом прямоугольник
станет невидимым, потому что сольётся с фоновым цветом окна.
Улучшенный обработчик с защитой от неправильного ввода прини­
мает вид:
def onChange( sender ):
try:
# получить данные из полей ввода
s = "#{:02Х}{:02Х}{:02Х}".format(г, д, Ь)
bkColor = s
except:
s = "?"
bkColor = "SystemButtonFace"
rgbLabel.text = s
rgbRect.background = bkColor
Здесь переменная s обозначает шестнадцатеричный код цвета (в виде
символьной строки), а переменная bkColor — цвет прямоугольника.
Если при попытке получить новый код цвета происходит ошибка, то
выполняются две команды в блоке except: в переменные s и bkColor
записываются значения, сообщающие о неудаче.
В модели RGB все составляющие цвета должны быть не меньше 0 и не
больше 255, т. е. должны находиться в диапазоне range (256). Поэтому в
обработчик полезно добавить ёщё проверку допустимости введённых чисел:
def onChange( sender ):
s = "?"
bkColor = "SystemButtonFace"
try:
r =int( rEdit.text )
g =int( gEdit.text )
b =int( bEdit.text )
if r in range(256) and \
g in range(256) and b in range(256):
s = "#{:02x}{:02x}{:02x}".format(r, g, b)
bkColor = s

65
1 Программирование на языке Python

except:
pass
rgbLabel.text = s
rgbRect.background = bkColor
Здесь в самом начале процедуры-обработчика мы записываем значе­
ния по умолчанию в переменные s и bkColor. В блоке except поме­
щён «пустой» оператор pass, т. е. ошибки игнорируются. Если поль­
зователь ввёл ошибочные данные (не числа или числа вне отрезка
[0; 255]), программа не выполнит команды в теле оператора if, и
значения переменных s и bkColor не изменятся.

Выводы
• Для организации диалога с пользователем на форме размещают
объекты, называемые виджетами или компонентами.
• Любой компонент может реагировать на некоторый набор собы­
тий. С каждым событием, которое нужно обрабатывать, необходи­
мо связать обработчик события.
• Обработчик события — это процедура, которая получает управле­
ние каждый раз, когда происходит данное событие.
• Один обработчик события может быть связан с несколькими ком­
понентами. Ссылка на конкретный компонент, который вызвал со­
бытие, передаётся в обработчик события как первый параметр.
• Для выбора файлов на диске можно использовать стандартные
диалоги из модуля filedialog библиотеки tkinter.
• Всё приложение с графическим интерфейсом можно оформить как
один класс. Компоненты добавляются на форму в конструкторе, а
обработчики становятся методами нового класса.
• Для обработки ошибок используют механизм исключений. Ко­
манды, которые могут вызвать ошибку, заключаются в отдель­
ный блок try. В следующем блоке, который начинается словом
except, записывают команды, выполняемые в случае ошибки.
Вопросы и задания
1. Что такое компоненты? Зачем они нужны?
2. Объясните, как связаны компоненты и идея инкапсуляции.
3. Что такое родительский и дочерний объекты?
4. Какую роль играет свойство align в размещении элементов на
форме?
5. Что такое стандартный диалог? Как его использовать?
6. Назовите основное свойство флажка (TCheckBox). Как его использо­
вать?
7. Чем отличается метка от элемента TEdit?
8. Как обрабатываются ошибки в современных программах? В чём, на
ваш взгляд, преимущества и недостатки такого подхода?

66
 Создание компонентов §10

9. Почему в последнем варианте обработчика onChange (из параграфа)

удобно присвоить значения переменным s и bkColor в начале про­
граммы, а не в блоке except?
10. Проект. Напишите программу для построения RGB-кода цвета в
стиле ООП, убрав все действия по созданию формы в конструктор
класса. Обработчики событий также должны быть членами класса.
11. Проект. Разработайте программу для перевода морских миль в
километры (1 миля = 1852 м).
12. Проект. Разработайте программу для перевода суммы денег из
рублей в другие валюты и обратно.
13. Проект. Разработайте программу для перевода чисел из десятичной
системы в двоичную, восьмеричную и шестнадцатеричную.
14. Проект. Разработайте программу для вычисления информационного
объёма рисунка по его размерам и количеству цветов в палитре.
15. Проект. Разработайте программу для вычисления информационного
объёма звукового файла при известных длительности записи звука,
частоте дискретизации и глубине кодирования (числу битов на один
результат измерения).
16. Проект. Разработайте программу для решения системы двух
линейных уравнений. Обратите внимание на обработку ошибок при
вычислениях.
Интересные сайты
younglinux.info/tkinter.php — tkinter. Программирование графичес­
кого интерфейса
effbot.org/tkinterbook/tkinter-index.htm — учебник по пакету tkinter
pypi.python.org/pypi/Pillow/ — библиотека Pillow для работы с изо­
бражениями в Python

§10
Создание компонентов
Ключевые слова:
• компонент поле
• наследование метод
• базовый класс обработчик события

Зачем это нужно?

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

67
1 Программирование на языке Python

того, чтобы получить нужное нам поведение (ввод целых чисел), мы

добавили обработку ошибок в процедуру onChange, а для перевода тек­
стовой строки в число каждый раз использовали функцию int.
Если такие поля ввода нужны часто и в разных программах, мож­
но избавиться от этих рутинных операций. Для этого создаётся новый
компонент, который обладает всеми необходимыми свойствами.
Конечно, можно создавать компонент «с нуля», но так почти никто
не делает. Обычно задача сводится к тому, чтобы как-то улучшить су­
ществующий стандартный компонент, который уже есть в библиотеке.

Компонент для ввода целых чисел

Мы будем совершенствовать компонент TEdit (поле ввода), поэтому
новый компонент TIntEdit будет наследником класса TEdit, а класс
TEdit будет соответственно базовым классом для класса TIntEdit:
class TIntEdit ( TEdit ):

В стандартный класс TEdit нужно внести два изменения:

• все некорректные символы, которые приводят к тому, что текст
нельзя преобразовать в целое число, должны блокироваться авто­
матически, без установки дополнительных обработчиков событий;
• компонент должен уметь сообщать числовое значение целого типа;
для этого мы добавим к нему свойство value (по-английски —
значение).
Сначала построим конструктор нового класса:
class TIntEdit( TEdit ):
def _ init__ ( self, parent, **kw ):
TEdit.__ init__ ( self, parent, **kw )
При вызове этого конструктора нужно указать, по крайней мере,
один параметр — ссылку на родительский объект parent. Затем могут
следовать именованные параметры (подробности можно найти в Интер­
нете в описании компонента Entry библиотеки tkinter). Запись с дву­
мя звёздочками **kw говорит о том, что они «собираются» в словарь.
Пока новый класс TIntEdit ничем не отличается от TEdit. Добавим
к нему свойство value. Для этого введём закрытое поле _ value, в
котором будем хранить последнее правильное числовое значение:
class TIntEdit( TEdit ):
def _ init__ ( self, parent, **kw ):
TEdit.__ init__ ( self, parent, **kw )
self._ value = 0
def _ setValue( self, value ):
self._ value = value
self.text = str( value )
value = property( lambda x: x.__ value, __ setValue )

68
 Создание компонентов §10

Последняя часть этого описания говорит о том, что для чтения вве­
дённого числового значения используется лямбда-функция, возвраща­
ющая значение скрытого поля _ value. Метод записи _ setvalue
сохраняет переданное число в поле _ value, а затем записывает в
свойство text в виде символьной строки.
Для того чтобы заблокировать ввод нецифровых символов, использу­
ем обработчик события onValidate (от англ, validate — проверять на
правильность) компонента TEdit. Установим этот обработчик на скры­
тый метод нового класса TIntEdit, который назовём _ validate. Об­
работчик должен возвращать логическое значение: True, если символ
допустимый, и False, если нет (тогда ввод этого символа блокирует­
ся). В следующем коде оставлены только те строки, который относятся
к установке нового обработчика:
class TIntEdit( TEdit ):
def _ init__ ( self, parent, **kw ):

self.onValidate = self.__ validate

def _ validate( self ):
try:
newValue = int( self.text )
self.__value = newValue
return True
except:
return False
При получении сигнала о событии «нужна проверка» обработчик
пытается преобразовать новое значение свойства text в число. Если
это удаётся, полученное число записывается в переменную _ value и
возвращается результат True. Если произойдёт ошибка, она будет пере­
хвачена с помощью исключения, и управление будет передано в блок
except, откуда функция вернёт значение False.
Готовый компонент лучше всего поместить в отдельный модуль,
который можно назвать int_edit.py.

Программа с новым компонентом

Построим программу, использующую новый компонент. Она будет пе­
реводить целые числа из десятичной системы в шестнадцатеричную
(рис. 1.20).
/ Шестнадцатеричная система Г^~|Г(=ПЙ8й|

1001| ЗЕ9

Поле decEdit \ /Метка hexLabel

TIntEdit TLabel
Рис. 1.20

69
 Программирование на языке Python

Импортируем компонент TIntEdit из модуля int edit:

from int_edit inport TIntEdit
Создаём объект-приложение:
app = TApplication( "Шестнадцатеричная система" )
app.size = ( 250, 36 )
app.position = ( 200, 200 )
Поместим на форму метку hexLabel для вывода шестнадцатеричного
значения и компонент класса TIntEdit:
f = ( "Courier New", 14, "bold" )
hexLabel = TLabel( app, text = "?", font = f, fg = "navy" )
hexLabel.position = ( 155, 5 )

decEdit = TIntEdit( app, width = 12, font = f )

decEdit.position = ( 5, 5 )
decEdit.text = "1001"
Добавим обработчик события onChange для поля ввода:
def onNumChange( sender ) :
hexLabel.text = "{:X}". format( sender.value )

decEdit.onChange = onNumChange
Этот обработчик читает значение свойства value объекта, вызвавше­
го событие, и выводит его на метку hexLabel в шестнадцатеричной
системе (формат X). В строке формата можно написать и строчную
букву х, тогда в записи шестнадцатеричного числа будут выводиться
строчные буквы a-f вместо прописных A—F.

Выключатель с рисунком
Построим ещё один новый компонент — выключатель TSwitch,
который имеет два положения: «включено» и «выключено». Он дол­
жен менять своё состояние по щелчку мышью (рис. 1.21 и см. цвет­
ной рисунок на обороте обложки).
9 Выключатель FZ7]|- а .||«еД 9 Выключатель Г^~11 а |ЬвД
С\ выкл

Рис. 1.21
В библиотеке graph есть компонент TLabel (метка), который может
стать базовым классом для такого выключателя. Перечислим отличия
нового компонента-выключателя от стандартной метки:

70
 Создание компонентов §10

• содержит не текст, а рисунок;

• имеет состояние (включено или выключено);
• реагирует на щелчок мышью: изменяет состояние и изображение.
Нам нужно создать у компонента TSwitch два новых поля: в одном
будет храниться состояние выключателя, а во втором — массив из
двух изображений («выключено» и «включено»).
Начнём строить новый класс:
class TSwitch( TLabel ):
def _init__ ( self, parent, images, **kw ):
TLabel.__ init__ ( self, parent, **kw ) # (1)
self. state = False # (2)
self. images = images # (3)
self.config( image = self.__ images[0] ) # (4)
Класс TSwitch — это наследник класса TLabel. Его конструктор
принимает два обязательных параметра — ссылку на родительский
объект parent и массив, состоящий из двух изображений (images).
В первую очередь вызываем конструктор базового класса TLabel
(строка 1). Ему передаются все параметры, кроме изображений.
В строке 2 создаётся новое скрытое поле _ state (по-английски —
состояние), в которое записывается значение False. Это означает, что
выключатель сразу после создания выключен.
Затем массив изображений, переданный конструктору, записывается
в скрытое внутреннее поле _ images (строка 3). Далее мы будем счи­
тать, что _ images [0] — это изображение выключенного переключате­
ля (соответствующее состоянию False), а _ images [1] — изображение
включённого переключателя (состояние True).
К счастью, объекты класса TLabel умеют работать с изображения­
ми, и наша задача сводится к изменению изображения с помощью ме­
тода config. В строке 4 мы загружаем изображение с индексом 0 (со­
стояние «выключено»).
Добавим в класс общедоступное свойство (property) с именем
state — состояние выключателя:
class TSwitch(TLabel):
# здесь должен быть конструктор
def _ setstate(self, newState):
if newState != self.__ state:
self.__ state = newState
self.config( image = self.__ images[self.__ state])
state = property( lambda x: x. state, setstate )
Функции property передаются два аргумента: функция для чте­
ния свойства и процедура для его изменения. Функция чтения просто
возвращает значение скрытого поля _ state. Процедура записи ново­
го значения _ setstate проверяет, не совпадает ли новое состояние с

71
1 Программирование на языке Python

текущим, и если не совпадает, то изменяется как значение внутренне­

го поля, так и изображение. Новое изображение — это элемент мас­
сива _ images, его номер определяется полем _ state. Если переклю­
чатель выключен, загружается изображение с индексом 0, потому что
при преобразовании логического значения False в целое число полу­
чается 0. Аналогично при включении переключателя загружается изо­
бражение с индексом 1.

Перехват щелчка мышью

При каждом щелчке мышью по выключателю он должен изменять
своё состояние на обратное. Для этого достаточно вызвать уже готовый
метод _ setstate, передав ему новое состояние, обратное текущему:
self.__ setstate( not self.__ state )
Эту команду нужно применить тогда, когда пользователь щёлкнет
по выключателю, т. е. в обработчике события «щелчок мышью» базо­
вого класса:
class TSwitch( TLabel ):
def _ init__ ( self, parent, images, **kw ):

self.onClick = self.__ doClick # (1)

def _ doClick( self ): # (2)

self.__ setstate( not self.__ state ) # (3)
Процедура _ doClick (строки 2 и 3) — это скрытый метод класса
TSwitch. В строке 1 эта процедура сохраняется в свойстве onClick,
т. е. устанавливается в качестве обработчика события «щелчок мышью».
Теперь можно написать основную программу и проверить работу
компонента:
арр = TApplication( "Выключатель" )
арр.position = ( 200, 200 )
арр.size = ( 300, 300 )

switchimages = [ PhotoImage("off.gif") ,
PhotoImage("on.gif") ] # (1)
switch = TSwitch( app, switchimages ) # (2)
switch.position = ( 5, 5 ) # (3)
switch.state = True # (4)

app.run()
После создания главного окна приложения загружаем рисунки в
массив switchimages (строка 1). Файлы off.gif и on.gif в текущем

72
 Создание компонентов §10

каталоге должны содержать изображения выключенного и включённо­

го переключателей. В строке 2 создаётся объект-выключатель, в строке
3 он размещается на форме. Далее устанавливаем начальное состояние
«включено» (строка 4) и запускаем программу.

Новое свойство onChange

Компонент TSwitch, который мы построили, хорошо работает сам по
себе. В реальных программах при изменении состояния этого элемен­
та нужно выполнять некоторые действия, например включать и вы­
ключать какой-то режим, разрешать или запрещать обмен данными по
сети и т. п. Для того чтобы позволить программисту, использующему
компонент, установить свой обработчик этого события, добавим новое
свойство onChange (от англ, on change — «при изменении»):
onChange = property( lambda х: х.__onChange, __ setOnChange)
Это свойство связано с внутренним полем _ onChange - там будет
храниться ссылка на обработчик, который может установить програм­
мист. Этот обработчик нужно вызывать при изменении состояния пе­
реключателя. При чтении свойства будет возвращаться значение поля
__ onChange, а при записи — вызываться процедура _ setOnChange,
которая сохраняет ссылку на новый обработчик:
def _setOnChange( self, proc ):
self.__ onChange = proc
Обработчик будет вызываться при изменении состояния переключа­
теля, т. е. внутри метода _ setstate. Все необходимые изменения в
описании класса выделены фоном:
class TSwitch(TLabel):
def _ init__ ( self, parent, images, **kw ):

self.__ onChange = None # (1)

def _ setstate( self, newState ) :

if newState != self. state:

if self. onChange: # (2)

self. onChange() # (3)

def _setOnChange( self, proc ): # (4)

self.__ onChange = proc # (5)

onChange = property( lambda x: x.__ onChange,

__ setOnChange) # (6)

73
1 Программирование на языке Python

В конструкторе (в строке 1) создаётся новое поле для хранения

ссылки на обработчик, и в него записывается значение None — пока
обработчика нет. В строках 2 и 3 этот обработчик вызывается, если он
установлен (не равен None). Строки 4 и 5 — это процедура для изме­
нения обработчика, а строка 6 — описание свойства onChange.
Теперь остаётся в основной программе определить процедуру-обработ­
чик и связать её со свойством onChange объекта-выключателя:
def showSwitchState():
print( switch.state )

switch.onChange = showSwitchState
Наш тестовый обработчик выводит на экран информацию о каждом
изменении состояния выключателя.

Составной компонент
Построим ещё один новый компонент — TEditPanel, который объеди­
няет два компонента — метку TLabel и поле ввода TEdit. Окно для
входа пользователя в закрытую часть сайта или базы данных, исполь­
зующее два таких составных компонента, показано на рис. 1.22.

Вход в систему | <=> || и || |

Пользователь

Пароль

Войти।

Рис. 1.22

Метку и поле ввода удобно объединить на панели TPanel. Поэтому

новый компонент будет наследником класса TPanel, а метка и поле
ввода будут его внутренними полями:
class TEditPanel( TPanel ):
def _init_( self, parent, label, **kw ):
TPanel.__ init__ ( self, parent, **kw )
self.label = TLabel( self, text = label )
self.label.align = "top"
self.edit = TEdit( self )
self.edit.align = "top"
У конструктора класса TEditPanel два обязательных параметра —
ссылка на родительский объект и текст метки (параметр label).
Сначала вызывается конструктор базового класса TPanel, затем созда­

74
 Создание компонентов §10

ются метка и поле ввода, ссылки на них записываются во внутренние

поля label и edit. Эти поля нет смысла делать скрытыми, потому
что тогда затруднится доступ к данным элементам.
И для метки, и для поля ввода устанавливается режим выравнива­
ния top, т. е. элементы «прижимаются» к верхней границе панели.
Сначала размещается метка (она выравнивается первой), а потом —
поле ввода. Отметим, что при таком выравнивании ширина всех ком­
понентов будет изменяться автоматически при изменении ширины
окна.
Для удобства добавим к этому компоненту свойство text, которое
будет связано с одноимённым свойством поля ввода:
class TEditPanel(TPanel):

def _ getText( self ) :

return self.edit.text
def _ setText( self, newText ) :
self.edit.text = newText
text = property( __ getText, __ setText )
Таким образом, все запросы к свойству text наш компонент без из­
менений передаёт {делегирует) своему внутреннему элементу edit.
Программа, которая проверяет имя пользователя и пароль, может
выглядеть так:
def tryToEnter( sender ):
if userEdit.text == "sysdba" and \
passEdit.text == "masterkey":
print("Доступ разрешён!")
app.destroy()

app = TApplication("Вход в систему")

app.position = ( 200, 200 )
app.size = ( 200, 120 )

userEdit = TEditPanel( app, "Пользователь" )

userEdit.align = "top"

passEdit = TEditPanel( app, "Пароль" )

passEdit.align = "top"

btn = TButton(app, text=" Войти ")

btn.position = ( 70, 85 )
btn.onClick = tryToEnter
app.run ()

75
 Программирование на языке Python

В главное окно программы добавляются два новых компонента

TEditPanel и одна кнопка с надписью «Войти». Для кнопки уста­
новлен обработчик события onClick. При щелчке мышью по кнопке
вызывается процедура tryToEnter, которая проверяет данные пользо­
вателя. В случае удачной проверки выводится сообщение «Доступ раз­
решён!» и программа заканчивает работу.

Выводы
• Новые компоненты обычно строятся на основе существующих с
использованием наследования.
• Цель создания новых компонентов — добавить или изменить свой­
ства и методы существующих компонентов или связать несколько
компонентов в один составной компонент.
• Составные компоненты могут объединяться в новый компонент с
помощью панели TPanel.
• Составные компоненты могут передавать запросы своим частям,
такой приём называется делегированием.

Вопросы и задания
1. В каких случаях имеет смысл разрабатывать свои компоненты?
Сравните такой подход с использованием готовых компонентов.
2. Почему программисты почти никогда не создают свои компоненты
«с нуля»?
3. Объясните, как связаны рассмотренные в параграфе классы компо­
нентов TIntEdit и TEdit с точки зрения объектно-ориентированно­
го программирования. Чем они отличаются друг от друга?
4. Какие функции используются в языке Python для преобразования
числового значения в текстовое и обратно?
5. Как получить запись числа в шестнадцатеричной системе счисле­
ния?
6. Объясните, как работает свойство value у компонента TIntEdit в
программе из параграфа.
7. Почему мы не обрабатывали возможные ошибки в обработчике
onChange класса TIntEdit в программе из параграфа?
8. Как вы думаете, как можно установить обработчик события во вре­
мя выполнения программы?
9. Почему можно использовать в программе из параграфа обработчик
события onChange, который не был объявлен в классе TIntEdit?
10. Проект. Разработайте компонент, который позволяет вводить шест­
надцатеричные числа.
11. Проект. Разработайте компонент, который позволяет вводить веще­
ственные числа (они относятся к типу float).

76
 §11

12. Изучив программу проверки пароля из параграфа, определите имя

пользователя и пароль, при котором проверка проходит успешно.
Узнайте в дополнительных источниках, где используются эти дан­
ные.
13. Проект. Доработайте программу для проверки пароля пользовате­
ля так, чтобы после трёх неудачных попыток она завершала свою
работу с сообщением «Доступ запрещён!».

§11
Модель и представление
Ключевые слова'.
• модель • представление

Зачем это нужно?

Один из важнейших приёмов разработки современных программ —
повторное использование написанного ранее кода. Чтобы облегчить
решение этой задачи, было предложено использовать ещё одну де­
композицию: разделить модель, т. е. данные и алгоритмы их обра­
ботки, и представление — способ взаимодействия модели с пользо­
вателем.
Пусть, например, данные об изменении курсов валют хранятся в
виде массива. По этим данным требуется строить зависимости, позво­
ляющие прогнозировать изменение курсов в ближайшем будущем. Это
описание задачи на уровне модели.
Для пользователя эти данные могут быть представлены в различных
формах: в виде таблицы, графика, диаграммы и т. п. (рис. 1.23). Это
уровень представления, или интерфейса с пользователем.

Рис. 1.23

Чем хорошо такое разделение? Его главное преимущество состоит в

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

Вычисление арифметических выражений: модель

Построим программу, которая вычисляет арифметическое выражение,
записанное в символьной строке. Будем считать, что в выражении ис­
пользуются только:
• целые числа и
• знаки арифметических операций +-*/.
Для простоты предполагаем, что выражение не содержит ошибок и по­
сторонних символов.
Какова модель для этой задачи? По условию, данные хранятся в
виде символьной строки. Обработка данных состоит в том, что нужно
вычислить значение записанного в строке арифметического выражения.
При вычислении арифметического выражения последней выполня­
ется крайняя справа операция с наименьшим приоритетом. Используя
этот факт, можно сформулировать следующий алгоритм вычисления
арифметического выражения, записанного в символьной строке ехрг
(от англ, expression — выражение):
1) найти последнюю операцию с наименьшим приоритетом; предпо­
ложим, что индекс этого символа записан в переменной pos;
2) используя дважды этот же алгоритм, вычислить выражения слева
и справа от символа с индексом pos и записать результаты вы­
числения в переменные nl и п2 (рис. 1.24);
pos
I ,........... .
22 + 13 - : 3 * 8 \
nl п2
Рис. 1.24
3) выполнить операцию, символ которой записан в ехрг [pos], со
значениями переменных nl и п2.
Обратите внимание, что в пункте 2 этого алгоритма нужно решить
ту же самую задачу для левой и правой частей исходного выражения.
Как вы знаете, такой прием называется рекурсией.
Основную функцию назовём calc (от англ, calculate — вычислить).
Она принимает символьную строку и возвращает целое число — значе­
ние выражения, записанного в этой строке. Вот алгоритм её работы на
псевдокоде:
pos = позиция символа, соответствующего
последней выполняемой операции
if pos <0: # нет знака операции
перевести всю строку в число
else:
nl = результат вычисления левой части
п2 = результат вычисления правой части
применить найденную операцию к nl и п2

78
 Модель и представление §11

Последнюю выполняемую операцию будем искать с помощью функ­

ции lastOp, которую напишем немного позже. Если эта функция вер­
нула -1, это значит, что операция не найдена, т. е. вся переданная ей
строка — это число.
Теперь можно написать функцию calc на языке Python:
def calc ( expr ) :
pos = lastOp ( expr )
if pos < 0: # вся строка - число
return int( expr )
else:
nl = calc ( expr[:pos] ) # левая часть
n2 = calc ( expr[pos + 1:] ) # правая часть
# выполнить операцию
return doOperation( expr[pos], nl, n2 )
Обратите внимание, что функция calc — рекурсивная, она дважды
вызывает сама себя.
Функция doOperation выполняет допустимые операции:
def doOperation( op, nl, n2 ) :
if op == return nl + n2
elif op == : return nl - n2
elif op == return nl * n2
else: return nl // n2
Осталось написать функцию lastOp, которая должна найти в сим­
вольной строке последнюю операцию с минимальным приоритетом.
Сначала составим вспомогательную функцию, возвращающую приори­
тет символа-операции:
def priority( op ):
if op in return 1
if op in "*/": return 2
return 100
Сложение и вычитание имеют приоритет 1, умножение и деление —
более высокий приоритет 2, а все остальные символы (не операции) —
приоритет 100 (условное значение).
Функция lastOp может выглядеть так:
def lastOp ( expr ) :
minPrt =50 # любое число между 2 и 100
pos = -1
for i in range( len(expr) ):
prt = priority( expr[i] )
if prt <= minPrt:
minPrt = prt
pos = i
return pos

79
 Программирование на языке Python

В условном операторе используется нестрогое неравенство (<=), что­

бы найти именно последнюю операцию с наименьшим приоритетом.
Начальное значение переменной minPrt можно выбрать любым
между наибольшим приоритетом операций (2) и условным кодом ко­
операции (100). Если найдена любая операция, в переменной pos со­
храняется позиция найденного символа. Если же в строке нет опера­
ций, условие в условном операторе всегда ложно, и в переменной к
остаётся начальное значение —1, которое и вернёт функция lastOp.
Цикл, в котором перебираются все элементы символьной строки,
можно записать несколько иначе, «в стиле Python»:
for i, sym in enumerate(expr):
prt = priority ( sym )
if prt <= minPrt:
minPrt = prt
pos = i
Функция enumerate перебирает все пары «индекс — символ». При
каждом повторении цикла очередной индекс попадает в переменную i,
а соответствующий ему символ expr[i] — в переменную sym.
Функции calc, doOperation, priority и lastOp удобно объединить
в отдельный модуль model.py (модуль модели). Таким образом, модель
в этой задаче — это функции, с помощью которых вычисляется ариф­
метическое выражение, записанное в символьной строке.

Представление
Теперь построим интерфейс программы. В верхней части окна будет
размещён выпадающий список (компонент ТСошЬоВох), в котором поль­
зователь вводит выражение (рис. 1.25).

0 Калькулятор | " а || .» |
5*5-13/2

25*4+190/13=114
13+6/7-4=9
12+15-6*3=9

Рис. 1.25
При нажатии клавиши Enter выражение вычисляется, и его
результат выводится в верхней строке обычного списка — компонент
TListBox.
Выпадающий список, в котором хранятся все вводимые выражения,
полезен для того, чтобы можно было вернуться к ранее введённому
варианту и исправить его.
Итак, импортируем из модуля model функцию calc и создаём при­
ложение:
 Модель и представление §11
from model inport calc
app = TApplication( "Калькулятор" )
app.size = ( 200, 150 )
На форме разместим компонент TComboBox. Чтобы прижать его к
верху, установим свойство align, равное "top". Назовём этот компо-
нент1) inp (от англ, input — ввод).
inp = TComboBox( app, values = [], height = 1 )
inp.align = "top"
inp.text = "2+2"
При вызове конструктора, кроме родительского объекта мы указа­
ли два именованных аргумента: values (в переводе с английского —
значения) — пустой список, и height — высоту компонента, равную
одной текстовой строке.
Добавляем второй компонент — TListBox, устанавливаем для него
выравнивание "client" (заполнить всю свободную область) и имя
answers (в переводе с английского — ответы).
answers = TListBox ( app )
answers.align = "client"
Логика работы программы может быть записана в виде псевдокода:
if нажата клавиша Enter:
вычислить выражение
добавить результат вычислений в начало списка
if выражения нет в выпадающем списке:
добавить его в выпадающий список
Для перехвата нажатия клавиши Enter установим обработчик со­
бытия "<Key-Return>" (по-английски — клавиша перевода каретки).
Он подключается стандартным способом библиотеки tkinter — через
метод bind (по-английски — связать):
inp.bind ( "<Key-Return>", doCalc )
Обработчик doCalc должен принимать один параметр — структуру,
которая содержит информацию о произошедшем событии:
def doCalc ( event ):

Вместо многоточия мы должны записать команды, которые нужно

выполнить при нажатии клавиши Enter. Во-первых, читаем текст, вве­
дённый в выпадающем списке, и вычисляем выражение с помощью
функции calc:
expr = inp.text
х = calc( expr )
Конечно, лучше было назвать его input, но это имя уже занято — так назы­
вается встроенная функция ввода в Python.

81
1 Программирование на языке Python

Затем добавляем в начало списка вычисленное выражение и его

результат, разделив их знаком равенства:
answers.insert( 0, ехрг + "=" + str(х) )
Здесь используется метод insert (по-английски — вставить), его пер­
вый аргумент — это номер вставляемого элемента: если он равен О,
строка вставляется в начало списка.
Теперь проверим, есть ли такое выражение в выпадающем списке, и
если нет — добавим его:
if not inp.findltem( expr ):
inp.addltem( expr )
Метод finditem (англ, find item — найти элемент) возвращает
логическое значение True, если переданная ему строка есть в списке,
и False, если её там нет. Метод addltem (англ, add item — добавить
элемент) добавляет элемент в конец списка.
Таким образом, полная функция doCalc приобретает следующий
вид:
def doCalc( event ):
expr = inp.text
x = calc ( expr )
answers.insert( 0, expr + "=" + str(x) )
if not inp.finditem( expr ):
inp.addltem( expr )
Итак, в этой программе мы разделили модель (данные и средства их
обработки) и представление (взаимодействие модели с пользователем).
Построенный модуль модели можно использовать в любых программах,
где нужно вычислять арифметические выражения. При этом представ­
ление может быть совершенно различным, модель от него никак не
зависит.
Часто к паре «модель — представление» добавляют ещё управляю­
щий блок (контрбллер, от англ, controller — регулятор, управляющее
устройство), который, например, обрабатывает ошибки ввода данных.
Но часто контроллер и представление объединяются вместе — управле­
ние данными происходит в обработчиках событий.

Выводы
• В современных программах принято разделять модель (данные и
алгоритмы их обработки) и представление (способ ввода исходных
данных и вывода результатов).
• Одну и ту же модель можно использовать с разными представле­
ниями (в разных проектах).
• Разделение на модель и представление позволяет разрабатывать и
тестировать эти части отдельно друг от друга.

82
 Модель и представление §11

Вопросы и задания
1. Что даёт разделение программы на модель и представление? Как
это связано с особенностями современного программирования?
2. Что обычно относят к модели, а что — к представлению?
3. Что от чего зависит (и не зависит) в паре «модель — представле­
ние»?
4. Приведите свои примеры задач, в которых можно выделить мо­
дель и представление. Покажите, что для одной модели можно
придумать много разных представлений.
5. Пусть требуется изменить программу так, чтобы она обрабатыва­
ла выражения со скобками. Что нужно изменить: модель, интер­
фейс или и то, и другое?
6. Проект. Измените программу из параграфа так, чтобы модель
осталась та же, а представление было другое.
7. Проект. Измените программу из параграфа так, чтобы она
вычисляла значения выражений с вещественными числами (для
перевода вещественных чисел из символьного вида в числовой
используйте функцию float).
*8. Проект. Добавьте в программу из параграфа обработку ошибок.
Подумайте, какие ошибки может сделать пользователь. Какие
ошибки могут возникнуть при вычислениях? Как их обработать?
*9. Проект. Измените программу из параграфа так, чтобы она
вычисляла значения выражений со скобками. Подсказка: нужно
искать последнюю операцию с самым низким приоритетом, стоя­
щую вне скобок.
*10.Проект. Постройте программу «Калькулятор» для выполнения
вычислений с целыми числами:

**11.Проект. Напишите программу для игры «Змейка» (ru.wikipedia.

org/wiki/Snake_(Hrpa)). Выделите модель задачи и представление.

83
Глава 2
ПРОГРАММИРОВАНИЕ НА ЯЗЫКАХ C++ И C#

§12
Классы и объекты в C++
Ключевые слова’.
• класс • конструктор
• объект • инициализация
• экземпляр • метод
• модификатор доступа • рефакторинг

Новая задача и её анализ

Представьте себе, что в вашей игре нужно моделировать движение
машины по дороге. Для упрощения будем считать, что дорога состоит
из квадратных участков трёх типов: обочин, препятствий и свободных
клеток, где может проехать машина. Так можно построить не только
модель одной дороги, но и целую карту местности. Поэтому назовём
этот объект Картой.
Сама машина занимает один квадрат и при нажатии на клавиши-
стрелки может перемещаться по свободной части карты. Наша бли­
жайшая задача — построить классы Карта и Машина на языке С++
и научиться их использовать.
Так как мы решили составить карту из квадратов, объект клас­
са Карта должен где-то хранить информацию о том, что находится
в каждом квадрате. Удобнее всего использовать для этого матрицу,
размеры которой совпадают с размерами карты. Каждая ячейка этой
матрицы (рис. 2.1) будет хранить одно из трёх значений: «свободно»
(код 0), «обочина» (код 1) или «препятствие» (код 2).

Рис. 2.1
Карта должна уметь перерисовывать себя, поэтому нужно добавить в
этот класс метод show (в переводе с английского — показать).
 Классы и объекты в C++ §12

Класс Машина должен хранить во внутренних полях координаты

машины, х и у, — номера столбца и строки той клетки карты, где
сейчас находится машина.
Машина, как и карта, должна уметь перерисовывать себя, поэтому
в класс Машина тоже нужно добавить метод show. Кроме того, маши­
на должна перемещаться при нажатии на клавиши-стрелки, поэтому
нужен ещё метод move (по-английски — двигаться).
Машина должна как-то получать информацию о том, свободна ли
клетка, в которую она перемещается. Поэтому объекты класса Машина
должны хранить ссылку на карту, по которой машина едет. А в класс
Карта нужно включить ещё один метод — логическую функцию isFree,
которая определяет, свободна ли клетка с заданными координатами.
Таким образом, мы описали два класса, которые используются в
игре (рис. 2.2).
а) Карта Машина
width (ширина) х
height (высота) У
cells (клетки) тар (карта)
show (показать) show (показать)
isFree (свободно?) move (двигаться)

Рис. 2.2
Свойства карты width и height — это её ширина и высота, а
cells — матрица, в которой хранится информация о содержании кле­
ток карты.

Класс СМар
Названия всех классов будем начинать с прописной буквы «С» (от
англ, class — класс). Класс Карта назовём в программе СМар (от англ.
тар — карта).
Выделим место под матрицу с запасом, считая, что в нашей игре не
встретятся карты размером больше, чем 50 на 50 клеток (вы можете
использовать свои максимальные значения). Объявляем две целочис­
ленные константы — максимальные размеры карты, MAX WIDTH (мак­
симальная ширина), и MAX HEIGHT (максимальная высота):
const int MAX_WIDTH = 50,
MAX_HEIGHT = 50;
Простейший вариант класса Карта выглядит так:
class СМар
{
int width, height;
int cells[MAX_WIDTH][MAX_HEIGHT];
} ;

85
2 Программирование на языках C++ и C#

Обратите внимание, что после закрывающей скобки, которая завер­

шает объявление класса, должна стоять точка с запятой (она выделена
фоном).
В отличие от языка Python, в C++ все поля и методы класса нуж­
но заранее объявлять, добавить новое поле или метод во время работы
программы не получится. В классе СМар мы объявляем два целочис­
ленных поля width и height (размеры карты — ширину и высоту), а
также массив cells, в котором будет храниться информация о клет­
ках карты.
Теперь можно построить новый объект — экземпляр класса СМар:
СМар тар;
Однако попытка обратиться к полям этого объекта с помощью то­
чечной записи приведёт к ошибке — программа даже не пройдёт ком­
пиляцию:
map.width = 15; // это ошибка!
Дело в том, что по умолчанию все поля и методы объекта в C++
закрытые, или частные (англ, private). Наше описание класса равно­
сильно такому:
class СМар
{
private:
int width, height;
int cells[MAX_WIDTH][MAX_HEIGHT];
} ;
Служебное слово private, за которым стоит двоеточие, называется
модификатором доступа. Эта инструкция определяет правила доступа
к записанным далее полям и методам класса.
Инструкция private начинает секцию, где перечисляются закрытые
(частные) поля и методы класса. А данные, доступные другим объек­
там, должны быть объявлены в секции, которая начинается модифика­
тором public (в переводе с английского — общий, публичный):
class СМар
{
public:
int width, height;
int cells[MAX_WIDTH][MAX_HEIGHT];
};
Теперь можно создать объект и присвоить значения всем полям:
СМар тар; // (1)
тар.width = 20;
тар.height = 25;

86
 Классы и объекты в C++ §12

Объект создаётся в памяти в строке 1, при этом вызывается специ­

альный метод класса — конструктор. Если в описании класса кон­
структор явно не определён (как у нас), компилятор построит кон­
структор по умолчанию, который просто выделяет в памяти место для
объекта. Все поля будут содержать «мусор» — неопределённые значе­
ния, использовать которые бессмысленно и опасно.

Пишем свой конструктор

Чтобы случайно не использовать «мусорные» данные, желательно при
создании объекта сразу присваивать всем его полям начальные значе­
ния. Для этого определим свой конструктор:
class СМар
{
public:
int width, height;
int cells[MAX_WIDTH][MAX_HEIGHT];
CMap()
{
width =0;
height = 0;
}
};
Конструктор (он выделен фоном) — это специальный метод, кото­
рый создаёт объект в памяти и выполняет его инициализацию, т. е.
присваивает полям начальные значения. Имя конструктора всегда сов­
падает с именем класса. Он не возвращает никакого значения, даже
void.
Можно записать тот же конструктор в краткой форме:
class СМар
{
public:

СМар() : width(0), height (0) {}

};
В заголовке такого конструктора для каждого поля в скобках указано
его начальное значение, а тело конструктора — пустое.
В этом конструкторе мы не записали начальные значения в массив
cells — там пока находится «мусор». Когда размеры карты выбра­
ны, нужно выполнить её инициализацию — записать в крайние левый
и правый столбцы код 1 («обочина»), а в остальные — код 0 («сво­
бодно»). Это будет делать новый метод init (от англ, initialization —
инициализация), который мы добавим в класс:

87
2 Программирование на языках C++ и C#

class СМар
{
public:

void init(); // прототип метода

};

void CMap::init() // реализация метода

{
for( int x = 0; x < width; x++ )
for( int у = 0; у < height; y++ )
if( x == 0 or x == width-1 )
cells[x][y] = 1;
else cells[x][y] = 0;
}
В описании класса метод init только объявлен: мы записали его
прототип — заголовок метода с точкой с запятой в конце. А реали­
зация метода записана отдельно, после объявления класса. «Пристав­
ка» СМар: : в заголовке говорит о том, что это метод класса СМар, а
не обычная процедура. Другими словами, процедура init принадлежит
пространству имён11 класса СМар. Только поэтому внутри метода мож­
но обращаться к полям width, height и cells класса СМар.
В начале основной программы нужно создать объект, выбрать разме­
ры карты и выполнить её инициализацию:
СМар тар; // вызов конструктора
map.width = 20;
тар.height = 20;
тар.init();
Лучше всего объединить все эти действия: при создании объекта сразу
присваивать полям нужные значения и заполнять матрицу cells. Для
этого можно добавить в класс ещё один конструктор с двумя парамет­
рами:
class СМар
{
public:

СМар(): width(0), height(0) {}

СМар ( int widthO, int heightO );
};

СМар::СМар( int widthO, int heightO )

Таким же способом можно указывать и другие пространства имён. Например,

обращение к выходному потоку cout из пространства имён std можно записать
как std::cout.

88
 Классы и объекты в C++ §12

{
width = max( 0, min( widthO, MAX_WIDTH ) );
height = max( 0, min( heightO, MAX_HEIGHT ) );
init () ;
}
В описании класса мы оставили только объявление нового конструкто­
ра, а его реализация записана отдельно. Так обычно делают, если ме­
тод содержит более одной-двух строк. При этом описание класса стано­
вится короче и легче для понимания.
Теперь у класса СМар два конструктора. Их может быть и больше,
но все они должны различаться по количеству и типам параметров (по
сигнатуре, от англ, signature — подпись). Иначе компилятор не смо­
жет различить, когда какой конструктор вызывается.
Обратите внимание, что в конструкторе с параметрами выполняется
проверка правильности входных данных: мы не разрешаем устанавли­
вать ширину карты меньше нуля или больше, чем MAX_WIDTH, а высо­
ту — меньше нуля или больше, чем MAX_HEIGHT. После того как раз­
меры будут установлены, сразу вызывается метод init, и карта готова
к работе.
По команде
СМар mapl;
вызывается первый конструктор, поля объекта обнуляются. Второй
конструктор срабатывает, если после имени нового объекта в скобках
указать размеры карты:
СМар тар2( 20, 25 );
Заметим, что приведённые выше приёмы работают во всех версиях
C++, включая стандарт С++98. А в стандарте C++11 (и во всех бо­
лее новых) разрешено задавать начальные значения по умолчанию в
фигурных скобках после имени каждого поля:
class СМар
{
public:
int width{20}, height{25};
int cells[MAX_WIDTH][MAX_HEIGHT] {};
};
Пустые фигурные скобки в последней строке означают, что все ячейки
матрицы cells заполняются нулями.

Рефакторинг
Попробуем улучшить описание класса так, чтобы сделать его более
простым и понятным (выполним рефакторинг).

89
2 Программирование на языках C++ и C#

Во-первых, сделаем так, чтобы в массив cells нельзя было запи­

сывать другие значения, кроме 0, 1 и 2. Для этого введём новый тип
данных:
enum cellType { EMPTY, SIDE, WALL };
Такой тип данных называется перечисляемым, он объявляется с помо­
щью служебного слова enum (от англ, enumeration — перечисление).
Переменные типа cellType могут принимать только значения EMPTY
(в переводе с английского — пустой), SIDE (боковая сторона) и WALL
(стена). Фактически это целые числа, если вывести их на экран с
помощью оператора
cout « EMPTY « SIDE « WALL;
вы увидите, что EMPTY = О, SIDE = 1 и WALL = 2. Но в переменную
типа cellType компилятор не даст записать значение, не входящее в
перечисление:
cellType а = 25; // ошибка!
cellType Ь= 2; // ошибка!
cellType с = WALL; // так можно
Ограничивая множество допустимых значений, мы даём компилято­
ру возможность автоматически обнаруживать возможные ошибки. При­
меняя эту идею, выберем тип элементов cellType для матрицы cells
в классе СМар:
enum cellType { EMPTY, SIDE, WALL };
class CMap
{
public:

cellType cells [MAX_WIDTH] [MAX_HEIGHT] ;

};
В методе init нужно избавиться от «магических чисел» 1 и 0, за­
менив их на SIDE и EMPTY:
void СМар::init ()
{
for( int x = 0; x < width; x++ )
for( int у = 0; у < height; y++ )
if( x == 0 or x == width-1 )
cells[x][y] = SIDE;
else cells[x][y] = EMPTY;
}
Добавим в класс новый метод — логическую функцию isFree,
которая возвращает значение true, если свободна клетка с переданны­
ми ей координатами:

90
 Классы и объекты в C++ §12

class СМар
{
public:

bool isFree( int x, int у ) const {

return cells[x][y] == EMPTY;
}
};
Метод is Free скоро нам понадобится: перед тем, передвинуть маши­
ну, нужно проверить, свободна ли клетка, в которой она должна ока­
заться.
Так как функция isFree получилась короткой, мы разместили её
прямо в описании класса. Такой метод компилятор не оформляет как
отдельную функцию, а встраивает (англ, inline) прямо в машинный
код каждый раз, когда этот метод вызывается.
В заголовке метода появилось новое слово const. Оно говорит о
том, что это константный метод, т. е. метод, не изменяющий объ­
ект. Служебное слово const писать не обязательно, но оно помогает
понять, как устроен и как работает класс. Если внутри этого метода
случайно изменить данные объекта, компилятор сообщит об ошибке.
Сделаем ещё одно улучшение. Два конструктора класса СМар можно
объединить в один. Чтобы конструктор с параметрами можно было вы­
зывать без аргументов, для всех параметров нужно задать значения по
умолчанию:
class СМар
{
public:
int width, height;
cellType cells[MAX WIDTH][MAX_HEIGHT] ;
CMap( int widthO = 10 , int heightO = 15 );
void init();
};
Теперь, если при создании карты ширина и высота не заданы,
ширина будет равна 10, а высота — 15.
Новый конструктор можно вызвать тремя способами:
СМар mapl; // 10, 15

СМар тар2( 20 ); // 20, 15

СМар тарЗ( 20, 20 ); // 20, 20

В первом случае конструктор вызван без аргументов, поэтому применя­
ются оба значения по умолчанию: ширина 10 и высота 15. При вызове
с одним аргументом 20 мы задаём только ширину (первый параметр),

91
2 Программирование на языках C++ и C#

а второй параметр (высота) принимает значение по умолчанию — 15.

В последнем случае явно заданы оба размера карты.
Нужно помнить, что если какой-то параметр конструктора или дру­
гой функции имеет значение по умолчанию, то все следующие парамет­
ры тоже должны иметь значения по умолчанию. Например, такое объ­
явление конструктора неверно:
class СМар
{
public:
... // это ошибка!
СМар( int widthO = 10, int heightO );
};

Рисуем карту
Карта состоит из клеток, размер этих клеток на экране лучше задать
как константу, чтобы при необходимости его было легко изменить:
const int CELL_SIZE = 20;
Добавим в класс СМар метод show, который рисует карту:
class СМар
{
public:

void show () const;

};
Этот метод тоже не изменяет объект, поэтому объявлен с описателем
const.
Для рисования будем использовать библиотеку ТХ Library1), раз­
работанную И. Р. Дединским. Основная программа получается очень
короткой:
const int W=15,L=20; //(1)
СМар map( W, L ); // (2)
txCreateWindow( W*CELL_SIZE, L*CELL_SIZE ); // (3)
map.show(); // (4)
Размеры карты объявлены как константы W и L внутри основной
программы (строка 1). В строке 2 строится новый объект-карта с эти­
ми размерами. Окно для вывода графики создаётся в строке 3, а затем
мы рисуем карту на экране (строка 4).
Остаётся написать реализацию (код) метода show. Для вывода карты
надо перебрать все ячейки массива cells, для каждой клетки выбрать
цвет в зависимости от её содержимого и нарисовать на холсте квадрат
нужного цвета.11
11 Библиотеку ТХ Library можно загрузить с главной страницы сайта И. Р. Дедин-
ского ded32.ru или txlib.ru.

92
 Классы и объекты в C++ §12

void СМар::show() const

{
for( int x = 0; x < width; x++ )
for( int у = 0; у < height; y++ ) {
COLORREF color;
if( cells[x][y] == EMPTY ) // (1)
color = RGB (50, 255, 50);
else if( cells[x][y] == SIDE )
color = RGB(80, 0, 0) ;
else /* if( cells[x][y] == WALL ) */
color = RGB(0, 80, 0) ;
txSetColor ( color ); // (2)
txSetFillColor ( color ) ; // (3)
int left = x*CELL_SIZE, // (4)
top = y*CELL_SIZE;
txRectangle( left, top, // (5)
left+CELL_SIZE, top+CELL_SIZE ) ;
}
}
Цепочка условных операторов, которая начинается со строки 1, слу­
жит для выбора цвета. Для пустых ячеек мы используем светло-зе­
лёный цвет, для обочин — коричневый (тёмно-красный), для препят­
ствий — тёмно-зелёный. Цвета задаются в модели RGB как яркости
трёх составляющих (красной, зелёной и синей), каждая из которых
кодируется целым числом от 0 до 255.
В строках 2 и 3 устанавливается одинаковый цвет контура и залив­
ки. Координаты левого верхнего угла квадрата (в пикселях) вычисля­
ются в строке 4, а в следующей строке команда txRectangle рисует
этот квадрат.
Попробуем сразу выполнить рефакторинг. В методе show есть несколь­
ко строк (между строками 1 и 2), в которых выбирается цвет клетки.
Эти операции можно объединить в новый метод cellColor класса СМар:
class СМар
{
public:

COLORREF cellColor( int x, int у ) const;

};

COLORREF CMap::cellColor( int x, int у ) const

{
COLORREF color;
if( cells[x][y] == EMPTY )
color = RGB(50, 255, 50);

93
2 Программирование на языках C++ и C#

else if( cells[х][у] == SIDE )

color = RGB (80, 0, 0);
else /* if( cells[x][y] == WALL ) */
color = RGB (0, 80, 0);
return color;
}
Метод show сокращается и становится более понятным:
void СМар::show() const
{
for( int x = 0; x < width; x++ )
for( int у = 0; у < height; y++ ) {
COLORREF color = cellColor ( x, у );
txSetColor( color ) ;
txSetFillColor( color ) ;
int left = x*CELL_SIZE,
top = y*CELL_SIZE;
txRectangle( left, top,
left+CELL_SIZE, top+CELL_SIZE );
}
}
Если теперь собрать полную программу и запустить её, она должна
нарисовать карту и завершиться при нажатии на любую клавишу.

Выводы
• Описание класса в C++ начинается служебным словом class.
• Для ограничения доступа к полям и методам класса использу­
ют модификаторы доступа. Модификатор private обозначает за­
крытые (частные) данные и методы, обращаться к которым могут
только объекты данного класса. Модификатор public обозначает
общедоступные данные и методы.
• По умолчанию все поля и методы класса — закрытые.
• Класс может иметь несколько конструкторов. Все они должны раз­
личаться по сигнатуре, т. е. по количеству и типам параметров.
• Реализация метода класса может быть вынесена из объявления
класса. В этом случае в объявлении класса нужно записать объ­
явление (прототип) метода.
• Данные перечисляемого типа (enum) могут принимать одно из за­
данного множества значений. Эти значения кодируются целыми
числами.
Вопросы и задания
1. Как можно назвать этап решения задачи, который обсуждается в
первом пункте параграфа?
2. Найдите ошибку в объявлении класса.
class CMarusya { int strength; }

94
 Классы и объекты в C++ §12

3. Сравните работу с полями объектов в языках Python и C++. Какой

подход вам больше нравится?
4. Найдите ошибки в программе,
class CBobr { int weight; }
int main()
{
CBobr b(5);
b.height = 11;
}
5. Найдите ошибки в программе.
class CShip {
int x, у;
CShip () { x = у = 0; }
};
int main() { CShip ship; }
6. Найдите ошибку в программе (используйте описание класса СМар
из параграфа):
СМар тар;
cout << map->width;
7. Может ли класс иметь два таких конструктора?
class CBall {
int Re­
public :
CBall () { R = 10; }
CBall ( int _R = 0 ) { R = _R; }
};
Проверьте ваш ответ с помощью компьютера.
8. Что такое сигнатура метода?
9. В каких случаях два конструктора класса можно заменить одним?
10 .Объясните значение термина «инициализация». Почему лучше вы­
полнять инициализацию полей в конструкторе?
11. Почему метод init в классе СМар не объявлен с описателем const?
12. Как вы думаете, можно ли объявить конструктор с описателем
const? Обоснуйте ваш ответ, проверьте его экспериментально.
13. Запишите конструктор так, чтобы его тело было пустым.
class CPoint {
int х, у;
public:
CPoint ( int xO, int yO )
{ x = xO; у = yO; }
};
14. Зачем при рефакторинге стараются избавиться от «магических
чисел»?

95
2 Программирование на языках C++ и C#

15. Почему код (реализация) сложных методов класса обычно записы­

вается отдельно от объявления класса?
16. Найдите ошибку в объявлении класса.
class CBall {
int R, mass;
public:
CBall ( int _R = 0, int _M ) {
R = _R; mass = _M;
}
};
17. Что подозрительное вы заметили в объявлении класса?
class ССаг {
public:
СМар тар;
int х, у;
};

Интересные сайты
cpp.sh — онлайн-среда для программирования на С++
ded32.ru (txlib.ru) — сайт профессиональной проектной работы по
информатике для школьников, там же расположена библиотека
ТХ Library

§13
Программа с классами (практикум)
Ключевые слова:
• класс • конструктор
• объект • метод
• ссылка • рефакторинг
В этом параграфе мы построим класс Машина и закончим простую
программу, в которой машина двигается по карте. После этого вы смо­
жете совершенствовать её самостоятельно.

Класс ССаг
Данные класса Машина (ССаг) — это координаты машины, х и у.
Кроме того, машина должна быть связана с картой, иначе непонятно,
что означают эти координаты и как проверить, свободна ли клетка, в
которую перемещается машина. Чтобы организовать такую связь, нуж­
но хранить для каждого объекта-машины ссылку на карту, которую
машина использует. Таким образом, одно из полей в классе ССаг —
это ссылка на объект класса СМар:
СМар& тар;

96
 Программа с классами (практикум) §13

Ссылка (англ, reference) указывает на какой-то объект и позволяет

обращаться к его свойствам и методам. Такое отношение между клас­
сами называется «использование» (в отличие от наследования).
Ссылка во многом похожа на указатель — переменную особого типа,
которая хранит адрес объекта. Но, в отличие от указателя, ссылка не
может принимать «нулевое» значение, она всегда указывает на суще­
ствующий объект. Кроме того, после присваивания начального значе­
ния ссылку нельзя изменить. Это значит, что будет невозможно «пере­
ставить» машину на другую карту1*.
Вспомним (см. рис. 2.2), что у машины должно быть два метода —
show и move. Имя move недостаточно понятное: сложно догадаться,
куда и насколько двигается машина. Поэтому заменим его на moveBy
(в переводе с английского — передвинуться на) и будем передавать
этому методу изменения координат машины.
Введём класс ССаг следующим образом:
class ССаг
{
public:
СМар& тар; // (1)
int х, у; // (2)
ССаг ( СМар& тарО, int хО = 0, int уО = 0 ) : // (3)
тар( тарО ), х( хО ), у( уО )
{};
void show() const; // (4)
bool moveBy( int dx = 0, int dy = 0 ); // (5)
};
Строки 1 и 2 объявляют данные объекта: ссылку на карту тар и
целочисленные поля х и у — координаты машины на этой карте.
В строке 3 начинается описание конструктора. Он принимает три
параметра — ссылку на карту и начальные координаты. Первый пара­
метр конструктора обязательный, потому что машину обязательно надо
«привязать» к какой-то карте. Для остальных заданы нулевые значе­
ния по умолчанию. Конструктор присваивает всем полям начальные
значения, его тело пустое.
В строках 4 и 5 объявлены два метода — константный метод show
для вывода машины на экран и метод moveBy для перемещения ма­
шины. Метод moveBy принимает два параметра — смещения по каж­
дой из координат. Координату х нужно увеличить на величину dx, а
координату у — на величину dy. По умолчанию оба смещения равны
нулю.

х* Если необходимо связывать машину с разными картами, вместо ссылки нужно

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

97
2 Программирование на языках C++ и C#

В основной программе сначала построим объект-карту:

const int W = 15, L = 20;
CMap map( W, L );
Затем при создании объекта-машины передадим конструктору ссылку
на эту карту:
CCar car( тар, 10, 10 );
Будем изображать машину синим ромбом (конечно, вы можете ис­
пользовать и более сложный рисунок). Метод show можно записать так:
void CCar::show() const
{
txSetColor( RGB(0,0,255) );
txSetFillColor( RGB(0,0,255) );
int xCenter = x*CELL_SIZE + CELL_SIZE / 2,
yCenter = y*CELL_SIZE + CELL_SIZE / 2;
POINT carlmage[] = { {xCenter-5, yCenter},
{xCenter, yCenter-10},
{xCenter+5, yCenter},
{xCenter, yCenter+10} };
txPolygon( carlmage, 4 );
}
Переменные xCenter и yCenter обозначают координаты центра клет­
ки карты (в пикселях). Массив carlmage состоит из структур типа
POINT, которые описывают точки на плоскости. Этот массив задаёт ко­
ординаты четырёх углов ромба. Рисование ромба выполняет функция
txPolygon, которая принимает два аргумента: массив координат точек
многоугольника и количество этих точек.
Теперь напишем код метода moveBy. Прежде чем передвинуть маши­
ну в новую позицию, с помощью метода is Free привязанной карты
узнаем, свободно ли это место:
bool CCar::moveBy( int dx, int dy )
{
if( map.isFree( x+dx, y+dy ) ) { // (1)
x += dx;
у += dy;
return true;
}
else
return false;
}
Заметьте, что при определении метода в заголовке не нужно указывать
значения параметров dx и dy по умолчанию, они задаются только в
прототипе метода в описании класса.

98
 Программа с классами (практикум) §13

Поскольку поле тар — это ссылка на объект-карту (а не указатель),

для вызова метода is Free применяется обычная точечная запись.
Как видно из условия в строке 1, машина перемещается только тог­
да, когда клетка карты с новыми координатами свободна. В этом слу­
чае метод возвращает логическое значение true («истина») — машина
перемещена успешно. Если переместить машину не удаётся, метод воз­
вращает результат false («ложь»).

Снова рефакторинг
Итак, классы вроде бы готовы. Но давайте всё-таки попробуем ещё
кое-что улучшить.
Во-первых, функцию выбора цвета клетки карты можно «изъять»
из класса СМар и выделить в отдельную подпрограмму. Она определяет
цвет клетки не по координатам, а по коду объекта, находящегося в
этой клетке:
COLORREF cellColor( cellType type )
{
COLORREF color;
if ( type == EMPTY )
color = RGB(50, 255, 50);
else if( type == SIDE )
color = RGB(80, 0, 0);
else // if( type == WALL )
color = RGB(0, 80, 0);
return color;
}
Операцию рисования клетки карты оформим как отдельную про­
цедуру, не входящую ни в какой класс. Она принимает три парамет­
ра — координаты клетки и код объекта:
void drawCell( int х, int у, cellType type )
{
COLORREF color = cellColor( type );
txSetColor ( color );
txSetFillColor ( color );
int left = x*CELL_SIZE,
top = y*CELL_SIZE;
txRectangle( left, top,
left+CELL_SIZE, top+CELL_SIZE );
}
В первой строке для определения цвета клетки вызывается функция
cellColor, которую мы только что написали.

99
2 Программирование на языках C++ и C#

Также выделим в отдельную процедуру рисование машины:

void drawCar( int х, int у )
{
txSetColor ( RGB (0, 0,255) );
txSetFillColor( RGB(0,0,255) );
int xCenter = x*CELL_SIZE + CELL_SIZE / 2,
yCenter = y*CELL_SIZE + CELL_SIZE / 2;
POINT carlmage[] = { {xCenter-5, yCenter},
{xCenter, yCenter-10},
{xCenter+5, yCenter},
{xCenter, yCenter+10} };
txPolygon( carlmage, 4 );
}
Теперь методы рисования объектов становятся совсем простыми и
понятными:
void CMap::show() const
{
for( int x = 0; x < width; x++ )
for( int у = 0; у < height; y++ )
drawCell ( x, у, cells[x] [у] );
}
void CCar::show() const
{
drawCar( x, у );
}
В результате мы разделили модель и представление (см. § 11). Клас­
сы СМар и ССаг представляют собой модель — данные и алгоритмы их
обработки. Эти классы «ничего не знают» о том, как карта и машина
будут изображены на экране. Меняя процедуры drawCell и drawCar,
мы можем изображать данные как угодно (например, в виде шести­
угольных сот), при этом не придётся менять модель.

Основная программа
В основной программе нужно создать объекты (карту и машину) и
окно для вывода графики:
const int W = 15, L = 20;
CMap map ( W, L ) ;
CCar car( map, 10, 10 );
txCreateWindow( W*CELL_SIZE, L*CELL_SIZE );
Для анимации будем использовать цикл, работающий до нажатия
клавиши Escape:

100
 Программа с классами (практикум) §13

while( not GetAsyncKeyState(VK_ESCAPE) ) { // (1)

txClear (); // (2)
if ( GetAsyncKeyState(VK_LEFT) ) // (3)
car.moveBy( -1 );
if ( GetAsyncKeyState(VK_RIGHT) ) // (4)
car.moveBy( 1 );
map.show(); // (5)
car.show(); // (6)
txSleep( 50 ); // (7)
}
В условии цикла в строке 1 вызывается функция GetAsyncKeyState.
Она возвращает истинное значение, если в момент её вызова нажата
клавиша Escape, код которой равен VK ESCAPE. При этом обратное ус­
ловие станет ложно, и цикл завершится.
В строке 2 очищается графическое окно, а в строках 3 и 4 мы про­
веряем, не нужно ли двигать машину. Если нажата клавиша «влево»
(она имеет код VK_LEFT), вызывается метод moveBy. Первый аргумент
при вызове этого метода равен -1, а второй не задан, т. е. считается
равным нулю (см. прототип метода в классе). Поэтому машина переме­
щается влево на одну клетку. Аналогично при нажатии кнопки «впра­
во» (с кодом VK RIGHT) машина переместится на одну клетку вправо.
В строках 5 и 6 рисуем сначала карту, а потом — машину. Стро­
ка 7 обеспечивает задержку выполнения программы на 50 миллисе­
кунд.
Движение машины вверх и вниз при желании вы можете сделать
самостоятельно. В некоторых играх машина не двигается по вертика­
ли, вместо этого карта прокручивается сверху вниз.

Разбиение на модули
Программа получилась достаточно большой, поэтому возникает естест­
венное желание разбить её на части, сохранив каждую часть в от­
дельном файле. Например, в отдельный модуль, который мы назовём
cargame. срр, можно выделить определение обоих классов1’, СМар и
ССаг.
Сразу возникает вопрос: как собрать исполняемую программу из
нескольких исходных файлов? Для этого нужно создать проект, объе­
диняющий несколько файлов. Это умеют все современные среды разра­
ботки программ. Кроме того, для сборки проекта из командной строки
можно использовать утилиту make.
В C++ используется раздельная компиляция, т. е. все файлы про­
екта проходят компиляцию независимо друг от друга. Для каждого из
’’ Другой вариант — выделить каждый класс в отдельный файл. При желании вы
сможете это сделать самостоятельно, поняв общий принцип.

101
2 Программирование на языках C++ и C#

них компилятор строит отдельный объектный файл (обычно он имеет

расширение .о или .obj). На следующем этапе эти объектные файлы
обрабатывает другая программа — редактор связей (англ, linker), зада­
ча которого — собрать из файлов один исполняемый файл, подключив
все используемые библиотеки.
Из-за раздельной компиляции возникает ещё одна проблема: обра­
батывая файл с основной программой, компилятор не будет знать, что
где-то есть файл cargame. срр с определениями классов СМар и ССаг.
Как же сказать ему, что такие классы есть?
Давайте вспомним, как используются функции стандартной библи­
отеки в языке C++. Чтобы компилятор знал про эти функции, мы
включаем в начало файла специальные заголовочные файлы, содержа­
щие объявления (прототипы) функций: iostream, random, cmath и др.
Следовательно, нужно написать свой заголовочный файл, в котором бу­
дут описания наших классов. Назовём его cargame. hpp (заголовочным
файлам на языке C++ обычно дают расширения . h или .hpp) и под­
ключим его в основной программе:
#include "cargame.hpp"
Двойные кавычки вместо угловых скобок говорят о том, что нужно
сначала искать файл в текущем каталоге проекта, а не в системных
каталогах, где хранятся заголовочные файлы стандартной библиотеки.
Заголовочный файл cargame.hpp содержит только константы и но­
вые типы данных (в том числе описания классов):
enum cellType {EMPTY, SIDE, WALL};
const int MAX_WIDTH = 50,
MAX_HEIGHT = 50;

class CMap
{
public:
int width, height;
cellType cells[MAX_WIDTH][MAX_HEIGHT];
CMap( int widthO = 10, int height0 = 15 );
void init();
void show() const;
bool isFree( int x, int у ) const {
return cells[x][y] == EMPTY;
}
};
class CCar
{
public:
CMap& map;

102
 Программа с классами (практикум) §13

int х, у;
ССаг ( СМар& _map, int хО = 0, int уО = 0 ):
тар(_тар), х(хО), у(уО)
{};
void show() const;
bool moveBy( int dx = 0, int dy = 0 );
};
Реализацию всех методов классов поместим в файл cargame. срр:
#include <algorithm>
#include "cargame.hpp"
using namespace std;
void drawee11( int x, int у, cellType type );
void drawCar( int x, int у );
... // далее — реализация всех методов классов
В начале файла подключается библиотека algorithm. В ней объяв­
лены функции min и max, которые используются в конструкторе клас­
са СМар. Затем подключаем заголовочный файл cargame.hpp и записы­
ваем прототипы процедур рисования.
Таким образом, мы построили модуль, содержащий классы СМар и
ССаг. Он состоит из двух частей — заголовочного файла с расширени­
ем . h или .hpp (интерфейса) и файла с расширением .срр, в котором
реализованы методы классов.
А что же осталось в файле с основной программой? Только то, что
относится к представлению, т. е. к картинке на экране:
#include "TxLib.h"
#include "cargame.hpp"
const int CELL_SIZE = 20;
COLORREF cellColor( cellType type )
{

}
void drawCe11( int x, int у, cellType type )
{

}
void drawCar( int x, int у )
{

}
int main()
{
const int W = 15, L = 20;
CMap map( W, L ) ;

103
2 Программирование на языках C++ и C#

CCar car( тар, 10, 10 );

txCreateWindow( W*CELL_SIZE, L*CELL_SIZE );
while( not GetAsyncKeyState(VK_ESCAPE) ) {

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

Выводы
• Связь с объектом можно установить с помощью специального поля
типа «ссылка». В отличие от указателя, ссылка всегда указывает
на существующий объект и не может быть изменена.
• Для обращения к полям и методам объекта по ссылке использует­
ся точечная запись.
• Разделение программы на модель данных и представление позво­
ляет легко изменять одну из этих частей, не затрагивая вторую.
Кроме того, модель можно использовать в других программах.
• Классы, которые создаёт программист, обычно оформляются в
виде модулей. Модуль может содержать один класс или несколько
связанных по смыслу классов.
• Модуль состоит из двух частей — заголовочного файла с расши­
рением . h или . hpp (интерфейса) и файла с расширением . срр, в
котором реализованы методы классов.

Вопросы и задания
1. Что произойдёт, если поменять местами строки 5 и 6 в основной
программе, приведённой на с. 101?
2. Почему при вызове метода moveBy в основной программе из парагра­
фа задаётся только один аргумент, хотя метод имеет два параметра?
3. Что произойдёт, если вызвать метод moveBy без параметров (см. про­
грамму из параграфа): car. moveBy ();?
4. Предположите, что произойдёт, если во время работы программы из
параграфа одновременно нажать стрелки «влево» и вправо». Что из­
менится, если два условных оператора в цикле основной программы
связать словом else?
5. Подумайте, в каком случае вызов метода isFree в программе из
параграфа может привести к ошибке? Как можно защититься от
этой ошибки?

104
 Инкапсуляция §14

6. Ваш коллега предлагает при разбиении на модули программы из

параграфа объединить файлы cargame, hpp и cargame, срр в один
файл и включить в программу этот объединённый файл с помо­
щью команды #include. Оцените достоинства и недостатки тако­
го решения.
7. Двигая машину (см. программу из параграфа) с помощью стрелок
во время игры, вы можете заметить мигание графического окна.
Чтобы убрать мигание, попробуйте использовать функции txBegin
и txEnd из библиотеки ТХ Library. Описание этих функций най­
дите в справочной системе.
8. Переделайте программу из параграфа, выделив каждый класс в
отдельный модуль.
9. Переделайте программу из параграфа так, чтобы снять ограниче­
ние на максимальные размеры поля. Указание: вместо статичес­
кого массива cells используйте вектор, составленный из векто­
ров:
vector< vector<cellType> > cells;
*10. Проект. Доделайте игру, которая была начата в этом параграфе.
Изображение карты должно «ехать» сверху вниз, на карте будут
появляться препятствия, которые машина должна объезжать. Чем
дольше продержится машина на трассе, тем больше очков полу­
чает игрок.
*11.Проект. Доработайте игру из предыдущего задания так, чтобы
клавиши-стрелки «вверх» и «вниз» изменяли скорость движения
машины. Начисляйте очки за скорость прохождения трассы за­
данной длины.
**12. Проект. Придумайте свою простую игру и напишите объектно-
ориентированную программу, используя пример из параграфа.

Интересные сайты
ideone.com — онлайн-среда для программирования на различных
языках
repl.it — онлайн-среда для программирования на различных языках

§14
Инкапсуляция
Ключевые слова:
• инкапсуляция • модификаторы доступа
• поле • интерфейс
• метод • свойство

105
2 Программирование на языках C++ и C#

Объект защищает свои данные

В программе, которую мы написали выше, все поля и методы клас­
сов были открытыми — мы объявляли их в секции public. Соглас­
но принципу инкапсуляции, всё внутреннее устройство объектов долж­
ны быть «невидимо» для остальных объектов, «заключено в капсулу».
Объект тем и отличается от структуры, что сам работает со своими
данными, никого к ним «не подпуская».
Для того чтобы разобраться с инкапсуляцией в C++, мы построим
класс СРеп — объект-перо. Для простоты пусть он содержит единствен­
ное поле FColor, которое хранит информацию о цвете в виде символь­
ной строки (см. § 4). Запишем объявление класса:
class СРеп
{
private:
string FColor;
};
Те элементы (поля и методы), которые нужно скрыть, в описании
класса помещают в «частную» секцию, которая начинается с модифи­
катора доступа private. Таким образом, теперь поле FColor закрытое.
Имена всех закрытых полей далее будем начинать с буквы F (от англ.
field — поле).
К закрытым полям нельзя обратиться извне (это могут делать толь­
ко методы класса СРеп), поэтому сейчас невозможно не только изме­
нить внутреннее поле объекта, но и просто узнать его значение.
Чтобы всё же получить доступ к полю FColor, добавим к классу
ещё два метода. Один из них, getColor (на жаргоне программистов —
«геттер», от англ, get — получать), будет возвращать текущее значе­
ние поля FColor. Второй метод, setColor («сеттер», от англ, set —
устанавливать), присваивает полю новое значение.
class СРеп {
private:
string FColor;
public:
string getColor() const;
void setColor ( string newColor );
};
Оба метода находятся в секции public (общедоступные), позволяя дру­
гим объектам работать с полем FColor.
Конечно, проще всего было сделать поле FColor общедоступным. Но
при этом:
• другие объекты (и функции, не относящиеся к объектам) смогут
самостоятельно изменять значение этого поля; отследить такие из­
менения может быть очень сложно;

106
 Инкапсуляция §14

• другие объекты в своей работе смогут использовать знание о внут­

реннем устройстве класса СРеп, а этого лучше не допускать, пото­
му что при изменении класса СРеп придётся искать в программе
все связи, которые могут быть нарушены.
Если мы сделаем поле закрытым, то другие объекты «увидят» это
поле только через интерфейс — методы getColor и setColor. Поэто­
му мы можем сколько угодно менять внутреннее устройство и алгорит­
мы работы объектов класса СРеп, не меняя интерфейса, и другие объ­
екты об этом даже не «догадаются».
В простейшем случае метод getColor просто возвращает значение
поля:
string СРеп::getColor() const
{ return FColor; }
В методе setColor мы можем обрабатывать ошибки, не разрешая
присваивать полю недопустимые значения. Например, потребуем, что­
бы символьная строка с кодом цвета состояла ровно из шести сим­
волов. Если это условие не выполняется, будем записывать в поле
FColor код чёрного цвета «000000»:
void СРеп::setColor( string newColor )
{
if( newColor.size() != 6 )
FColor = "000000"; // чёрный цвет
else FColor = newColor;
}
Теперь для установки и чтения цвета пера нужно использовать
методы класса СРеп:
СРеп реп;
реп.setColor( "FFFF00" );
cout << "цвет пера: " << реп.getColor();
Итак, мы скрыли внутренние данные, но одновременно обращение
к свойствам стало выглядеть некрасиво: вместо реп. color="FFFF00"
теперь приходится писать так:
pen.setColor("FFFF00");

Изменение внутреннего устройства

Поскольку доступ к данным класса СРеп возможен только через
методы, внутреннее устройство может быть любым, и его можно ме­
нять как угодно. Для сохранения прежних связей с другими объекта­
ми нам нельзя изменять интерфейс. Это значит, что возвращаемое зна­
чение функции getColor и единственный параметр метода setColor
должны быть символьными строками заданного формата. Всё осталь­
ное не влияет на работу других объектов.

107
2 Программирование на языках C++ и C#

Допустим, мы решили хранить цвет как целое число (такой способ

чаще всего и используется на практике). Изменим тип поля FColor на
целочисленный (int):
class CPen
{
private:
int FColor;

};
При этом необходимо поменять также методы getColor и setcolor,
которые непосредственно работают с этим полем. Обратите внима­
ние, что заголовки методов (т. е. интерфейс, способ общения объекта с
«внешним миром») остались прежними, и другие объекты «не заметят»,
что во внутреннее устройство класса СРеп внесены какие-то изменения.
Итак, метод getColor должен вернуть символьную строку, в кото­
рой записан шестнадцатеричный код цвета, хранящегося в поле FColor
как целое число. Преобразовывать число в символьную строку будем
с помощью строкового потока (stringstream). В него можно записать
число, как в обычный поток вывода, при этом число превратится в
последовательность символов, т. е. в строку.
Записать в поток число в шестнадцатеричной системе счисления
можно так:
#include <sstream> // (1)

stringstream s; // (2)
s « hex << FColor; // (3)
Для работы co строковыми потоками подключаем библиотеку
sstream (строка 1). Формат hex обозначает «вывести число в шестнад­
цатеричной системе счисления». Однако это немного не то, что нужно.
Например, цвет FF16 будет выведен как "FF" вместо "0000FF". Необхо­
димо как-то указать, что требуется вывести число в 6 позициях, и все
пустые позиции слева заполнить нулями. Это делается с помощью ма­
нипуляторов вывода из библиотеки iomanip, которую тоже надо под­
ключить в начале программы:
#include <iomanip>

s << setfill ('0') << setw(6) << hex << FColor;

Здесь используются два манипулятора вывода: setw(6) устанавливает
ширину поля 6 символов, a setfill('O') задаёт заполнение пустых
позиций символом 0.
В итоге метод getColor приобретает такой вид:

108
 Инкапсуляция §14

string CPen::getColor() const

{
stringstream s;
s << setfill ('O') << setw(6) « hex << FColor;
return s.str();
}
Оператор return возвращает символьную строку, записанную в
поток s, вызывая его метод str.
Обратный переход — от символьной записи к числовому коду —
также может быть выполнен с помощью строкового потока. Записыва­
ем в поток символьную строку, а затем читаем число:
void CPen::setColor ( string newColor )
{
stringstream s;
if( newColor.size()!= 6 )
FColor =0; // если ошибка, то чёрный цвет
else {
s << newColor;
s » hex >> FColor;
}
}
Если длина входной строки равна 6, мы записываем её в строковый
поток, а затем читаем из этого потока число, записанное в шестнадца­
теричной системе счисления.
Можно обойтись и без потока, вызвав функцию strtol (от англ.
string to long — из строки в длинное целое) из библиотеки cstdlib:
void CPen::setColor( string newColor )
{
if( newColor.size()!= 6 )
FColor =0; // если ошибка, то чёрный цвет
else
FColor = strtol( newColor.c_str(), nullptr, 16 );
}
Первый аргумент функции strtol — это символьная строка в фор­
мате языка С (с кодом 0 на конце), мы получаем её из строки класса
string с помощью метода c_str. Второй аргумент — это адрес указа­
теля, который в результате работы функции strtol будет установлен
на первый символ после числа. Мы его не используем, поэтому пере­
даём функции нулевой указатель nullptr. Последний аргумент (16) —
основание системы счисления.
Итак, внутреннее устройство объектов класса CPen изменилось —
информация о цвете хранится теперь как целое число, а не как сим­
вольная строка. Однако интерфейс класса — способы вызова методов
getColor и setColor — остался прежним. Поэтому никакой передел­
ки объектов, взаимодействующих с классом CPen, не требуется.

109
2 Программирование на языках C++ и C#

Фактически пара методов getColor и setcolor определяют свой­

ство (вспомните свойства объектов в языке Python, § 4). Однако тако­
го понятия в стандарте языка C++ нет.

Свойство «только для чтения»

Иногда нужно позволить другим объектам читать какие-то данные, но
запретить изменять их. Другими словами, требуется добавить свойство
«только для чтения» (англ, read-only). В этом случае просто не нужно
создавать метод для записи значения скрытого поля:
class ССаг {
private:
double Fv;
public:
ССаг( double vO ): Fv(vO) {}
double getV() const { return Fv; }
};
Поскольку поле Fv объявлено в секции private, оно недоступно
остальным объектам. Значение этого поля можно прочитать с помо­
щью общедоступного метода getv, но изменить это поле другие объ­
екты не могут.
Короткий код метода getv записан прямо в объявлении класса, т. е.
это встроенный (англ, inline) метод. Компилятор подставляет в точку
вызова всё тело метода, а не оформляет отдельную подпрограмму в ма­
шинных кодах.

Свойства в C#
Мы уже говорили о том, что фактически класс СРеп определяет свойство
«цвет», для работы с которым используются метод чтения («геттер»)
getColor и метод записи («сеттер») setcolor. Однако понятия «свой­
ство» нет в языке C++, и эти два метода формально никак не связаны!
Во многих современных языках программирования введено понятие
свойства. Один из таких языков — язык С#, основанный на идеях С
и C++. В C# можно ввести свойство color так (сначала рассмотрим
простейший случай):
class СРеп
{
private string FColor; // закрытое поле
public string color // открытое свойство
{
get { return FColor; } // метод чтения
set { FColor = value; } // метод записи
}
}

110
 Инкапсуляция §14

Всё очень похоже на описание класса в C++. У объектов тако­

го класса есть закрытое (private) поле FColor и открытое (public)
свойство color. Для работы с этим свойством используются два мето­
да: «геттер» и «сеттер». Метод, записанный в фигурных скобках по­
сле слова get, возвращает текущее значение свойства, а метод, запи­
санный после слова set, устанавливает его новое значение. Параметр,
который передаётся процедуре-«сеттеру», всегда называется value (это
служебное слово языка С#).
Обращение к свойству в C# выполняется так же, как к обычному
открытому полю объекта:
string s = pen.color;
pen.color = "FFFFFF";
В методе set можно обеспечить защиту от записи неправильного
значения:
public string color
{
get { return FColor; }
set {
if ( value.Length != 6 ) // если ошибка, то
FColor = "000000"; // чёрный цвет
else FColor = value;
}
}
Мы можем легко изменить внутреннее устройство объекта, сохра­
нив интерфейс. В следующем примере свойство color имеет строковый
тип, а данные хранятся как целое число:
class СРеп
{
private int FColor; // закрытое поле
public string color // открытое свойство
{
get { return FColor.ToString( "X6" ); }
set { FColor = Convert.Tolnt32(value, 16); }
}
}
Здесь для преобразования целого числа в символьную строку исполь­
зуется метод ToString из библиотеки С#. Значение аргумента "Х6"
обозначает, что нужно записать число в шестнадцатеричной системе
(«X», от англ, hexadecimal — шестнадцатеричный) в шести позициях.
Обратный перевод выполняет метод Tolnt32 класса Convert. Его
второй аргумент (16) — это основание системы счисления, в которой
будет записано число.

111
2 Программирование на языках C++ и C#

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

Вопросы и задания
1. Каковы достоинства и недостатки инкапсуляции?
2. Чем различаются секции public и private в описании классов?
Как определить, в какую из них поместить какое-либо свойство
или метод?
3. Почему рекомендуют делать доступ к полям объекта только с по­
мощью методов?
4. Как вы думаете, когда можно сделать поле открытым (объявить в
секции public)? Обсудите этот вопрос с коллегами.
5. Зачем нужны свойства «только для чтения»?
6. Как ввести в класс свойство «только для записи» (которое нельзя
прочитать)?
7. Что такое интерфейс объекта? Почему при коллективной разра­
ботке программы желательно не изменять заранее согласованные
интерфейсы?
8. Что означает «сохранить интерфейс класса» для класса СРеп, раз­
работанного в параграфе?
9. Измените внутреннее устройство объектов класса СРеп из пара­
графа так, чтобы три составляющие RGB-кода цвета хранились в
виде массива из трёх элементов.
*10. Проект. Измените программу моделирования движения машины
(см. предыдущий параграф) так, чтобы все поля у объектов были
закрытыми.

Интересные сайты
cppstudio.com — программирование для начинающих на C++
ru.cppreference.com — онлайн-справочник по C++
leamcs.org — интерактивный учебник по C#
dotnetfiddle.net — онлайн-компилятор C#

112
 Наследование §15

§15
Наследование
Ключевые слова:
• класс • абстрактный класс
• иерархия классов • виртуальный метод
• базовый класс • защищённые поля
• наследование • утечка памяти

Моделирование жизни в океане

В этом параграфе мы начнём разрабатывать новую игру, которая моде­
лирует жизнь в океане. На игровом поле «живут» разнообразные объ­
екты:
• Камни (препятствия) — не двигаются;
• Трава (планктон) — пища для рыб;
• Рыбы, поедающие траву; они не обращают внимания на камни;
• Хищники — хищные рыбы, поедающие обычных Рыб; они не
обращают внимания на камни и траву.
Океан живёт своей жизнью. При этом происходят следующие изме­
нения1’:
• Трава растёт (через заданное время её размеры увеличиваются);
• Рыбы двигаются в выбранном направлении (или случайно меняют
направление движения);
• если Рыба проходит через Траву, то размер Травы уменьшается,
а Рыба становится сытой;
• если Рыба долгое время не ест, она умирает от голода;
• если Хищник сталкивается с Рыбой, он ест Рыбу; при этом Рыба
погибает, а Хищник становится сытым;
• если Хищник долгое время не ест, он умирает от голода.
Наша первая (и самая важная) задача — построить систему классов
для этой игры.

Иерархия классов
Все объекты, о которых мы говорили, обладают общими свойствами.
Эти свойства можно объединить в базовом классе, который мы назовём
COceanObject (в переводе с английского — класс «океанский объект»).
Конечно, создавать такой объект бессмысленно, потому что это просто
набор свойств и методов (т. е. абстракция). Объектов типа Океанский
объект в природе (и в нашей игре) не существует. Поэтому, говоря
на языке программистов, класс COceanObject будет абстрактным, он
Для научного исследования биологических систем используют модели «хищ­
ник — жертва». Самая известная из них — модель Лотки-Вольтерры. Этот
материал выходит за рамки пособия, но вы можете самостоятельно найти
информацию о таких моделях в сети Интернет.

113
2 Программирование на языках C++ и C#

предназначен только для создания классов-наследников, но не конкрет­

ных объектов (вспомните материал § 5).
У подвижных объектов должны быть дополнительные свойства и
методы. Объединим их в классе CMovingObject (в переводе с англий­
ского — движущийся объект). Конечно, этот класс будет наследником
класса COceanObject. Кроме того, такие «подвижные объекты вообще»
тоже не существуют, поэтому класс CMovingObject тоже абстрактный.
Очевидно, что наследниками класса CMovingObject будут классы
CFish (Рыба) и CHunter (Хищник). А классы CStone (Камень) и CGrass
(Трава) — это прямые наследники базового класса COceanObject.
Таким образом, мы построили иерархию классов в игре (рис. 2.3).

Рис. 2.3

Базовый класс
Введём новый перечисляемый тип данных:
enum objectType { STONE, GRASS, FISH, HUNTER };
Здесь STONE обозначает Камень, GRASS — Траву, FISH — Рыбу и
HUNTER — Хищника (от английских слов stone — камень, grass —
трава, fish — рыба и hunter — охотник).
Для простоты будем изображать все объекты кругами разного цве­
та: Камни — чёрными, Траву — зелёными, Рыб — синими и Хищни­
ков — красными.
В базовый класс COceanObject добавим три поля, общие для всех
объектов: координаты центра круга (х, у) и радиус круга г:
class COceanObject
{
public:
int x, у, г;
};
Теперь определим общие методы, которые должны иметь все океан­
ские объекты. Компьютер выполняет моделирование в дискретном време­
ни, обновляя картинку на экране с некоторым интервалом Ai. В течение
очередного интервала моделирования каждый объект может измениться.
Могут поменяться размеры или координаты объекта, объект может быть
съеден или, наоборот, сам может кого-то съесть. Все эти изменения мы
поместим в метод change (по-английски — изменить).

114
 Наследование §15

Кроме того, каждый объект должен уметь по команде сам себя

перерисовывать. Для этого добавим в базовый класс ещё один метод —
show (по-английски — показать).
Эти две операции (изменить и показать) нужно выполнять на каж­
дом шаге моделирования. Поэтому их удобно объединить в новый ме­
тод update (по-английски — дополнить). Получается схема базового
класса, показанная на рис. 2.4.

COceanObjесt
х
У
z
update
change
show

Рис. 2.4
Запишем эту схему в виде класса на языке C++:
class COceanObject
{
public:
int x, у, г;
void update();
void change();
void show() const;
};
Метод show не должен изменять объект, поэтому он объявлен с описа­
телем const.
Мы не определили конструктор для этого класса, поэтому компи­
лятор создаст конструктор по умолчанию, который просто размещает
объект в памяти.
Теперь мы даже можем создать объект этого класса и присвоить
значения его полям:
COceanObject obj;
obj.х = 100;
obj.у = 100;
obj.r = 10;
Конечно, при попытке вызвать метод этого объекта
obj.update();
мы увидим сообщение об ошибке, ведь реализации этого метода (про­
граммного кода) пока нигде нет.

115
2 Программирование на языках C++ и C#

Абстрактный класс
Разбираться с методами класса начнём с метода update. Его содержа­
ние написать очень просто: объект изменяется, и затем на экран вы­
водится его новое изображение. Это значит, что сначала вызывается
метод change, а потом сразу — метод show. Так будут обновляться
объекты всех классов, поэтому метод update мы правильно поместили
в базовый класс TOceanObject:
class COceanObject
{
public:

void update() {
change();
show ();
}
};
Методы change и show есть у всех объектов, поэтому они также
должны располагаться именно в базовом классе COceanObject. Но
каждый наследник будет выполнять их по-разному, т. е. наследники
будут переопределять методы базового класса. Такие методы обозна­
чаются словом virtual (в переводе с английского — виртуальный) в
начале объявления метода:
class COceanObject
{
public:

virtual void change ();

virtual void show () const;
};
Обратим внимание на то, что мы не можем в базовом классе напи­
сать код методов change и show, потому что у всех классов объектов
эти методы выполняются по-разному. Мы знаем, как нарисовать ка­
мень, траву, рыбу, но никто не знает, как нарисовать «океанский объ­
ект вообще».
Конечно, можно добавить в базовый класс методы-«заглушки», кото­
рые ничего не делают:
class COceanObject
{
public:

virtual void change () {}

virtual void show() const {}
};

116
 Наследование §15

Пустые фигурные скобки (они выделены фоном) говорят о том, что

метод есть, но ни одна команда в нём не выполняется.
Но если мы поставим «заглушки», появится возможность создать и
использовать объекты базового класса, что бессмысленно. В этом случае
в языке C++ можно применить красивое решение: мы объявим методы
в классе, но укажем, что пока они не определены, и поэтому создавать
такой класс нельзя. Для этого нужно «приравнять методы к нулю»:
class COceanObject
{
public:

virtual void change() = 0;

virtual void show() const = 0;
};
Функции, «приравненные к нулю», называются «чистыми» функци­
ями или абстрактными методами. Они обязательно должны быть вир­
туальными, иначе наследники не смогут их переопределить.

Класс в C++, в котором объявлена хотя бы одна чистая виртуальная

функция, называется абстрактным. Создавать объекты такого класса
нельзя.

Как и в других языках программирования, для того чтобы наслед­

ник абстрактного класса COceanObject не был абстрактным, он дол­
жен переопределить обе чистые виртуальные функции базового класса,
change и show.

Защищённые поля и методы (protected)

Теперь обсудим поля класса COceanObject. Сейчас все они открытые,
потому что находятся в секции public. Как мы уже выяснили в § 14,
этого нужно избегать. Конечно, можно сделать их закрытыми (поме­
стить в секцию private) и добавить методы для работы с ними («гет­
теры» и «сеттеры»). Но чтобы не усложнять запись программы (напри­
мер, не писать obj.getxO вместо obj.x), мы сделаем по-другому.
В языке C++ кроме private и public есть ещё один модификатор
доступа: protected (в переводе с английского — защищённый). Он
означает, что поля или методы, размещённые в этой секции, откры­
ты всем наследникам класса, но недоступны объектам всех остальных
классов:
class COceanObject
{
protected:
int x, у, г;

117
2 Программирование на языках C++ и C#

public:
void update() {
change ();
show () ;
}
virtual void change() = 0;
virtual void show() const = 0;
};
Теперь наследники класса COceanObject смогут работать с полями
базового класса так же, как с открытыми полями, а другие объекты
не смогут «увидеть» эти поля.
И тут возникает вопрос: а как же мы будем присваивать начальные
значения полям? Имеет смысл делать это сразу при создании объекта,
в конструкторе. Следовательно, нам нужно добавить в описание класса
конструктор, присваивающий начальные значения полям х, у и г.
Поскольку класс COceanObject абстрактный, его конструктор будет
вызываться только классами-наследниками. Поэтому конструктор так­
же можно поместить в секцию protected:
class COceanObject
{
protected:
int x, у, г;
COceanObject( int xO, int yO, int rO ):
x(xO) , y(yO), r(rO) { }

};

Неподвижные объекты
В нашей программе будут два класса неподвижных объектов — CStone
{Камень) и CGrass {Трава).
Начнём с класса CStone. Как показано на рис. 2.3, он — прямой
наследник базового класса COceanObject. Поэтому заголовок класса
выглядит так:
class CStone: public COceanObject
{

}
После названия нового класса CStone через двоеточие указан базовый
класс COceanObject. Служебное слово public определяет режим до­
ступа при наследовании. В нашем случае режим доступа не меняется:
защищённые (protected) данные базового класса остаются защищён­
ными и для класса-наследника, а открытые — открытыми. В этом по­
собии мы не будем использовать другие варианты наследования1'.
При желании вы легко найдёте эту информацию в литературе или в Интернете.

118
 Наследование §15

Приведём полный текст класса CStone:

class CStone: public COceanObject
{
public:
CStone( int xO, int yO, int rO ):
COceanObject ( xO, yO, rO ) {}
virtual void change() override {}
virtual void show() const override
{ drawObject( x, y, r, STONE ); }
};
Конструктор класса CStone расположен в секции public, т. е. его
можно вызывать из любой функции. Он принимает три целочисленных
параметра — координаты и размер камня, — и сразу вызывает кон­
структор базового класса COceanObject, передавая ему все эти данные.
Заметим, что вызов конструктора базового класса записывается через
двоеточие сразу после заголовка конструктора класса CStone. Сначала
всегда выполняется конструктор базового класса, а потом — конструк­
тор производного класса (в данном случае он пустой).
В секции public находятся два переопределяемых метода: change
и show. Вообще говоря, слово virtual при описании этих методов не
обязательно, потому что виртуальные методы базового класса будут
виртуальными у всех наследников. Но так программу легче читать —
мы сразу видим, что метод виртуальный, не заглядывая в описание
базового класса.
Описатель override (в переводе с английского — переопределить)
говорит о том, что класс CStone переопределяет метод базового клас­
са, а не добавляет новый метод. Слово override тоже можно не пи­
сать, но оно ясно выражает намерения программиста и позволяет об­
наруживать некоторые ошибки. Если мы попытаемся переопределить
метод, которого нет в базовом классе, компилятор сообщит об ошибке.
Обратите внимание, что метод show обязательно должен быть объ­
явлен с описателем const, потому что такой описатель есть у метода
show базового класса.
Метод change у класса CStone — пустой, так как во время анима­
ции никаких изменений с камнем не происходит. А в методе show ка­
мень выводится на экран с помощью процедуры drawObject, которую
мы напишем позже. Она должна принимать координаты и размер объ­
екта, а также его тип — значение из перечисления objectType (тип
объекта для камня — STONE).
Класс CGrass {Трава) строится аналогично, сделайте это самостоя­
тельно1).
1) Если вам очень хочется поскорее собрать и запустить программу, посмотрите
пункты «Вспомогательные процедуры и функции» и «Основная программа» в
конце этого параграфа.

119
2 Программирование на языках C++ и C#

Подвижные объекты
Подвижные объекты относятся к классу CMovingObject, который
наследует все свойства и методы базового класса COceanObject:
class CMovingObject: public COceanObject
{

}
В этом классе к тем полям и методам, которые унаследованы от
класса COceanObject, добавляются два новых поля — скорость движе­
ния (поле v) и курс (поле course), — и новый метод move (в переводе
с английского — двигаться):
class CMovingObject: public COceanObject
{
protected:
double v, // скорость
course; // курс в градусах
public:
CMovingObject( int xO, int yO, int rO,
double vO, double courseO = 0 ) :
COceanObject( xO, yO, rO ),
v(vO), course(courseO)
{ )
virtual void move()
{
double courseRadians = course*M_PI/180;
x += round(v*cos(courseRadians) ) ;
у -= round(v*sin(courseRadians) ) ;
if ( x-r < 0 ) x += SCREEN_WIDTH;
if ( x+r > SCREEN_WIDTH )
x -= SCREEN_WIDTH;
if ( y-r < 0 ) у += SCREEN_HEIGHT;
if ( y+r > SCREEN_HEIGHT )
у -= SCREEN—HEIGHT;
}
};
Конструктор класса CMovingObject вызывает конструктор базового
класса, а затем записывает в поля v и course дополнительные дан­
ные: скорость и курс, которых у базового класса нет. В конструкторе
определён© значение по умолчанию для последнего параметра course:
если курс не задан, он считается равным нулю.
Новый метод move определяет алгоритм движения объекта. Это вир­
туальный метод, так что классы-наследники могут его переопределить.
Курсовой угол переводится в радианы, затем изменяются координаты
х и у (подробно мы обсуждали эти формулы в § 7, см. рис. 1.12).

120
 Наследование §15

После этого проверяем, не вышел ли объект за границы игрового

поля. Если вышел, то «перекидываем» его на другую сторону поля.
Например, если объект вышел за верхнюю границу, он вновь появля­
ется на поле снизу. Здесь используются целочисленные константы —
размеры поля:
const int SCREEN_WIDTH = 600,
SCREEN_HEIGHT = 4 00;
Их нужно определить в самом начале программы как глобальные дан­
ные.
Обратите внимание, что методы класса CMovingObject могут обра­
щаться к полям х, у и г базового класса, так как эти поля — за­
щищённые (protected), т. е. доступны всем наследникам класса
COceanObject.
Заметим, что абстрактные методы change и show базового клас­
са здесь не переопределяются. Это означает, что новый класс
CMovingObject — тоже абстрактный, и создавать объекты этого класса
нельзя. Хотя бы потому, что мы не знаем, как изобразить их на поле.

Рыбы
Рыбы (класс CFish) — это подвижные объекты, т. е. наследники клас­
са CMovingObject. Класс CFish можно описать так:
class CFish: public CMovingObject
{
public:
CFish( int xO, int yO, int rO,
double vO, double courseO ):
CMovingObject( xO, yO, rO, vO, courseO )
{ }
virtual void change () override
{ move(); }
virtual void show () const override
{ drawObject ( x, y, r, FISH ); }
};
Конструктор класса просто вызывает конструктор базового класса
CMovingObject. Метод change вызывает метод move из базового клас­
са, а метод show рисует рыбу с помощью процедуры drawObject, пере­
давая ему последний аргумент FISH.
В описании класса CFish определены оба абстрактных метода
базового класса — change и show. Мы знаем, как изменять состояние
рыбы во время моделирования и как нарисовать её на экране. Поэтому
класс CFish — не абстрактный класс, и мы можем (и будем) создавать
экземпляры этого класса.

121
2 Программирование на языках C++ и C#

Хищники
Займёмся хищниками. Класс CHunter (Хищник) — это тоже наслед­
ник класса CMovingObject:
class CHunter: public CMovingObject
{

};
У нас на поле будет всего один экземпляр класса CHunter — им
управляет игрок. Хищник должен двигаться с заданной скоростью к
той точке игрового поля, на которую указывает курсор мыши.
Определим, куда переместится хищник за один интервал игрового
времени At. Начальные координаты хищника — х и у, скорость и озна­
чает, что за время At он проходит v единиц игрового поля (пикселей).
Пусть хм и ум — координаты курсора мыши. Тогда расстоя­
ние между текущим положением хищника и заданной точкой можно
вычислить по теореме Пифагора:

d = fyx- хм)2 + (у- ум)2 .

Далее определим ту часть (долю) этого расстояния, которую пройдёт

хищник за один интервал игрового времени At:
v
P=d’
и вычислим новые координаты хищника:
хг = X + р(хм- х), уг = у +р (ум - у).

Конечно, нужно убедиться, что d Ф 0, т. е. хищник ещё не пришёл

в нужную точку.
Приведём полностью описание класса CHunter:
class CHunter: public CMovingObject
{
public:
CHunter( int xO, int yO, int rO, int vO ):
CMovingObject( xO, yO, rO, vO )
{}
virtual void change () override
{
int xMouse = getMouseXO,
yMouse = getMouseYO;
double dist = hypot ( x - xMouse, у - yMouse );
if( dist < 1 ) return;
double part = v / dist;

122
 Наследование §15

if( part > 1 ) part = 1;

x += round(part*(xMouse - x));
у += round(part*(yMouse - y));
}
virtual void show() const override
{ drawObject( x, y, r, HUNTER ); }
};
В этом классе определяются оба абстрактных метода базового клас­
са: change и show. Поэтому класс CHunter — не абстрактный, и мы
сможем создать объект-хищник в программе.
В методе change хищник двигается со скоростью v к точке, на
которую указывает мышь. Координаты курсора мыши в окне опреде­
ляются с помощью функций getMouseX и getMouseY, мы их напишем
в конце параграфа (пока будем считать, что они есть1*).
Далее закодирован описанный выше алгоритм. Дистанцию di st между
текущим положением объекта и точкой назначения находим с помощью
стандартной функции hypot, которая вычисляет гипотенузу прямоуголь­
ного треугольника по его катетам. Рассчитанные смещения округляются
к ближайшему целому числу с помощью стандартной функции round.
В качестве упражнения попробуйте разобраться, зачем нужна строка
if( part > 1 ) part = 1;
в методе change и что произойдёт, если её убрать.
Метод show рисует объект на экране, вызывая процедуру drawobject
с последним аргументом HUNTER.

Вспомогательные процедуры и функции

Выводить все объекты на экран будет процедура drawobject, которая
принимает четыре параметра: координаты объекта х и у (это коорди­
наты базовой точки — центра круга), радиус круга г и тип объекта —
значение type перечисляемого типа objectType:
void drawObject( int x, int y, int r,
objectType type )
{
if ( type == STONE )
drawCircle ( x, y, r, RGB(0,0,0) );
else if( type == GRASS )
drawCircle ( x, y, r, RGB(0,255, 0) );
else if( type == FISH )
drawCircle ( x, y, r, RGB(0, 0,255) );
else /* if ( type == HUNTER ) */
drawCircle ( x, y, r, RGB(255,0, 0) );
}
Подумайте, какой метод разработки программ мы здесь используем.

123
2 Программирование на языках C++ и C#

Поскольку тип obj ectType включает всего четыре возможных значе­

ния, проверку последнего условия (на тип HUNTER) делать не нужно —
если первые три не подошли, то остаётся только вариант HUNTER.
Процедура drawcircle должна нарисовать круг с заданными пара­
метрами (последний — это цвет заливки):
void drawCircle ( int х, int у, int г,
COLORREF fillColor )
{
txSetColor ( RGB(0,0,0) );
txSetFillColor( fillColor );
txCircle( x, у, r ) ;
}
Цвет контура выбирается в первой строке — здесь он всегда чёрный
(но вы можете всё изменить!).
В методе change класса CHunter мы использовали функции
getMouseX и getMouseY для определения координат курсора мыши.
Эти функции сводятся к вызовам аналогичных функций библиотеки
ТХ Library:
int getMouseX () { return txMouseXO; }
int getMouseY () { return txMouseYO; }
Для получения случайных целых чисел на отрезке [а; Ь] мы приме­
ним функцию randlnt, которая использовалась в предыдущих частях
пособия:
int randlnt( int a, int b ) {
return a + rand() % (b-a+1);
}

Основная программа
Настало время собрать игру целиком. В начале подключим библиоте­
ку ТХ Library, введём перечисляемый тип данных objectType и кон­
станты (размеры поля):
#include "TXLib.h"
enum objectType { STONE, GRASS, FISH, HUNTER };
const int SCREEN_WIDTH = 600,
SCREEN_HEIGHT = 400;
Затем запишем все вспомогательные процедуры и функции, которые
были только что рассмотрены. После этого поместим описания всех
классов, начиная с базового.
В начале основной программы необходимо создать все нужные объ­
екты. Мы покажем, как добавить на поле камни и хищника, осталь­
ные объекты вы сможете построить самостоятельно.

124
 Наследование §15

Хищник — это объект класса CHunter. В нашей программе этот

объект будет иметь имя hunter:
CHunter hunter ( 100, 150, 10, 5 );
Здесь вызывается конструктор класса, ему передаются координаты
(х = 100, у = 150), размер (г = 10) и скорость хищника (v = 5). Хищ­
ник готов.
С камнями получается посложнее. Попытаемся создать массив из 10
объектов класса CStone:
const int NUMBER_OF_STONES = 10;
CStone stones[NUMBER_OF_STONES];
Эти строки вызовут ошибку при компиляции.
Дело в том, что при таком объявлении должен быть вызван кон­
структор без параметров, которого у нас в классе просто нет! Можно
было бы надеяться на конструктор по умолчанию, но компилятор со­
здаёт его только тогда, когда в описании класса вообще нет никакого
конструктора. Мы же определили свой конструктор в классе CStone,
поэтому конструктор по умолчанию не будет построен.
Более того, все данные объекта-камня в базовом классе COceanObject
защищённые, т. е. недоступные «посторонним» объектам и функци­
ям, в том числе и основной программе. И поэтому задать их значения
можно только в конструкторе, при создании объекта.
Но выход есть. Мы создадим массив указателей на объекты1*. На­
помним, что указатель — это переменная, в которой можно хранить
адрес данных определённого типа, в том числе и адрес объекта. Объ­
явим массив указателей:
CStone* pStones[NUMBER_OF_STONES ];
Для того чтобы не забыть, что это указатели, имя массива начинается
со строчной буквы р (от англ, pointer — указатель).
Это ещё не объекты, а переменные, в каждую из которых можно за­
писать адрес какого-то объекта типа CStone. Теперь в цикле мы будем
на каждой итерации создавать в памяти новый объект-камень и запи­
сывать его адрес в очередной элемент массива указателей:
for( int i = 0; i < NUMBER_OF_STONES; i++ )
pStones [i] = new CStone(
rand!nt(0, SCREEN_WIDTH),
randInt(0, SCREEN_HEIGHT),
randlnt(5, 15) );

Здесь можно было бы использовать вектор (динамический массив) объектов, в

который объекты-камни добавляются по одному. Но вариант с указателями будет
нам более удобен при усовершенствовании программы.

125
2 Программирование на языках C++ и C#

В цикле вызывается конструктор с тремя параметрами. Координаты

камня задаются случайным образом в пределах игрового поля, а его
размер (радиус) — случайное целое число из отрезка [5; 15].
Теперь можно создать графическое окно:
txCreateWindow( SCREEN_WIDTH, SCREEN_HEIGHT );
и запустить цикл моделирования:
while( not GetAsyncKeyState(VK_ESCAPE) ) {
txSetFillColor ( TX_WHITE ); // (1)
txClear (); // (2)
for( int i = 0; i < NUMBER_OF_STONES; i++ )
pStones[i]->update (); // (3)
hunter.update(); // (4)
txSleep ( 50 ); // (5)
}
Как следует из заголовка, этот цикл заканчивает работу при нажатии
клавиши Escape. Один интервал игрового времени At (время ожидания в
конце каждой итерации цикла) равен 50 миллисекунд (строка 5).
В теле цикла сначала устанавливается белый цвет заливки (строка 1)
и очищается холст (строка 2). Затем в цикле перебираем все указате­
ли на объекты-камни в массиве pStones, для каждого из этих объек­
тов вызываем метод update. Обратите внимание, что здесь использу­
ется не точечная запись, а оператор ->, потому что элемент массива
pStones [i] — это адрес объекта, а не сам объект и не ссылка на него.
В строке 4 вызывается метод update для хищника. Здесь другая
ситуация: переменная hunter — это именно объект, а не его адрес,
поэтому мы обращаемся к методу объекта с помощью точечной записи.
Интересно, что в классах CStone и CHunter нет метода update, а
мы в программе его вызываем, и всё работает! Но этот метод есть в
базовом классе COceanObject, наследниками которого являются и
CStone, и CHunter. Значит, у классов CStone и CHunter тоже есть ме­
тод update, который им «передал по наследству» базовый класс. Клас­
сы-наследники получают «по наследству» все данные и методы всех
«классов-предков» (кроме закрытых, private).
Другие объекты (траву, рыб) вы можете добавить в программу само­
стоятельно.
Строго говоря, после того как объекты, созданные с помощью опера­
тора new, станут не нужны (в конце программы), их нужно удалить из
памяти, вызвав оператор delete:
for( int i = 0; i < NUMBER_OF_STONES; i++ )
delete pStones[i];
Но здесь это делать не обязательно, поскольку при завершении про­
граммы вся выделенная ей память освобождается автоматически.
Проблема может возникнуть, если выделение памяти происхо­
дит внутри функции, которая часто вызывается (например, 10 раз в

126
 Наследование §15

секунду). Если в конце работы функции ненужная память не освобож­

дается, возможна утечка памяти (англ, memory leak). Это значит, что
выделенный блок памяти не освобождён, а указатель на него потерян.
Так может произойти, например, когда функция закончит работу и
указатель — локальная переменная — выйдет из области видимости.
Выделенная память будет помечена как занятая до конца работы про­
граммы, и освободить её не получится, так как обратиться к ней не­
возможно. В результате при каждом вызове функции выделяются (и
не освобождаются) всё новые и новые блоки памяти. В конце концов,
свободная память будет исчерпана, и программа завершится аварийно.

Выводы
• Классы в программе образуют иерархию. Базовый класс объединя­
ет общие данные и методы всех объектов.
• Класс-наследник обладает всеми свойствами и методами базового
класса.
• Класс, который предназначен только для создания классов-
наследников, а не экземпляров (объектов), называется абстракт­
ным. Абстрактный класс объединяет общие данные и методы
группы классов.
• Виртуальная функция — это метод, который могут переопреде­
лять классы-наследники.
• Чистая виртуальная функция только объявляется в классе, но её
программный код (реализация) отсутствует.
• Абстрактный класс в C++ — это класс, который содержит хотя
бы одну чистую виртуальную функцию.
• Чтобы класс-наследник не был абстрактным, он должен пере­
определить все чистые виртуальные функции базового класса. Пос­
ле этого можно будет создавать экземпляры класса-наследника.
• Если новые объекты создавались с помощью оператора new
(динамически), программа должна освободить эту память с помо­
щью оператора delete.

Вопросы и задания
1. Чем полезна иерархия классов? Почему бы не использовать в про­
грамме отдельные (не связанные между собой) классы?
2. Что такое метод-«заглушка»? Какие достоинства и недостатки он
имеет?
3. Объясните, почему бессмысленно создавать объекты абстрактного
класса.
4. Что такое виртуальная функция? Почему некоторые виртуальные
функции называют чистыми?
5. Можно ли по описанию класса сразу сказать, абстрактный он или
нет? Рассмотрите разные случаи.

127
2 Программирование на языках C++ и C#

6. Можно ли метод update базового класса из параграфа объявить с

описателем const? Почему?
7. Что такое переопределение метода? Зачем оно используется?
8. В каком случае класс-наследник абстрактного класса сам не будет
абстрактным классом?
9. Расскажите о разных способах, с помощью которых класс-наследник
может обратиться к полям базового класса. Сравните их, обсудите
достоинства и недостатки каждого способа.
10. Найдите все ошибки в описании класса (в этом и следующих
заданиях используются классы, приведённые в параграфе).
class CStone ( COceanObject );
{
/* какие-то объявления */
}
11. Найдите все ошибки, которую допустил программист:
COceanObject fish;
CHunter hunter;
Предложите варианты исправления этих ошибок.
12. Сравните свойства данных и методов, описанных в секциях
private, protected и public. Как выбрать нужную секцию для
нового поля или метода?
13. Как вы думаете, что произойдёт, если конструктор класса объявить
в секции private или protected? Проверьте ваши выводы экспе­
риментально.
14. Зачем при переопределении виртуальных методов в классах-наслед­
никах обычно пишут слово virtual, хотя можно этого и не делать?
15. Используя дополнительные источники, выясните, что означает слу­
жебное слово final и зачем его можно использовать.
16. Какая серьёзная ошибка может случиться, если убрать из метода
change класса CHunter следующую строку?
if( dist < 1 ) return;
Проверьте ваш ответ, запустив программу на компьютере.
17. Что произойдёт, если убрать из метода change класса CHunter сле­
дующую строку?
if( part > 1 ) part = 1;
Проверьте ваш ответ, запустив программу на компьютере, и объяс­
ните результат.
18. Какая ошибка произойдёт, если создать массив объектов класса
CStone так?
CStone stones[10];
Чем она вызвана? Как можно доработать программу, чтобы такой
способ тоже был возможен?
19. Придумайте свой тип океанских объектов и добавьте его в иерар­
хию на рис. 2.3.

128
 Полиморфизм §16

20. Проведите рефакторинг программы. Методы, состоящие из не­

скольких строк (например, метод move класса CMovingObject),
оформите как отдельные подпрограммы вне описания класса.
* 21. Проект. Вынесите все классы в отдельный модуль. Создайте
для него заголовочный файл. Учтите, что все подпрограммы, ко­
торые используют функции библиотеки ТХ Library (например,
drawCircle, getMouseX, getMouseY), должны находиться в одном
файле — там же, где и основная программа с именем main.
* *22.Предусмотрите такой метод добавления объектов на поле, чтобы
объекты не перекрывали друг друга.
* *23.Сделайте так, чтобы хищник не мог «проходить сквозь камни».
При столкновении с камнем он должен перекатиться вокруг него.

Интересные сайты
cplusplus.com — сайт, посвящённый программированию на языке
C++
rsdn.org — сайт, посвящённый разработке программного обеспечения
(на разных языках)

§16
Полиморфизм
Ключевые слова:
• базовый класс • позднее связывание
• класс-наследник • таблица виртуальных методов
• виртуальный метод • деструктор
• полиморфизм
В § 5 мы познакомились с полиморфизмом. Так называется возмож­
ность классов-наследников по-разному реализовать метод базового клас­
са. Виртуальные методы change и show в построенных ранее классах
морских объектов — это как раз пример полиморфизма. В этом па­
раграфе мы увидим, что виртуальные методы особенно полезны при
работе с коллекцией объектов разных классов через указатели.

Указатели на базовый класс

Добавляя на игровое поле объекты, вы, скорее всего, записывали адре­
са объектов каждого типа в отдельный массив. Например, так:
const int NUMBER_OF_STONES = 10;
CStone* pStones[NUMBER_OF_STONES];
for( int i = 0; i < NUMBER_OF_STONES; i++ )
pStones[i] = new CStone( ... );

129
2 Программирование на языках C++ и C#

const int NUMBER_OF_GRASS = 10;

CGrass* pGrass[NUMBER_OF_GRASS];
for( int i = 0; i < NUMBER_OF_GRASS; i++ )
pGrass[i] = new CGrass( ... );
Здесь многоточия внутри скобок обозначают аргументы конструкторов,
которые мы здесь не написали для экономии места.
Однако можно было сделать проще — записывать все указатели в
один массив. Это кажется странным, ведь указатель предназначен для
хранения адресов объектов конкретного типа. Например, фрагмент
кода
CStone *pl;
CGrass *р2;
вводит два указателя: в указатель pl можно записать адрес любого
объекта класса CStone, а в р2 — адрес любого объекта класса CGrass.
В общем случае записать в указатель одного типа адрес объекта друго­
го типа нельзя. Но есть одно исключение.
Объявим указатель так:
COceanObject *pObject;
Кажется, что это совершенно бессмысленно, ведь в нашей программе
COceanObject — это абстрактный класс, и создать объект этого класса
невозможно: компилятор просто не позволит этого сделать.
Однако в языке C++ такой указатель может хранить адрес любого
наследника класса COceanObject. Это вполне естественно, ведь любой
наследник «умеет» делать всё, что «умеет» объект базового класса.
Область памяти, занимаемую объектом класса-наследника (например,
класса CStone), можно разделить на две части: сначала размещаются
данные и методы базового класса COceanObject, а затем — данные и
методы, определённые в классе-наследнике (рис. 2.5).
Данные и методы класса
COceanObject
Данные и методы класса
CStone

Рис. 2.5
Указатель на любой объект класса-наследника хранит начальный адрес
этой области, поэтому через него можно легко «добраться» до всех
данных и методов базового класса.
В переменную pObject, которая объявлена выше, можно записать
адрес нового объекта-камня:
pObject = new CStone( 100, 100, 10 );
Потом можно удалить этот объект-камень из памяти и в ту же пере­
менную записать адрес нового объекта-рыбы:

130
 Полиморфизм §16

delete pObject;
pObject = new CFish( 100, 100, 5, 2, 120 );
В переменную, объявленную как указатель на объект класса А, мож­
но записать адрес любого объекта-наследника класса А.
Используя эту особенность, построим общий массив указателей для
хранения адресов всех океанских объектов. Вот как это выглядит для
камней и травы:
#include <vector>
using namespace std;

vector <COceanObject*> pObjects;

const int NUMBER_OF_STONES = 10;
for( int i = 0; i < NUMBER_OF_STONES; i++ )
pObjects.push_back ( new CStone(
randlnt(0, SCREEN_WIDTH),
randlnt(0, SCREEN_HEIGHT),
randlnt(5, 15) ) );
const int NUMBER_OF_GRASS = 10;
for( int i = 0; i < NUMBER_OF_GRASS; i++ )
pObjects.push_back ( new CGrass(
randlnt(0, SCREEN_WIDTH),
randlnt (0, SCREEN_HEIGHT),
randlnt(5, 15) ) );
Здесь вместо статического массива заранее определённого размера
используется динамический массив (вектор), размер которого можно
изменять во время работы программы.
В начале программы подключаем библиотеку vector и пространство
имён std, в котором объявлены все стандартные функции библиотеки
языка C++.
Объявление
vector <COceanObject*> pObjects;
вводит новый вектор с именем pObjects. В угловых скобках записан
тип элементов этого массива: указатель на объект класса COceanObject.
Сразу после объявления массив пустой, в нём нет ни одного эле­
мента. Метод push_back добавляет новый элемент в конец массива.
В двух циклах мы с помощью этого метода добавляем в массив снача­
ла 10 адресов вновь созданных объектов-камней, а потом — 10 адресов
новых объектов типа CGrass.

Полиморфизм в действии
Теперь возникает вопрос: что делать с этим массивом, в который за­
писаны адреса объектов разных типов, и (это важно!) являющихся

131
 Программирование на языках C++ и C#

наследниками одного базового класса COceanObject. Попробуем в цик­

ле вызвать метод update для каждого объекта:
for( int i = 0; i < pObjects.size(); i++ )
pObj ects[i]->update() ;
Запустив программу, вы убедитесь, что все объекты нарисованы
правильно! Действительно, метод update — это метод базового класса
COceanObject:
class COceanObject
{

public:
void update() {
change();
show ();
}
};
Но он вызывает методы change и show, которых в базовом классе нет.
Все объекты нарисованы правильно (камни — чёрные, трава — зелё­
ная). Это значит, что для объектов класса CStone были вызваны мето­
ды change и show из класса CStone, а для объектов класса CGrass —
методы с такими же именами из класса CGrass.
Фактически программа во время выполнения определила, к какому
классу относится конкретный объект, и вызвала именно «его» методы.

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

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

Таким образом, полиморфизм позволяет использовать один и тот же

интерфейс (способ вызова метода) для управления объектами разных
классов.
Немного теории
Полиморфизм можно использовать при обращении к объекту не только
через указатель, но и через ссылку. Пусть у нас есть два класса1*: CCat
и CPurringCat, причём класс CPurringCat — наследник класса CCat:
class CCat
{
public:
virtual void say(){
cout « "Мяу!" « endl;
}
};
1 По-английски cat — кошка, a purring cat — мурлыкающая кошка.

132
 Полиморфизм §16

class CPurringCat: public CCat

{
virtual void say() {
cout << "Mypp!" << endl;
}
};
В этих классах есть виртуальный метод say, который выводит сообще­
ние на экран.
Рассмотрим процедуру, которая принимает один параметр — объект
класса CCat — и вызывает его метод say:
void voice ( CCat cat ) {
cat.say();
}
В основной программе создадим объекты классов CCat и CPurringCat
и вызовем для каждого из них процедуру voice:
CCat cat;
CPurringCat purrCat;
voice( cat ); // Мяу!
voice( purrCat ); // Мяу!
Программа успешно компилируется, несмотря на то что в послед­
ней строке мы передали объект другого класса, CPurringCat вместо
CCat. Это возможно только потому, что класс CPurringCat — наслед­
ник класа CCat. Согласно правилам языка C++, процедуре voice мож­
но передать объект любого класса-наследника CCat, поскольку любой
такой объект обладает всеми свойствами и методами класса CCat.
Вызов процедуры для объекта cat даёт ожидаемый результат —
текст «Мяу!». Кажется, что при втором вызове программа должна вы­
вести «Мурр!», но это не так. Дело в том, что объект передаётся в
эту процедуру по значению. В этом случае в стеке строится временный
объект класса CCat, и для него вызывается метод say.
Теперь введём вторую процедуру, параметр которой уже не объект,
а ссылка на него:
void voiceRef ( CCat& cat ) {
cat.say();
}
и снова вызовем её для обоих объектов:
voiceRef( cat ); // Мяу!
voiceRef( purrCat ); // Мурр!
Здесь объект передаётся по ссылке (временный объект не создаётся),
и это может быть объект любого класса-наследника CCat. С одной сто­
роны, мы сообщили компилятору, что параметр cat в процедуре — это
ссылка на объект класса CCat. Это его статический тип, т. е. тип,

133
2 Программирование на языках C++ и C#

известный в момент компиляции. С другой стороны, при вызове про­

цедуры переданная ссылка может указывать на объект любого класса-
наследника CCat, это динамический тип параметра, который может
отличаться от статического. Например, в последней строке нашей про­
граммы динамический тип параметра cat — это CPurringCat. В этом
случае, как и при обращении через указатель, программа определяет
фактический тип объекта и вызывает метод say класса CPurringCat.

Позднее связывание
Если мы хотим использовать полиморфизм при вызове методов через
указатели, важно, чтобы эти методы были виртуальными, для невир­
туальных методов такой механизм не работает.
Предположим, что в базовом классе COceanObject методы change
и show не объявлены виртуальными (например, мы поставили вместо
них «заглушки»). Тогда при компиляции в машинный код сразу за­
писываются команды перехода по адресам в памяти, где расположены
эти (обычные, невиртуальные) методы.
Пусть р — указатель на объект базового класса, и мы записали в
него адрес класса-наследника:
COceanObject* р = new CStone ( ... );
Теперь вызываем метод update, объявленный в базовом классе:
p->update();
И тут выясняется, что в машинном коде метода update адреса перехо­
дов на методы change и show уже прописаны. В итоге программа вы­
полнит методы-«заглушки» базового класса и ничего не нарисует.
У нас же методы change и show — виртуальные. В этом случае ком­
пилятор «соображает», что наследники могут переопределить эти мето­
ды, и поэтому не записывает в машинный код метода update фикси­
рованные адреса переходов на методы change и show. Вместо этого он
добавляет довольно сложные команды, при выполнении которых:
• определяется фактический тип объекта;
• в таблице виртуальных методов объекта (англ. VMT: virtual
method table) ищется адрес нужного метода (например, метода
change);
• выполняется метод, расположенный по найденному адресу.
Потом так же происходит вызов виртуального метода show.
Такой механизм называется поздним связыванием. Это означает, что
программа определяет адрес выполняемого метода не при компиляции,
а во время выполнения программы.
При позднем связывании:
• вместе с каждым объектом хранится таблица его виртуальных
методов;

134
 Полиморфизм §16

• выполняются дополнительные действия — поиск нужного метода,

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

Класс Океан
До этого момента мы предполагали, что в нашей игре все обитатели
океана действуют независимо друг от друга. На самом деле они при­
надлежат единой системе Океан. При программировании игр такой
объект иногда называют игровым миром.
Если говорить на языке ООП, можно ввести ещё один «большой»
объект — Океан, — который «владеет» всеми другими объектами.
Назовём этот класс СОсеап:
class СОсеап
{
};
Информацию о его «подчинённых» объектах — камнях, траве и др. —
будем хранить как вектор (массив) указателей в закрытом поле объек­
та с именем pObjects:
class СОсеап
{
private:
vector <COceanObject*> pObjects;
};
В классе СОсеап создадим два метода. Первый метод — addObject —
будет добавлять новый объект, а второй — update — будет выполнять
обновление всех объектов в конце каждого интервала моделирования.
Оба этих метода сделаем общедоступными:
class СОсеап
{
private:
vector <COceanObject*> pObjects;
public:
void addObject( objectType type,
int xO, int yO, int rO = 10,
int vO = 0, double courseO = 0 );
void update ();
};

135
2 Программирование на языках C++ и C#

Первый параметр метода addObject — код объекта, который нуж­

но создать. Это величина перечисляемого типа objectType. Остальные
параметры — координаты и размер объекта, а также его скорость vO и
курс courseO. Последние два параметра используются только для под­
вижных объектов, поэтому для них определены значения по умолча­
нию: если эти параметры не заданы, они принимаются равными нулю.
Размер г0 тоже можно не задавать, если нас устраивает значение по
умолчанию, равное 10.
Реализацию (программный код) метода addObject выносим из опи­
сания класса:
void COcean::addObject( objectType type,
int xO, int yO, int rO,
int vO, double courseO )
{
COceanObject* pNewObj = nullptr; // (1)
if ( type == STONE ) // (2)
pNewObj = new CStone( xO, yO, rO );
else if( type == GRASS ) // (3)
pNewObj = new CGrass( xO, yO, rO );
else if( type == FISH )
pNewObj = new CFish( xO, yO, rO, vO, courseO );
else /* if ( type == HUNTER ) */
pNewObj = new CHunter( xO, yO, rO, vO);
if( pNewObj ) // (4)
pObjects.push_back( pNewObj ); // (5)
}
Обратите внимание, что значения параметров по умолчанию здесь ука­
зывать не нужно, они задаются в прототипе метода при объявлении
класса.
Разберём работу этого метода подробно. В строке 1 создаётся пере­
менная pNewObj — указатель на объект базового класса COceanObject.
В такой указатель можно записывать адрес любого объекта-наследни­
ка — базового класса. Мы сразу записываем в него значение по умол­
чанию — «нулевой указатель» nullptr.
В строке 2 проверяем переданный тип объекта: если это тип STONE,
создаём в памяти новый объект-камень класса CStone и записываем
его адрес в указатель pNewObj. Объект создаётся с помощью оператора
new, который вызывает конструктор класса CStone. Если переданный
тип — не STONE, продолжаем проверку дальше: если тип равен GRASS,
строим объект-траву (строка 3), и т. д.
Проверку на тип HUNTER выполнять не нужно (этот условный опе­
ратор поставлен в комментарий). Дело в том, что перечисляемый тип
objectType включает всего четыре варианта. Если первые три не по­
дошли, остаётся последний — HUNTER.

136
 Полиморфизм §16

В строке 4 проверяем, успешно ли создан объект. Если ошибок не

было, в указатель pNewObj будет записан ненулевой адрес нового объ­
екта, и мы добавляем его в конец вектора pObjects. В океане появил­
ся новый объект.
Если произошла ошибка, то в указателе pNewObj останется нулевое
значение (nullptr) — признак того, что создать объект не удалось.
При этом условие в строке 4 не выполнится, и вектор pObjects не из­
менится.
Второй метод класса СОсеап занимается обновлением состояния океана:
void СОсеап::update()
{
for( int i = 0; i < pObjects.size(); i++ )
pObjects[i]->update();
}
Здесь для каждого объекта, адрес которого хранится в векторе
pObjects, вызывается метод update. Обращение к методу объекта по
адресу выполняется с помощью оператора ->.
Используя возможности стандарта С++11, можно записать те же
действия более красиво и кратко:
void СОсеап::update()
{
for( auto pObj: pObjects )
pObj->update();
}
Такой цикл перебирает все указатели, входящие в вектор pObjects. На
каждой итерации цикла в переменной pObj оказывается адрес очеред­
ного объекта, и для этого объекта вызывается метод update. Служеб­
ное слово auto означает, что тип переменной pObj компилятор опре­
делит автоматически. Он будет совпадать с типом элементов вектора
pObjects, т. е. pObj — это указатель на объект класса COceanObject.
Метод update принадлежит базовому классу COceanObject и вызы­
вает ещё два метода: change и show. Они объявлены как виртуальные,
поэтому для каждого объекта вызываются «свои» версии этих методов.
Создадим в основной программе объект класса СОсеап:
СОсеап ocean;
Добавим в океан камни, траву, рыб. Например, для добавления кам­
ней можно использовать такой цикл:
const int NUMBER_OF_STONES = 10;
for( int i = 0; i < NUMBER_OF_STONES; i++ )
ocean.addObject( STONE,
randlnt( 0, SCREEN_WIDTH ),
randlnt( 0, SCREEN_HEIGHT ),
randlnt( 5, 15 ) );

137
 Программирование на языках C++ и C#

Другие типы объектов добавляются аналогично. Наконец, добавим

одного хищника:
ocean.addObject ( HUNTER, 100, 100, 10, 5 );
Он тоже будет одним из объектов в общем списке.
В теле цикла анимации теперь не нужно обновлять отдельно каж­
дый объект, достаточно вызвать метод update для главного объекта
ocean, а он уже «разберётся» сам со своими обитателями:
while( not GetAsyncKeyState(VK_ESCAPE) ) {
txSetFillColor( TX_WHITE );
txClear() ;
ocean.update() ;
txSleep ( 50 ) ;
}

Деструктор
В методе addObject класса COcean мы создаём новые объекты с помо­
щью оператора new, сохраняя их адреса в массиве pObjects. Чтобы не
было утечек памяти, важно сразу определить, где будет освобождаться
выделенная память.
Очевидно, что при уничтожении объекта Океан все другие объекты,
которые находятся в его «владении» (в массиве pObjects), тоже нуж­
но удалить. Поэтому возникает вопрос: как «поймать» момент удале­
ния объекта?
Для этой цели в каждом классе C++ есть специальный метод, кото­
рый называется деструктором.

Деструктор — это метод, который вызывается автоматически при

удалении объекта из памяти.

Если конструкторов у класса может быть много, то деструктор всег­

да только один. Вызывать деструктор специально не нужно, программа
вызовет его автоматически при выходе объекта из области видимости
или при удалении с помощью оператора delete.
Раньше мы никогда не добавляли деструкторы в описание класса.
При этом компилятор сам строит деструктор по умолчанию, который
просто освобождает память, занимаемую самим объектом.
Особый деструктор нужен тогда, когда объект захватывает какие-то
ресурсы: выделяет память, открывает файл и т. п. Тогда в деструкторе
эти ресурсы нужно освободить. Например, конструктор файлового потока
ifstream Fin( "input.txt" );
открывает файл на чтение. Когда поток выходит из области видимос­
ти, деструктор класса ifstream закрывает файл и снимает с него бло­
кировку.

138
 Полиморфизм §16

В нашем случае объект Океан хранит в векторе pObjects указатели

на блоки памяти, выделенные с помощью оператора new. При уничто­
жении объекта все его поля тоже уничтожаются, значит, использовать
эти указатели мы больше не сможем. Поэтому не сможем и освобо­
дить блоки памяти, на которые они ссылаются1*. Следовательно, осво­
бождать эту память нужно при уничтожении объекта Океан, т. е. в
деструкторе класса СОсеап. Таким образом, особый деструктор нам ну­
жен для того, чтобы освободить захваченные ресуры — память, выде­
ленную с помощью оператора new.
Деструктор — это специальный метод класса, имя которого начина­
ется со знака «~», а за ним записывают название класса:
class СОсеап
{
public:

-СОсеап(); // это деструктор

}
Деструктор, как и конструктор, — это не процедура и не функция,
а особый метод. Он ничего не возвращает, даже void, и не принимает
никаких параметров (в отличие от конструктора).
В теле нового деструктора нужно в цикле перебрать все указатели в
массиве pObjects и для каждого из них выполнить оператор delete
(удалить из памяти):
СОсеап::-СОсеап ()
{
for( auto pObj: pObjects )
delete pOb j;
}
При выполнении оператора delete объект, на который указыва­
ет очередной указатель obj, удаляется из памяти. При этом для него
вызывается деструктор. Но какой именно деструктор будет вызван?
Вспомним, что pObjects — это вектор указателей на объекты базо­
вого класса COceanObject. Ни в этом базовом классе, ни в его наслед­
никах мы не определяли деструкторы, поэтому компилятор построит
деструкторы по умолчанию. Но эти деструкторы — не виртуальные,
поэтому для всех объектов будет вызываться деструктор базового клас­
са. Это значит, что разрушается и удаляется из памяти только та
часть объекта, за которую «отвечает» базовый класс. Чтобы исправить
ситуацию, деструктор базового класса нужно сделать виртуальным,
добавив его в базовый класс COceanObject:

Если, конечно, мы не запомнили эти адреса где-то в другом месте.

139
2 Программирование на языках C++ и C#

class COceanObject
{
public:

virtual -COceanObject() = default;

};
Служебное слово default после знака = говорит о том, что компиля­
тору нужно построить деструктор по умолчанию, но сделать его вирту­
альным. В классах-наследниках деструкторы объявлять не нужно: они
станут виртуальными автоматически.
Деструкторы классов-наследников выполняются в обратном порядке
(по сравнению с конструкторами): сначала — деструктор производного
класса, затем — деструктор базового класса.

Выводы
• В переменную, объявленную как указатель на объект класса А,
можно записать адрес любого объекта-наследника класса А.
• При вызове виртуального метода через указатель или ссылку на
объект программа во время выполнения определяет фактический
класс объекта и вызывает метод того класса, к которому этот объ­
ект принадлежит.
• При позднем связывании программа определяет адрес выполняе­
мого виртуального метода не при компиляции, а во время выпол­
нения, в зависимости от типа объекта.
• При позднем связывании используется таблица виртуальных мето­
дов, которая хранится вместе с каждым объектом.
• Позднее связывание замедляет работу программы.
• Деструктор — это специальный метод, который вызывается при
удалении объекта из памяти. Если деструктор не указан, компи­
лятор построит деструктор по умолчанию.
• Деструктор необходимо определять, когда объект захватывает
ресурсы, например содержит указатели на блоки памяти, выде­
ленные во время работы программы.
• Если класс содержит виртуальные методы, его деструктор должен
быть объявлен виртуальным.
Вопросы и задания
1. Найдите все ошибки в этом фрагменте программы (в этом и следую­
щих заданиях используются объекты, приведённые в параграфе):
CFish р;
р = new CStone( 100, 100, 10 );
р.show ();
р = new COceanObject( 100, 100, 15 );
р = new CFish( 100, 100, 15, 2, 0 );
p->update;
Предложите способ исправления этих ошибок.

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

2. Оцените преимущества и недостатки использования статического

массива и динамического массива (вектора) для хранения адресов
игровых объектов.
3. Обсудите достоинства и недостатки обычного («раннего») и поздне­
го связывания.
4. Проверьте экспериментально, может ли класс-наследник переопре­
делить метод базового класса, не объявленный виртуальным. Со­
здайте новый объект и запишите его адрес в указатель на базовый
класс, например:
COceanObject* pStone = new CStone(100, 100, 5);
Теперь вызовите через этот указатель переопределённый невирту­
альный метод. Выясните, какой метод будет вызван: метод базово­
го класса или класса-наследника. Предположите, как связан этот
результат с таблицей виртуальных методов.
5. Как вы думаете, зачем нужен класс СОсеап?
6. В классе СОсеап не введен конструктор. Как же создаётся объект?
7. Почему вектор pObjects в классе СОсеап объявлен в секции
private?
8. Имеет ли смысл объявить метод update класса СОсеап виртуаль­
ным? Обсудите достоинства и недостатки такого решения.
9. Можно ли было объявить метод update класса СОсеап с описате­
лем const? Как вы думаете, почему мы так не сделали (с учётом
будущей доработки программы)?
*10. Найдите в дополнительных источниках информацию об операторе
switch и перепишите метод addObject класса СОсеап с помощью
оператора switch. Оцените достоинства и недостатки такого реше­
ния.
11. Приведите примеры ситуаций, когда нужно обязательно явно опре­
делить деструктор класса.
12. Василий хочет записать программный код (реализацию) всех мето­
дов своих классов прямо в объявлении класса. Обсудите достоин­
ства и недостатки такого решения.
*13.Проект. Измените программу так, чтобы по щелчку мышью хищ­
ник переключался в режим «блуждания» — менял направление
движения случайным образом. Повторный щелчок мышью по игро­
вому полю должен возвращать его в режим слежения за мышью.
14. Попробуйте добавить в океан несколько хищников. Что при этом
будет происходить?

Интересные сайты
ru.stackoverflow.com — сайт вопросов и ответов для программистов
learncpp.com — онлайн-учебник по языку C++

141
2 Программирование на языках C++ и C#

§17
Взаимодействие объектов
Ключевые слова:
• столкновения • итератор
• «мёртвые» объекты • преобразование типов

Столкновения
Давайте подумаем, а зачем нам вообще нужен класс Океан («игровой
мир»). Если он просто хранит указатели на все объекты, то особой
необходимости в нём нет — можно использовать обычный вектор.
Вспомним, что наши объекты должны взаимодействовать друг с дру­
гом. Например, хищник ест рыб, а рыбы едят траву. Организацию это­
го процесса мы можем поручить классу СОсеап.
Добавим в класс СОсеап два открытых метода, которые обрабатыва­
ют столкновения и их последствия:
class СОсеап
{

public:
void checkcollisions() const;
void removeDead();
};
Константный метод checkcollisions (от англ, «проверить столкно­
вения») проверяет для каждой пары объектов, произошло ли столкно­
вение, а метод removeDead — удаляет из океана мёртвые объекты.
Добавим вызовы этих методов в код метода update:
void СОсеап::update()
{
for( auto pObj: pObjects )
pObj->update();
checkcollisions ();
removeDead();
}
Таким образом, после того как все объекты изменят своё положе­
ние, мы обрабатываем столкновения между ними и удаляем «мёртвые»
объекты.
В методе removeDead какие-то объекты могут быть удалены с поля,
при этом изменится и вектор pObjects. Поэтому метод update нельзя
объявлять константным.
Перед тем как написать код новых методов, нужно решить, кто
(объект-океан или объекты-обитатели) должен уметь «отвечать» на сле­
дующие вопросы.

142
 Взаимодействие объектов §17

• Столкнулся ли объект А с объектом В?

• Что произошло с объектом А при столкновении с объектом В?
Если мы решим, что этим будет заниматься объект-океан, то при
появлении нового типа морских обитателей или нового поведения ста­
рых обитателей нам придётся менять код класса СОсеап. А это непра­
вильно с точки зрения ООП — океан-то не поменялся! Поэтому вполне
разумно передать решение этих вопросов классам объектов, населя­
ющих океан. Отсюда следует, что все объекты — наследники класса
COceanObject — должны иметь два метода:
• метод hasCollisionWith (в переводе с английского — «имеет
столкновение с»), который возвращает логическое значение true,
если этот объект столкнулся с другим объектом, адрес которого
ему передали;
• метод collideWith (в переводе с английского — «столкнуться с»),
в котором описаны изменения, происходящие с этим объектом
при столкновении.
Предполагая, что такие методы есть у базового класса COceanObject,
можно написать код метода checkcollisions:
void СОсеап::checkcollisions() const
{
for( int i = 0; i < pObjects.size(); i++ )
for( int j = i+1; j < pObjects.size(); j++ )
if( pObjects[i]->hasCollisionWith (pObjects[j]) ) {
pObjects[i]->collideWith( pObjects[j] );
pObjects[j]->collideWith ( pObjects [i] );
}
}
Вложенный цикл перебирает все пары объектов. Обратите внимание,
что переменная j внутреннего цикла начинает изменяться со значения
i+1, т. е. рассматриваются все пары объектов с номерами (i, j), для
которых j > i. При этом мы никогда не проверяем столкновение объ­
екта с самим собой (это могло бы произойти при i = j).
Сначала выясняем, было ли столкновение — вызываем метод
hasCollisionWith для первого выбранного объекта (с номером i)
и передаём ему адрес второго выбранного объекта (с номером j).
Если эта функция вернула истинное значение (true), вызываем ме­
тод collideWidth для каждого из объектов (оба могут измениться в
результате столкновения).
Заметьте, что мы применяем проектирование «сверху вниз», методы
hasCollisionWith и collideWidth пока не написаны, а метод
checkcollisions класса СОсеап уже готов.
Ещё один новый метод класса СОсеап, названный removeDead
(в переводе с английского — «удалить мёртвых»), должен удалять из
памяти и из списка pObjects все объекты, которые погибли в резуль­
тате столкновений на очередном интервале моделирования.

143
2 Программирование на языках C++ и C#

Будем считать, что объект сам умеет определять, мёртвый ли он, т. е.

имеет общедоступный метод isDead. Этот метод должен быть у всех
объектов, поэтому объявить его нужно в базовом классе. Метод isDead
вернёт значение true, если требуется удалить объект с игрового поля.
Метод remove De ad перебирает все объекты в списке pObjects:
void COcean::removeDead()
{
for( int i = pObjects.size()-1; i >= 0; i-- )
if( pObjects[i]->isDead() ) {
delete pObjects[i]; // (1)
pObjects.erase ( pObjects.begin ()+i ); // (2)
}
}
Если какой-то объект «мёртв», занятая им память освобождается
(строка 1), и ссылка на него удаляется из списка pObjects (строка 2).
Заметим, что примерно так работает сборщик мусора во многих совре­
менных языках программирования, например в языке Python.
Методу erase в строке 2 передаётся итератор — указатель специ­
ального типа на удаляемый элемент pObjects [i]. Здесь pObjects.
begin () — это итератор, указывающий на первый элемент списка
(он имеет индекс 0). Если добавить к нему значение целочисленной
переменной i, получается указатель на элемент вектора pObjects [i],
который нужно удалить.
Обратите внимание, что перебор массива указателей в цикле выпол­
няется в обратном порядке, от последнего к первому. Если использо­
вать стандартный вариант, когда индекс увеличивается после каждого
шага, то мы без проверки «проскочим» элементы, следующие за уда­
лёнными, и не удалим их, даже если они будут «мёртвыми».
Например, пусть цикл организован так:
for( int i = 0; i < pObjects.size() ; i++ )

Предположим, что элемент с индексом 0 оказался «мёртвым» и был

удалён. При этом на его место встал элемент, который раньше имел
индекс 1, теперь он имеет индекс 0. Но переменная i после первой
итерации будет автоматически увеличена и станет равна 1, поэтому
новый элемент с индексом 0 мы не будем проверять.

Изменение базового класса

Итак, в базовый класс нужно добавить три новых метода:
hasCollisionWith, collideWith и isDead.
Очевидно, что методы collideWith и isDead должны быть вирту­
альным, потому что каждый наследник класса COceanObject может
определять их по-своему.
Добавляем новые методы в секцию public:

144
 Взаимодействие объектов §17

class COceanObject
{

public:

virtual bool isDeadO { return (r == 0); }

bool hasCollisionWith( COceanObject* pOther ) const;
virtual void collideWith( COceanObject* pOther ) {}
};
Мы будем считать, что любой объект-обитатель изображается как
круг, и в поле г хранится радиус этого круга. По умолчанию будем
считать «мёртвым» объект, радиус которого равен нулю. В этом случае
метод is Dead, записанный прямо в объявлении базового класса, воз­
вращает истинное значение. В классе-наследнике этот метод можно пе­
реопределить, так как он объявлен виртуальным.
Метод collideWith принимает один параметр — адрес объекта, с
которым произошло столкновение. Тело метода по умолчанию пустое.
Классы-наследники, которые обрабатывают столкновения с другими
объектами, могут переопределить этот виртуальный метод.
Напомним, что код всех методов, записанных в объявлении класса,
компилятор добавляет прямо в точку вызова, не оформляя его как от­
дельную программу. Хотя при этом выполнение программы немного
ускоряется, размер кода увеличивается. Поэтому рекомендуется приме­
нять этот вариант только для очень коротких методов, длиной в одну-
две строки.
Третий метод, hasCollisionWith, вынесем из описания класса.
В этом случае он будет оформлен как отдельная подпрограмма, а не
включён полностью в код в месте вызова.
bool COceanObject::hasCollisionWith(
COceanObject* pOther ) const
{
double distance = hypot( x - pOther->x, у - pOther->y );
return (distance < r + pOther->r);
}
Здесь проверяется, было ли столкновение двух объектов — текущего
(для которого вызван метод) и второго, адрес которого передан методу
как единственный параметр pOther.
Предполагается, что все объекты изображаются как круги. Расстоя­
ние между базовыми точками объектов (центрами кругов) вычисляем
по теореме Пифагора с помощью функции hypot и записываем в ло­
кальную переменную distance. Функция hasCollisionWith возвраща­
ет истинное значение, если круги пересеклись, т. е. расстояние между
центрами кругов меньше, чем сумма их радиусов.

145
2 Программирование на языках C++ и C#

После этих изменений в классах СОсеап и COceanObject программу

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

Изменение других классов

Для того чтобы объекты реагировали на столкновение, нужно пере­
определить виртуальный метод collideWith в классах-наследниках:
CStone, CGrass, CFish, CHunter. Рассмотрим подробно только одно
взаимодействие: при столкновении хищника (CHunter) и рыбы (CFish)
хищник съедает рыбу, и его размер (радиус) увеличивается. А рыба,
как ни печально, погибает.
Добавим в классы CHunter и CFish метод collideWith, переопреде­
лив метод базового класса с тем же именем:
class CFish: public CMovingObject
{
public:

virtual void collideWith(

COceanObject* pother ) override;
};
class CHunter: public CMovingObject
{
public:

virtual void collideWith(

COceanObject* pother ) override;
};
При кодировании этих методов возникает следующая задача: мы
получили ссылку на другой объект (параметр pother), но это ссылка
на объект базового класса COceanObject. Этой информации мало для
обработки столкновения. Мы договорились, что пока учитываем только
взаимодействие хищника и рыбы, значит, нужно как-то определить,
что хищник столкнулся именно с рыбой, а рыба — с хищником.
Для решения этой задачи будем использовать информацию о типах
данных, доступную во время выполнения программы. По-английски
она называется RTTI‘. Runtime Type Information. С её помощью мож­
но узнать, принадлежит ли переданный адрес объекту класса CFish
или CHunter.
Рассмотрим метод collideWith для хищника. Параметр pother ука­
зывает на объект, с которым столкнулся хищник. Попробуем преоб­
разовать его в указатель на объект класса CFish. Если это удастся, то
второй объект — рыба, а если нет — не рыба.

146
 Взаимодействие объектов §17

void CHunter::collideWith( COceanObject* pother )

{
CFish* pFish = dynamic_cast <CFish*> (pOther); // (1)
if( pFish ) r += 1; // (2)
}
В строке 1 создаётся новая локальная переменная pFish — указа­
тель на объект класса CFish. В неё сразу же записывается начальное
значение. Сразу отметим, что можно было попросить компилятор авто­
матически определить тип этой переменной:
auto pFish = dynamic_cast <CFish*> (pOther);
Давайте разберём это сложное выражение по частям. Запись
dynamic_cast означает «динамическое преобразование типа», т. е. пре­
образование во время выполнения программы. Такое преобразование
применяют тогда1’, когда при компиляции тип переменной ещё неиз­
вестен. Действительно, ведь мы не знаем, на объект какого класса-на­
следника COceanObject будет ссылаться переданный указатель.
В угловых скобках записан тип (CFish*), к которому нужно преоб­
разовать переменную, а далее в круглых скобках — имя самой этой
переменной (pOther).
Если преобразование удалось, в переменную pFish будет записан
адрес, с которым можно работать как с адресом объекта CFish. Если
же объект, на который указывает pOther, — не рыба, в переменную
pFish будет записан нулевой указатель.
В строке 2 мы проверяем значение переменной pFish: если оно
ненулевое, то хищник удачно встретился с рыбой и его радиус увели­
чивается.
Аналогично построим метод collideWith для класса CFish:
void CFish::collideWith( COceanObject* pOther )
{
auto pHunter = dynamic_cast <CHunter*> (pOther);
iff pHunter ) r = 0;
}
Если рыба встретила хищника, её ждёт печальная участь: ради­
ус становится равным нулю, так что она считается мёртвой и бу­
дет удалена из памяти объектом Океан при выполнении метода
removeDead.
Методы collideWith не зря вынесены из классов, хотя они очень
короткие. Дело в том, что оба метода используют как класс CFish,
так и класс CHunter. Поэтому описания обоих классов должно быть
выше кода методов collideWith.

h Если тип переменной, значение которой преобразуется, заранее известен,

используют статическое преобразование (static cast).

147
2 Программирование на языках C++ и C#

Используя этот подход, вы можете самостоятельно добавить в про­

грамму остальные варианты взаимодействия объектов разных классов.
Обратите внимание, что объект Океан ничего «не знает» о том, как
взаимодействуют объекты разных классов, всё определяется методами
collideWith самих объектов. Океан просто организует такое взаимо­
действие, вызывая для всех пар объектов методы hasCollisionWith и
collideWith на каждом интервале моделирования.

«Умные» указатели
Неаккуратное использование указателей в программе может привести
к очень тяжёлым ошибкам, связанным с выделением и освобождением
памяти. К ним относятся:
• обращение по неверному адресу;
• повторное удаление объекта;
• утечка памяти из-за того, что объект не удалён из памяти, а
ссылка на него потеряна.
Для того чтобы избавить программистов от этих проблем, в стан­
дарт С++11 были введены «умные» указатели. «Умный» указатель
типа shared_jptr (от англ, shared pointer — разделяемый указатель)
в любой момент «знает», сколько всего ссылок есть на связанный с
ним объект. Когда такой указатель выходит из области видимости и
удаляется из памяти, счётчик ссылок на этот объект уменьшается на
единицу. Если после этого счётчик ссылок станет равен нулю, объект
становится недоступным, поэтому автоматически удаляется из памяти.
Это значит, что программисту не нужно вручную удалять объект, на
который ссылается «умный» указатель — объект будет удалён именно
тогда, когда станет не нужен.
Для работы с «умными» указателями необходимо подключить биб­
лиотеку memory (в переводе с английского — память):
#include <memory>
«Умный» указатель — это переменная типа shared_ptr:
shared_ptr<COceanObject> рОЬ j ;
В угловых скобках записан тип объектов, на которые может ссылаться
этот указатель. Пока этот указатель пустой, он имеет нулевое значение
и нулевой счётчик ссылок.
Значение, которое записывается в «умный» указатель, обычно стро­
ится с помощью функции make_shared:
pObj = make_shared<CStone>( 100, 100, 8 );
Здесь создаётся новый объект класса CStone, для этого вызывается
конструктор CStone (100, 100, 8). Затем адрес этого объекта записы­
вается в «умный» указатель pObj.

148
 Взаимодействие объектов §17

Можно сразу объявить «умный» указатель и присвоить ему началь­

ное значение:
auto pObj = make_shared<CStone>( 100, 100, 8 );
Служебное слово auto говорит о том, что тип переменной pObj опре­
деляется автоматически, по тому значению, которое ей присваивается.
Метод use_count позволяет узнать значение счётчика, т. е. количест­
во ссылок на объект:
cout << pObj.use_count() << endl;
Для нашего примера программа выведет число 1.
Теперь создадим второй «умный» указатель и присвоим ему значе­
ние первого:
auto pObj2 = pObj;
Если теперь вывести на экран значения счётчиков обоих указателей,
оба они будут равны двум. Это значит, что в программе есть два ука­
зателя на данный объект.
Если один из указателей, pObj или pObj2, выйдет из области види­
мости, счётчик ссылок другого уменьшится на единицу и станет равен
1. Когда удаляется второй указатель, счётчик ссылок становится равен
нулю, и после этого объект автоматически удаляется из памяти.

Применяем «умные» указатели

Сделаем так, чтобы в нашей программе моделирования океана ис­
пользовались только «умные» указатели. В первую очередь вектор
pObjects в классе СОсеап должен теперь состоять из «умных» указа­
телей на объекты-наследники класса COceanObject:
class СОсеап
{
private:
std::vector<std::shared_ptr<COceanObject>> pObjects;

};
В методе addObject тоже нужно перейти на «умные» указатели, ко­
торые строятся с помощью функции make_shared:
void СОсеап::addObject ( objectType type,
int xO, int yO, int rO,
int vO, double courseO )
{
shared_ptr<COceanObject> pNewObj = nullptr;
if( type == STONE )
pNewObj = make_shared<CStone>( xO, yO, rO );

149
2 Программирование на языках C++ и C#

else if( type == GRASS )

pNewObj = make_shared<CGrass>( xO, yO, rO );
else if( type == FISH )
pNewObj = make_shared<CFish>( xO, yO, rO,
vO, courseO );
else /* if ( type == HUNTER ) */
pNewObj = make_shared<CHunter>( xO, yO, rO, vO );
if( pNewObj )
pObjects.push_back( pNewObj );
}
Поскольку объекты, связанные с «умными» указателями, удаляются
из памяти автоматически, деструктор в классе СОсеап уже не нужен,
его можно удалить.
Указатели в нашей программе используются при обработке столкно­
вений. В методах hasCollisionWith и collideWith базового класса
COceanObject и его наследников нужно изменить тип параметров на
«умные указатели»:
class COceanObject
{

bool hasCollisionWith(
std::shared_ptr<COceanObject> pother )
const;
virtual void collideWith(
std::shared_ptr<COceanObject> pother ) {}
};
Тело метода collideWith в каждом классе тоже поменяется, напри­
мер, для класса CFish:
void CFish::collideWith(
shared_ptr<COceanObject> pother )
{
auto pHunter =
dynamic_pointer_cast<CHunter> (pother);
if( pHunter ) r = 0;
}
Обратите внимание, что для преобразования типа «умного» ука­
зателя во время выполнения программы используется функция
dynamic_pointer_cast, а не dynamic_cast, как для обычных указателей.
Заметно, что текст программы стал немного сложнее по сравнению
с предыдущим вариантом. Однако мы получили важное преимущество:
теперь нам не нужно думать о том, как мы будем освобождать выде­
ленную память. Всё произойдёт автоматически и в нужный момент.

150
 Взаимодействие объектов §17

Выводы
• Для того чтобы обрабатывать столкновения, каждый объект дол­
жен иметь два метода. Один определяет факт столкновения с дру­
гим объектом, а второй изменяет объект в результате столкнове­
ния (если нужно).
• Вызов этих методов выполняет главный объект («игровой мир»,
у нас — океан), перебирая во вложенном цикле все возможные
пары разных объектов.
• Удалением «мёртвых» объектов с поля занимается главный объ­
ект. Все классы должны иметь метод, позволяющий определить,
можно ли удалить с поля данный объект.
• Для определения класса объекта по его адресу используется ин­
формация о типах данных, доступная во время выполнения про­
граммы (RTTT. Runtime Type Information).
• Для приведения указателя к другому типу во время выполне­
ния программы применяется оператор dynamic_cast. Если такое
преобразование закончится неудачно, в указатель будет записано
нулевое значение.
• В стандарте С++11 введены «умные» указатели, которые поддер­
живают счётчик ссылок на объект, выделенный в памяти. Когда
счётчик ссылок на какой-то объект становится равен нулю, этот
объект удаляется из памяти автоматически.

Вопросы и задания
1. Предложите какие-нибудь дополнительные свойства и методы, кото­
рые могут быть у объекта Океан (можно вспомнить, как меняется
состояние реального океана). В этом и следующих заданиях исполь­
зуются объекты, приведённые в параграфе.
2. Пётр хочет сделать так, чтобы всеми взаимодействиями объектов
управлял главный объект — «игровой мир». Обсудите достоинства и
недостатки такого решения.
3. Константин написал циклы в методе checkcollisions класса СОсеап
так:
for( int i = 0; i < pObjects.size (); i++ )
for( int j =0; j < pObjects.size(); j++ )

Обсудите достоинства и недостатки этого варианта.

4. Почему метод hasCollisionWith не объявлен виртуальным? В каком
случае его нужно будет объявить виртуальным?
5. Мария забыла написать строку
delete pObjects[i];
в теле метода removeDead класса СОсеап. К каким последствиям это
может привести?

151
2 Программирование на языках C++ и C#

6. Даниил забыл написать строку

pObjects.erase ( pObjects.begin()+i );
в теле метода removeDead класса СОсеап. К каким последствиям
это может привести?
7. Почему, на ваш взгляд, в методах checkcollisions и removeDead
мы не использовали циклы такого вида?
for( auto р: pObjects ) { ... }
8. Можно ли в процедуре removeDead поменять местами следующие
строки?
delete pObjects [i];
pObjects.erase( pObjects.begin ()+i );
Что при этом может произойти?
9. Используя дополнительные источники, выясните, какие ещё типы
«умных» указателей введены в стандарте С++11.
10. Переделайте программу из параграфа так, чтобы она везде ис­
пользовала «умные» указатели вместо обычных.
*11. Проект. Добавьте в модель океана другие взаимодействия между
объектами:
• рыбы едят траву;
• если хищник сталкивается с камнем, его размеры уменьшаются.
*12.Проект. Вместо хищника, который следит за мышью, добавьте в
модель океана несколько хищников, которые двигаются в случай­
ных направлениях.
*13.Проект. Добавьте в модель океана изменения объектов с течени­
ем времени:
• трава растёт (увеличивается в размерах);
• рыбы размножаются (появляются новые рыбы).
**14. Проект. Добавьте в модель океана элементы искусственного
интеллекта:
• рыба, обнаружив траву в некоторой зоне рядом с ней, начинает
двигаться к ближайшей траве;
• почуяв рядом хищника, рыбы «убегают» от него;
• хищник, обнаружив рыб в некоторой зоне рядом с ним, начи­
нает двигаться к ближайшей рыбе; если рядом рыб нет, хищ­
ник двигается в случайном направлении (режим поиска).

Интересные сайты
gamesmaker.ru — сайт о программировании игр на С++
tutorialspoint.com — онлайн-учебники по программированию

152
 Простая программа на C# §18

§18
Простая программа на C#
Ключевые слова:
• RAD-среда • свойство
• среда .NET • событие
• язык C# • обработчик события
• виртуальная машина • компонент
• проект • статический класс
• форма

RAD-среды для разработки программ

Разработка программ для оконных операционных систем до середины
1990-х годов была довольно сложным и утомительным делом. Очень
много усилий уходило на то, чтобы написать команды для создания
интерфейса с пользователем: разместить элементы в окне програм­
мы, правильно подключить обработчики сообщений. Значительную
часть своего времени программист занимался рутинной работой, кото­
рая была слабо связана с решением главной задачи. Поэтому возникла
естественная мысль — автоматизировать описание окон и их элемен­
тов так, чтобы весь интерфейс программы можно было построить без
ручного программирования (с помощью мыши), а человек думал бы о
сути решаемой задачи, т. е. об алгоритмах обработки данных.
Такие системы программирования получили название RAD-cped (от
англ. Rapid Application Development — быстрая разработка приложений).
Разработка программы в RAD-системе состоит из следующих этапов:
• создание формы (так называют шаблон, по которому строится
окно программы или диалога); при этом минимальный код добав­
ляется автоматически, и сразу получается работоспособная про­
грамма;
• расстановка на форме с помощью мыши элементов интерфейса
(полей ввода, кнопок, списков) и настройка их свойств;
• создание обработчиков событий:
• программирование алгоритмов обработки данных, которые выпол­
няются при вызове обработчиков событий.
Обратите внимание, что при программировании в RAD-средах обыч­
но говорят не об обработчиках сообщений, а об обработчиках собы­
тий. Событием в программе может быть не только нажатие клавиши
или щелчок мышью, но и перемещение окна, изменение его размеров,
начало и окончание выполнения расчётов и т. д.
Некоторые сообщения, полученные от операционной системы, библи­
отека RAD-среды «транслирует» (переводит) в соответствующие собы­
тия, а некоторые — нет. Более того, программист может вводить свои
события и определять процедуры для их обработки.

153
2 Программирование на языках C++ и C#

Одной из первых сред быстрой разработки стала среда Delphi, раз­

работанная фирмой Borland в 1994 году. Существует свободная RAD-
среда Lazarus (lazarus.freepascal.org), которая во многом аналогична
Delphi, но позволяет создавать кроссплатформенные программы (ра­
ботающие в разных операционных системах: Windows, Linux, macOS).
Как правило, в RAD-средах используется объектно-ориентированный
стиль программирования.
Самая известная современная профессиональная RAD-система —
Microsoft Visual Studio — поддерживает несколько языков программи­
рования. Одна из её версий, Visual Studio Community, распространяет­
ся бесплатно.
RAD-среды позволили существенно сократить время разработки про­
грамм. Однако нужно помнить, что любой инструмент — это только
инструмент, который можно использовать грамотно или безграмотно.
Использование среды RAD само по себе не гарантирует, что у вас ав­
томатически получится хорошая программа с хорошим пользователь­
ским интерфейсом.

Язык C# и среда .NET

В этом и следующих параграфах мы познакомимся с программирова­
нием в RAD-средах на примере бесплатной среды Visual Studio Com­
munity^ для операционной системы Windows. Все основные приёмы,
которые вы изучите, применимы также и в других средах визуальной
разработки программ, например в Delphi и Lazarus.
Для выполнения примеров мы будем использовать язык C# (читает­
ся как «Си шарп»), разработанный компанией Microsoft. Он опирается
на многие идеи языков С и C++. Поэтому правила записи команд в
языках C# и C++ очень похожи.
С помощью языка C# создаются программы для платформы .NET
(читается как «дот нет», от англ, dot — точка), разработанной ком­
панией Microsoft для операционной системы Windows. Программы на
C# компилируются не в команды процессора, а в код на специальном
языке CIL (Common Intermediate Language — «общий промежуточ­
ный язык»). Этот код выполняет специальная программа — виртуаль­
ная машина среды .NET, которая называется CLR (Common Language
Runtime — общая среда выполнения для языков).
В код на языке CIL можно скомпилировать программы на языках
C++, С#, Visual Basic .NET, F#, PascalABC.NET и др. Это позволяет
объединять в одной программе модули, написанные на разных языках.
Однако нужно помнить, что для выполнения таких программ необ­
ходимо установить среду .NET (англ. .NET Framework), причём опре-
Добавка Community (в переводе с английского — сообщество) указывает на
бесплатность этой версии. Скачать среду можно на сайте visualstudio.microsoft.
com/ru/vs/community/.

154
 Простая программа на C# §18

делённой версии, для которой написана программа. Установочные фай­

лы всех версий среды .NET для Windows можно свободно загрузить с
сайта компании Microsoft.
В UNIX-подобных операционных системах (Linux, macOS) програм­
мы, использующие .NET, могут выполняться в среде Mono.

Проект в C#
Разработка программы на C# начинается с создания проекта. Так на­
зывается набор файлов, из которых компилятор строит исполняемый
файл программы. В состав проекта на языке C# обычно входят:
• файл проекта с расширением .csproj (от англ. CSharp Project —
проект С#), в котором содержится описание проекта в текстовом
формате XML;
• модули на языке C# (файлы с расширением . cs), из которых
состоит программа;
• файлы ресурсов (с расширением . resx), содержащие, например,
строки для перевода сообщений программы на другие языки.
Проекты в Visual Studio объединяются в решения (англ, solution).
В состав решения может быть включено несколько проектов, напри­
мер: программа для пользователя разрабатываемой системы (первый
проект), программа для администратора (второй проект), средства раз­
работчика и т. п.
Основная программа проекта на C# находится в файле Program.cs
(здесь и далее указываются имена файлов по умолчанию).
В программе с графическим интерфейсом может быть несколько
окон, которые называют формами. С каждой формой связана пара
файлов с расширением .cs. В одном из них хранятся данные о рас­
положении и свойствах элементов интерфейса. В названиях этих фай­
лов есть слово Designer, например Forml.Designer.cs. Второй файл
(Forml. cs) содержит программный код обработчиков событий, связан­
ных с этой формой.
Одна из форм — главная, она появляется на экране при запуске
программы. Когда пользователь закрывает главную форму, работа про­
граммы завершается.

Первый проект
Для создания проекта с графическим интерфейсом нужно выбрать
пункт меню Файл — Создать проект и в появившемся окне отметить
вариант Приложение Windows Forms. При этом автоматически созда­
ется работоспособная программа, которую сразу же можно запустить
на выполнение клавишей F5 (рис. 2.6). Все приведённые далее снимки
экрана («скриншоты») были сделаны в среде Visual Studio Community
2017.

155
 M WindowsFormsAppI - Microsoft Visual Studio & Быстрый запуск (Ctrl+Q) P — Я X

Программирование на языках C++

Файл Правка Вид Проект Сборка Отладка Команда Средства Тестирование Анализ Константин Поляков
Окно Справка

© ’ 13 ’ - И «I- Debug ’ АпУсри ’ ► ПУСК ' & - - “

Панель элементов ? X Form1.cs [Конструктор]*-» x Обозреватель решений ¥X

Поиск по панели элементов fi * й Й ’ Ь - П с ’’
О Все формы Windows Forms л Forml
Обозреватель решений - поиск (Ctrl + fi »
j Стандартные элементы упра...
GD Решение "WindowsFormsAppI" (проект
Указатель
j 0 WindowsFormsAppI
И Button
0 CheckBox
Л* Properties
■ ■ Ссылки
g= CheckedListBox QForm1.cs
’[З ComboBox ► l3 Form1.Designer.cs
s DateTimePicker l3 Forml.resx

Д Label с* Program.es

A LinkLabel
ListBox ►
5“ ListView Обозреватель реш... Team Explorer— П..
MaskedTextBox
Свойства ▼ ? X
g] MonthCalendar
Form1.cs Свойства файла
Notifylcon

[Tg NumericUpDown
□ Дополнительно ж
Q PictureBox Действие при сбо Компилировать I
ProgressBar Копировать в вых Не копировать
О RadioButton Пользовательски w
Sa RichTextBox
Дополнительно
В TextBox ж

Обозреватель.. Панель элемен... «

:15,15 £-281x234 Добавить в систему уязвлений в^рси^ми -

Рис. 2.6
 Простая программа на C# §18

В верхней части окна Visual Studio (см. рис. 2.6) расположены меню
и панель инструментов — кнопки для быстрого вызова команд. В ра­
бочей области размещаются несколько окон, их состав может менять­
ся. Мы будем использовать следующие окна:
• Панель элементов;
• Обозреватель решений;
• Свойства;
• Конструктор формы;
• окно исходного кода.
На Панели элементов размещены готовые объекты (кнопки, поля
ввода, списки и т. п.), которые можно добавлять на формы с помощью
мыши.
Обозреватель решений позволяет выбрать для редактирования любой
файл проекта (решения).
Вся программа на C# состоит из объектов. Их свойства настраива­
ются с помощью окна Свойства. В нём две основные вкладки:
* Гл! Свойства, где можно изменить общедоступные свойства объ-
-T=J екта,
• ж События, где из списка подходящих методов выбираются об-
работники событий, связанных с объектом.
Форма — это тоже объект в программе. На форме можно распола­
гать другие объекты, обеспечивающие интерфейс с пользователем, —
кнопки, поля ввода, метки и т. п. Они называются компонентами
или элементами.
После двойного щелчка мышью по названию файла Forml. cs в окне
Обозреватель решений открывается Конструктор формы. В этом ре­
жиме можно мышью перетаскивать компоненты с Панели элементов
на форму, изменять их размеры и расположение, настраивать свойст­
ва. Таким образом, интерфейс программы полностью строится с помо­
щью мыши.
При нажатии клавиши F7 мы увидим в текстовом редакторе содер­
жимое файла Forml.cs, где хранятся обработчики событий формы1}:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using Systern.Windows.Forms;
namespace WindowsFormsAppl {
public partial class Forml: Form {
С помощью сочетания клавиш Shift+F7 можно перейти обратно в конструктор
формы.

157
2 Программирование на языках C++ и C#

public Forml () {
InitializeComponent();
}
}
}
Сначала с помощью команды using подключаются пространства
имён среды .NET (вспомните подключение пространства имён std в
C++). Например, если убрать строку
using System.Windows.Forms;
то вместо Form придётся писать
System.Windows.Forms.Form,
полностью указывая пространство имён, в котором определён класс
Form.
Затем вводится пространство имён проекта с именем WindowsFormsAppl
(такое имя имеет проект по умолчанию):
namespace WindowsFormsAppl {

}
В этом пространстве имён определяется новый класс Forml, который
является наследником базового класса Form:
public partial class Forml: Form {

}
Описатель public обозначает, что к объектам этого класса могут
обращаться и другие классы, а описатель partial указывает на то,
что класс Forml описывается по частям в разных файлах.
Единственный метод, определённый в классе Forml, — это конструк­
тор, который сводится к вызову процедуры InitializeComponent:
public Forml() { InitializeComponent(); }
Процедура InitializeComponent устанавливает свойства формы и
расположенных на ней элементов. Она находится во втором файле,
связанном с формой, — Forml. Designer. cs, который строится авто­
матически. Менять его вручную не рекомендуется, но посмотреть инте­
ресно и полезно.
Основная программа (точка входа) расположена в файле Program.cs.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace WindowsFormsAppl {
static class Program {

158
 Простая программа на C# §18

static void Main() {

Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault ( false );
Application.Run( new Forml() );
}
}
}
В уже знакомом нам пространстве имён проекта WindowsFormsAppl
создаётся статический (static) класс Program. Статический класс —
это класс особого типа, для которого нельзя создать экземпляр. Он со­
держит только методы обработки внешних данных, у него нет внут­
ренних переменных (нет состояния). Таким образом, статический
класс — это просто набор функций.
Все методы статического класса также объявляются статическими.
В нашем случае — это единственный метод с именем Main — точка
входа, с которой начинается выполнение основной программы.
В методе Main выполняются начальные установки для объекта (ста­
тического класса) Application. Это объект-приложение, самый глав­
ный объект в нашей программе. В последней строке вызывается метод
Run, запускающий цикл обработки сообщений. Этому методу передаёт­
ся ссылка на главную форму, которая появляется на экране при запу­
ске программы1). В данном случае главная форма — это новая форма
класса Forml, созданная с помощью оператора new.

Свойства объектов
Панель Свойства позволяет просматривать и изменять свойства и
обработчики событий для выделенного объекта, например для формы
(рис. 2.7). _____________________
Свойства ▼ X

Forml System.Windows.Forms.Form

S Padding 0; 0; 0; 0
RightToLeft No
RightToLeftLayout False
Showicon True
ShowInTaskbar True
Size 351; 213
Width 351
Height 213 I
SizeGripStyle Auto
Star Position WindowsDefaultLocatiU
Size
Размер данного элемента управления
в пикселях.

Рис. 2.7
Отметим, что цикл обработки сообщений скрыт внутри метода Run, так что здесь
тоже использован принцип инкапсуляции (скрытия внутреннего устройства).

159
2 Программирование на языках C++ и C#

Можно заметить, что при изменении границ формы с помощью

мыши изменяются её свойства Width (в переводе с английского — ши­
рина) и Height {высота), объединённые в группу Size (размер). Эти
величины можно изменить и с клавиатуры, вводя новые значения в
соответствующие области на панели Свойства. При этом размеры фор­
мы также меняются.
Свойство Name (в переводе с английского — имя) — это название
объекта-формы в программе. В имени можно использовать только
латинские буквы, цифры и знаки подчёркивания.
Если изменить имя формы в окне Свойства, скажем, на MainForm,
то это название автоматически изменится и в тексте модуля этой фор­
мы. Более того, название класса в файле Forml. Designer. cs тоже сра­
зу изменится на MainForm. Таким образом, многие изменения вносятся
в код программы автоматически.
Перечислим ещё некоторые важные свойства формы, с которыми
интересно поработать:
• Text — текст в заголовке окна;
• BackColor — цвет рабочей области;
• Font — шрифт надписей.
Установленные вами свойства формы Forml автоматически сохра­
няются в файле Forml. Designer. cs. Там находится код метода
InitializeComponent, который вызывается при запуске программы и
выполняет все начальные установки. Например, в нём можно найти
такие строки:
this.Clientsize = new System.Drawing.Size(800, 600);
this.Name = "MainForm";
this.Text = "Первая программа";
Слово this (в переводе с английского — этот) — это ссылка на
саму форму. Все свойства, записанные через точку после this, — это
свойства формы. В первой строке задаются размеры формы (свойство
Clientsize), во второй — имя формы в программе (свойство Name), в
третьей — текст в заголовке окна (свойство Text).

Обработчики событий

На вкладке ' События в окне Свойства (рис. 2.8) перечислены все

события, которые может обрабатывать форма.
Чтобы создать обработчик, нужно дважды щёлкнуть мышью на
поле справа от названия события. При этом открывается окно ре­
дактора и в текст модуля автоматически добавляется пустой обработ­
чик события (шаблон), в который остаётся только вставить нужные
команды.

160
 Простая программа на C# §18

Свойства ~ х
MainForm System.Windows.Forms.Form

si!®
DragLeave
DragOver
EnabledChanged
Enter
FontChanged
ForeColorChanged
FormClosed_______
FormClosin*
GiveFeedback
HelpButtonClicked
HelpRequested

FormClosing
Возникает при каждом завершении работы
с формой до того, как форма была закрыта...

Рис. 2.8

Рассмотрим простой пример. Вы знаете, что многие программы

запрашивают подтверждение, когда пользователь завершает их рабо­
ту. При этом происходит событие, которое называется Закрытие фор­
мы (FormClosing). В обработчике этого события мы можем вывести на
экран сообщение для пользователя, получить его ответ и, если нужно,
отменить закрытие окна.
Для создания обработчика выполним двойной щелчок мышью на
поле справа от названия события FormClosing. В результате в файле
Forml. cs создаётся шаблон обработчика:
private void MainForm_FormClosing (
object sender, FormClosingEventArgs e )
{

}
Это закрытый метод (private), который может вызывать только сама
форма.
Как видно из заголовка процедуры, в обработчик передаются два
параметра:
• sender — ссылка на объект, от которого пришло сообщение о
событии (в данном случае такой объект — это сама форма);
• е — изменяемый объект, с помощью которого можно разрешить
или запретить закрытие формы.
Установив значение поля е.Cancel равным true («да»), мы отме­
няем команду на закрытие формы. Значение false, которое записа­
но по умолчанию, разрешает закрыть форму и завершить работу про­
граммы.

161
2 Программирование на языках C++ и C#

Для того чтобы решить вопрос о закрытии окна, нужно задать поль­
зователю вопрос и получить на него ответ. В библиотеке C# есть класс
MessageBox, который выводит на экран диалоговое окно с нескольки­
ми кнопками (рис. 2.9) и возвращает ответ пользователя — код нажа­
той кнопки.
Подтверждение S3

о Вы действительно хотите выйти из программы?

I Да I I Нет I
Рис. 2.9

В тело обработчика добавим условный оператор, который присвоит

свойству е.Cancel значение true, если пользователь подтвердит выход
из программы:
private void MainForm_FormClosing(
object sender, FormClosingEventArgs e)
{
DialogResult result;
result = MessageBox.Show(
"Вы действительно хотите выйти из программы?",
"Подтверждение",
MessageBoxButtons.YesNo,
MessageBoxIcon.Question );
if ( result == DialogResult.No )
e.Cancel = true;
}
Здесь вызывается метод MessageBox. Show, и его результат записы­
вается в переменную result типа DialogResult. Если это значение
совпадает с константой DialogResult.No (т. е. пользователь нажал
кнопку «Нет»), в свойство изменяемого параметра е.Cancel записыва­
ется значение true. В этом случае команда закрытия окна отменяется,
иначе (при подтверждении выхода) программа завершается.
Разберём подробно вызов метода MessageBox. Show. Ему передаются
несколько аргументов:
• сообщение пользователю ("Вы действительно хотите выйти из про­
граммы? ”);
• заголовок окна ("Подтверждение");
• набор кнопок, которые появляются под текстом; в нашем слу­
чае это кнопки «Да» и «Нет», обозначенные константой YesNo из
класса MessageBoxButtons;

162
 Простая программа на C#

• значение перечисляемого типа MessageBoxIcon, определяющее тип

сообщения и рисунок слева от текста:
— Question — вопрос;
— Warning — предупреждение;
— Information — информация;
— Error — сообщение об ошибке.
Итак, мы построили работоспособную программу с графическим ин­
терфейсом на C# и познакомились со средой Visual Studio. В следую­
щем параграфе вы узнаете, как работать с компонентами.

Выводы
• Для быстрой разработки программ применяют системы визуаль­
ного программирования, в которых интерфейс строится без «руч­
ного» написания программного кода. Как правило, в них исполь­
зуется объектно-ориентированный стиль программирования.
• Программы на языке C# компилируются не в коды команд про­
цессора, а в программы на промежуточном языке CIL. Программу
на языке CIL выполняет виртуальная машина среды .NET.
• Проект — это набор файлов, которые используются для сборки
исполняемой программы (файла с расширением .ехе).
• В программе с графическим интерфейсом может быть несколько
окон, которые называют формами. С каждой формой связаны два
файла, один из которых (. Designer. cs) строится автоматически.
• Готовые объекты, которые можно использовать в программе (в том
числе кнопки, поля ввода, надписи и т. п.), называются компо­
нентами или элементами.
• Интерфейс программы на C# можно строить с помощью мыши.
• В окне Свойства можно изменить свойства выделенного объекта
и назначить обработчики связанных с объектом событий.

Вопросы и задания
©
1. Какие причины сделали необходимым создание сред быстрой разра­
ботки программ? В чём достоинства этих сред?
2. Чем отличается разработка программ в RAD-среде от использования
классических сред программирования?
3. Какие достоинства и недостатки, на ваш взгляд, имеют программы,
написанные для среды .NET?
4. В каком смысле используется термин «проект» в программирова­
нии?
5. Из каких файлов состоит проект на языке С#?
6. Сравните термины «проект» и «решение» {solution).
7. Что такое форма? Почему для описания формы в Visual Studio
используются два файла?

163
2 Программирование на языках C++ и C#

8. Покажите, что программа, написанная с помощью Visual Studio,

состоит из объектов.
9. Где расположена основная программа (точка входа) в проекте
Visual Studio на языке С#?
10. Почему в основной программе не виден цикл обработки сообщений?
11. Назовите некоторые важнейшие свойства формы. Какими способами
можно их изменять?
12. Приведите примеры автоматического построения и изменения кода
в RAD-среде.
13. Как создать новый обработчик события? Проверьте, можно ли ввес­
ти текст обработчика вручную.
14. Что означает параметр sender, который передаётся в обработчик
события? В каких случаях он может понадобиться?
15. Предположите, как можно вывести сообщение об ошибке на экран.
Проверьте вашу догадку экспериментально.
16. Попробуйте изменить какие-нибудь свойства формы, построив
обработчик ещё одного события (например: Shown — вывод формы
на экран; Click — щелчок мышью; Resize — изменение размеров).
17. Выясните, какие изменения вносятся автоматически в файл
. Designer, cs при добавлении обработчика события.

Интересные сайты
visualstudio.com/ru/vs/community/ — бесплатная среда разработки
Visual Studio Community
docs.microsoft.com/ru-ru/dotnet/csharp/ — руководство по языку C#
от компании Microsoft
bit.ly/2HnSmJo — учебный курс по языку C# от компании Micro­
soft

§19
Использование компонентов
Ключевые слова'.
• компонент • поле ввода
• свойство • метка
• событие • статический метод
• обработчик события • обработка ошибок
• родительский объект • исключение
• дочерний объект

В Visual Studio существует Панель элементов — библиотека готовых

объектов (компонентов), которые можно добавить в свою программу,
просто перетащив их мышью на форму.

164
 Использование компонентов §19

Компоненты разбиты на группы. Мы будем использовать компо­

ненты из групп Стандартные элементы, Контейнеры и Диалоговые
окна. Если задержать мышь над значком компонента, в тексте всплы­
вающей подсказки можно прочитать его краткое описание.

Программа для просмотра рисунков

Используя готовые компоненты, мы построим простую программу для
просмотра рисунков.
В верхней части окна программы разместим кнопку для загрузки
файла и флажок, который изменяет масштаб рисунка так, чтобы рису­
нок вписывался в окно и был полностью виден (рис. 2.10 и см. цвет­
ной рисунок на обороте обложки).
Флажок Панель
CheckBoxV Panel

Кнопка
Button

Рисунок
PictureBox

Рис. 2.10

Создадим новый проект (как в предыдущем параграфе), изменим

имя формы (свойство Name) на MainForm, а её заголовок (свойство
Text) — на Просмотр рисунков.
Добавим на форму панель — компонент □ Panel из группы Кон­
тейнеры. Для этого можно перетащить кнопку □ Panel на форму или
щёлкнуть по этой кнопке и нарисовать на форме прямоугольник, огра­
ничивающий панель. Для изменения размеров панели перетащите мар­
керы на её границах. Можно также изменить значения свойств Width
и Height на панели Свойства.
Панель можно перетаскивать по форме мышью за значок Е. Нам
нужно, чтобы панель была всё время прижата к верхней границе
окна, а её ширина должна быть равна ширине окна. Для того чтобы
обеспечить такое поведение, установим свойство Dock (по-английски —
состыковать) равным Тор (верх).
На панели нужно разместить кнопку (компонент ® Button) и фла­
жок (компонент CheckBox) — рис. 2.11.

165
2 Программирование на языках C++ и C#

На кнопке должна быть надпись Открыть файл (свойство Text), а

справа от флажка — текст По размерам окна (это свойство компонента
CheckBox тоже называется Text).

Рис. 2.11
Размеры и расположение компонентов изменяются с помощью
мыши. Имена компонентов (свойства Name) тоже можно заменить на
более понятные, например на openBtn и sizeCb.
Если теперь заглянуть внутрь файла Forml. Designer. cs, мы уви­
дим, что в состав класса MainForm добавлены новые элементы:
private System.Windows.Forms.Panel panell;
private System.Windows.Forms.Button openBtn;
private System.Windows.Forms.CheckBox sizeCb;
а в методе InitalizeComponent они создаются:
this.panell = new System.Windows.Forms.Panel();
this.openBtn = new System.Windows.Forms.Button();
this.sizeCb = new System.Windows.Forms.CheckBox();
Слово this в методе формы — это ссылка на саму форму, а запись
this.panell говорит о том, что панель (как и другие компоненты)
принадлежит форме.
Компоненты на форме связаны отношениями «родитель — пото­
мок». Главный объект — это форма MainForm. Она является роди­
тельским объектом для панели panell, а панель — дочерним ком­
понентом для формы. Это означает, что при перемещении формы
панель перемещается вместе с ней. Кроме того, «родитель» отвечает
за прорисовку всех дочерних компонентов на экране. В свою очередь,
панель — это родительский объект для кнопки openBtn и флажка
sizeCb.
Теперь добавим на форму специальный компонент Ei PictureBox,
который «умеет» выводить рисунки различных форматов. Для того
чтобы он заполнял всё свободное пространство формы (кроме панели),
для свойства Dock выберем значение Fill (по-английски — запол­
нить).

166
 Использование компонентов §19

Изменим название компонента PictureBox на img. Для него, как и

для панели panel 1, родительский объект — это сама форма MainForm.
Иерархия связей «родитель — потомок» для нашей формы показана
на рис. 2.12.

Рис. 2.12
Остаётся запрограммировать два действия:
• выбор файла и его загрузку в компонент img;
• подгонку размера рисунка под размер формы (при включённом
флажке орепСЬ).
К счастью, для этого достаточно использовать готовые возможности
компонентов библиотеки языка С#.
В группе Диалоговые окна есть компонент для выбора файла, он
называется |у] OpenFileDialog. Перетащим его в любое место формы.
Это невизуальный компонент — его не будет видно во время выпол­
нения программы. Поэтому он добавляется не на форму, а в нижнюю
часть окна конструктора.
Для краткости изменим название компонента на openDlg и очи­
стим свойство FileName (имя файла по умолчанию). В свойство Filter
запишем такую строку:
"Рисунки|*.jpg;*.jpeg;*.gif;*.png;*.bmp"
Это фильтр для отбора файлов: файлы, не подходящие ни под одну из
масок, будут скрыты. В данном случае нас интересуют только файлы
с указанными расширениями. Слева от символа «|» записано название
этого фильтра (любой текст).
Выбор файла нужно выполнять тогда, когда пользователь щёлкнет
по кнопке openBtn. Щелчок по кнопке — это событие, которое назы­
вается Click. Для того чтобы добавить обработчик этого события, нуж­
но выделить кнопку, перейти на вкладку [jFj События в окне Свойст­
ва и выполнить двойной щелчок в поле справа от названия события
Click. После этого откроется окно с шаблоном обработчика, который
был создан автоматически. Тело процедуры-обработчика пока пустое.
Запишем в него команды
if( openDlg.ShowDialog() == DialogResult.OK )
img.Image = new Bitmap( openDlg.FileName );
В этих двух строках происходит довольно много операций, которые
скрыты за вызовами готовых методов:

167
2 Программирование на языках C++ и C#

1) вызывается метод ShowDialog — пользователь увидит стандарт­

ный диалог выбора файла;
2) если результат работы метода ShowDialog равен значению, обо­
значенному как DialogResult.ОК, это означает, что пользова­
тель успешно выбрал файл; при этом имя выбранного файла
можно получить через свойство FileName объекта-диалога;
3) в памяти создаётся новый объект класса Bitmap (по-английски
bitmap — битовая карта, рисунок); в него загружается изобра­
жение из выбранного файла (openDlg. FileName);
4) адрес нового объекта присваивается свойству Image компонента
img; при этом рисунок сразу загружается в компонент, и изо­
бражение на форме обновляется.
Сейчас уже можно запустить программу и проверить, как работает
загрузка файлов.
Обратите внимание, что сейчас изображение выводится с исходными
размерами независимо от размера окна. Флажок По размерам окна мож­
но включать и выключать, но на работу программы он никак не влияет.
Изменить масштаб изображения можно с помощью свойства
SizeMode (режим подгонки размера), которое есть у всех компонентов
класса PictureBox, в том числе и у нашего компонента img. Если это­
му свойству присвоить значение Zoom, компонент сам выполнит под­
гонку размеров рисунка под размер области, которую он занимает. По
умолчанию установлен режим Normal — не изменять размеры.
Переключение режима вывода рисунка будем выполнять при изме­
нении состояния флажка sizeCb. У него есть свойство Checked (в пе­
реводе с английского — отмечен) — логическое значение, определяю­
щее состояние компонента. Если флажок включён, это свойство равно
true, если выключен, то false.
При изменении свойства Checked происходит событие CheckedChanged
(в переводе с английского — изменение свойства Checked). В обработ­
чике этого события нужно устанавливать режим вывода рисунка в за­
висимости от состояния флажка. Создадим шаблон обработчика (так
же, как мы делали раньше) и добавим в него следующий код:
if( sizeCb.Checked )
img.SizeMode = PictureBoxSizeMode.Zoom;
else img.SizeMode = PictureBoxSizeMode.Normal;
Режимы Zoom и Normal относятся к стандартному перечисляемому
типу PictureBoxSizeMode.
Теперь программа полностью готова. Отметим следующие важные
особенности:
• программа целиком состоит из объектов и основана на принципах
объектно-ориентированного программирования;
• мы построили полезную программу практически без программиро­
вания;

168
 Использование компонентов

• использование готовых компонентов скрывает от нас сложность

выполняемых операций, поэтому скорость разработки программ
значительно повышается.
Ввод и вывод данных
Во многих программах нужно, чтобы пользователь вводил тексто­
вую или числовую информацию. Обычно для ввода данных применяют
поля ввода — компоненты класса ® TextBox. Введённую символьную
строку можно получить через свойство Text (по-английски — текст).
Шрифт текста в поле ввода задаётся сложным свойством Font (шрифт).
Это объект, у которого есть свои «подсвойства», их список можно уви­
деть, если щёлкнуть по значку Е слева от названия свойства. Например,
под свойство Size — это размер шрифта в пунктах, а логические значе­
ния Bold (жирный), Italic (курсив) и Underline (подчёркнутый) опреде­
ляют стиль шрифта: каждое из них может быть истинно или ложно.
Если вручную установить шрифт для какого-то объекта, например
для формы, все дочерние компоненты по умолчанию будут иметь та­
кой же шрифт.
Программа, которую мы напишем, будет строить шестнадцатеричный
код цвета, используемый в языке HTML, по значениям красной, зелё­
ной и синей составляющих цвета в модели RGB (см. § 9) — рис. 2.12.
Поле ввода rEdit

Рис. 2.13
На форме расположены:
• три поля ввода (в них пользователь может задать значения со­
ставляющих цвета в модели RGB);
• прямоугольная панель (компонент Panel), цвет которой изменяет­
ся согласно введённым значениям;
• несколько меток (компонентов Label).
Метки — это надписи, которые пользователь не может редакти­
ровать. Однако из программы можно изменять их содержимое через
свойство Text.
Для того чтобы пользователь не мог изменить размеры окна про­
граммы (в данной задаче это не нужно!), мы установим свойство фор­
мы FormBorderStyle (по-английски — стиль границы формы), равное
FixedSingle (фиксированная, одиночная).

169
2 Программирование на языках C++ и C#

Во время работы программы будут использоваться поля ввода rEdit,

gEdit и bEdit, метка rgbLabel для вывода кода цвета, и панель
rgbPanel. Начальные значения полей ввода — любые целые числа от
О до 255 (их нужно записывать в свойство Text).
При изменении содержимого любого из трёх полей ввода будем вы­
водить HTML-код полученного цвета в свойство Text метки rgbLabel,
а также устанавливать новый цвет заливки панели rgbPanel.
Событие, которое происходит при изменении текста в поле ввода,
называется TextChanged. Так как при изменении любого из трёх по­
лей нужно выполнить одинаковые действия, для всех полей ввода мы
установим один и тот же обработчик события TextChanged. Удерживая
клавишу Shift, выделим щелчками мышью три поля ввода. После это­
го на вкладке [У События окна Свойства двойным щелчком мышью
создадим обработчик события TextChanged. Этот обработчик может вы­
глядеть так:
private void rEdit_TextChanged(
object sender, EventArgs e )
{
int r, g, b;
r = int.Parse( rEdit.Text );
g = int.Parse( gEdit.Text );
b = int.Parse( bEdit.Text );
rgbPanel.BackColor = Color.FromArgb(r, g, b);
rgbLabel.Text = "#" + r.ToString( "X2" )
+ g.ToString( "X2" ) + b.ToString( "X2" );
}
Сначала значения составляющих цвета переводятся из символьного
вида в числовой и записываются в переменные г, g и Ь. Это делает
метод Parse (в переводе с английского — разбор строки) класса int
(целые числа). Возможно, вы заметили, что обычно метод вызывается
для какого-то объекта, а здесь слева от точки записано название типа
данных (класса) int. Это особый метод, который называется методом
класса или статическим методом.
У панели есть свойство BackColor, которое задаёт цвет заливки вну­
тренней области. Нужный цвет определяется по значениям составляю­
щих модели RGB с помощью метода FromArgb класса Color.
В последней строке обработчика события строится символьная стро­
ка, содержащая шестнадцатеричный код цвета. Для перевода значений
в шестнадцатеричную систему применяем метод ToString (в переводе
с английского — в строку), второй аргумент "Х2" указывает на то,
что число нужно записать как два знака в шестнадцатеричной системе
счисления ("X").
Вы можете заметить, что сразу после запуска программы код цвета
в метке rgbLabel и цвет панели rgbPanel не соответствуют значениям

170
 Использование компонентов §19

составляющих цвета в полях ввода. Дело в том, что обновление мет­

ки и цвета панели не произойдёт, пока не будет вызван обработчик
TextChanged.
Чтобы исправить ситуацию, нужно при запуске программы сымити­
ровать изменение одного из полей ввода. Для этого мы используем со­
бытие Load, которое происходит сразу после создания формы, но до
того, как она появится на экране. Выделим форму и создадим (так
же, как мы делали раньше) обработчик события Load. В нём вызовем
готовый обработчик TextChanged:
private void MainForm_Load ( object sender, EventArgs e )
{
rEdit_TextChanged( rEdit, e );
}
Первый аргумент, который передаётся любому обработчику, — это
ссылка на объект-источник события. Здесь источником события «на­
значено» поле ввода rEdit, но вместо него можно было использовать
ссылку на любой компонент или даже нулевой объект null. По­
скольку значения параметров в нашем обработчике TextChanged не
используются, можно передать ему два нулевых объекта:
rEdit_TextChanged ( null, null );

Обработка ошибок
Если в предыдущей программе пользователь введёт не цифры, а другие
символы (или пустую строку), программа выдаст сообщение о необра­
ботанной ошибке и предложит завершить работу. Хорошая программа
никогда не должна завершаться аварийно. Для этого все ошибки, ко­
торые можно предусмотреть, надо обрабатывать в программе.
В современных языках программирования для обработки ошибок
применяют механизм исключений. В языке C# все «опасные» участки
кода (на которых может возникнуть ошибка) нужно поместить в блок
try — catch:
try {
// "опасные" команды
}
catch {
// обработка ошибки
}
Слово try в переводе с английского означает «попытаться», catch —
«поймать». В данном случае мы ловим исключения (исключительные
или ошибочные, непредвиденные ситуации). Программа выполнит блок
catch только тогда, когда между try и catch произойдёт ошибка.

171
2 Программирование на языках C++ и C#

В нашей программе «опасные» команды — это операторы преобразо­

вания данных из текста в числа (вызовы метода int. Parse). Вот улуч­
шенный обработчик с защитой от неправильного ввода:
try {
г = int.Parse( rEdit.Text );
g = int.Parse( gEdit.Text );
b = int.Parse( bEdit.Text );
rgbLabel.Text = + r.ToString ( "X2" )
+ g.ToString( "X2" ) + b.ToString( "X2" );
rgbPanel.BackColor = Color.FromArgb(r, g, b);
}
catch {
rgbLabel.Text =
rgbPanel.BackColor = Systemcolors.Control;
}
В случае ошибки мы выведем вместо кода цвета знак вопроса, а
панель будет невидима — её цвет будет совпадать со стандартным цве­
том элементов управления операционной системы; этот цвет обознача­
ется как SystemColors.Control.
Существует и другой способ защиты от неверных входных дан­
ных — блокировать при вводе символы, которых быть не должно (бук­
вы, скобки и т. п.). В нашей программе для всех полей ввода можно
установить такой обработчик события KeyPress (в переводе с англий­
ского — «нажатие клавиши»):
private void rEdit_KeyPress (
object sender, KeyPressEventArgs e )
{
if ( ! (Char.IsDigit(e.KeyChar)
I| e.KeyChar == (char) 8))
e.Handled = true;
}
Обратите внимание, что в языке C# используются классические обозна­
чения логических операций, пришедшие из языка С: операция И обо­
значается как & &, ИЛИ — как I |, а НЕ -восклицательным знаком.
Обозначения and, or и not, часто применяемые в языке C++, считают­
ся синтаксической ошибкой.
Обработчик события KeyPress получает блок данных типа
KeyPressEventArgs с именем е, в составе которого есть поле
KeyChar — символ, соответствующий нажатой клавише.
При вводе целых неотрицательных чисел используются только циф­
ры и клавиша Backspace (код символа 8) для удаления ошибочно вве­
дённых символов. Принадлежность символа к цифрам определяется с
помощью метода Char. IsDigit, который возвращает логическое значе­
ние true для любой цифры и false для всех остальных символов.

172
 Использование компонентов §19

Если полученный символ не входит в допустимый набор, свойство

е. Handled (по-английски — обработано) устанавливается равным
true. Этим мы сообщаем системе, что событие уже обработано и ни­
каких дополнительных действий не требуется. Так для всех «посторон­
них» символов отключается стандартная процедура обработки, при вво­
де они игнорируются.

Выводы
• Интерфейс программы строится с помощью мыши из готовых ком­
понентов, которые размещены на Панели элементов.
• Свойства компонентов изменяются с помощью панели Свойства.
На вкладке События можно установить обработчики событий для
выделенного компонента.
• Родительский компонент отвечает за перемещение и вывод на
экран всех дочерних компонентов.
• Невизуальные компоненты, например диалог выбора файла, не
изображаются на форме.
• Поля ввода позволяют пользователю вводить данные.
• Метки — это надписи на форме, которые не может изменить
пользователь. Текст метки можно изменять из программы.
• Для нескольких компонентов можно установить один и тот же
обработчик события. Параметр sender, который получает каждый
обработчик, — это ссылка на объект-источник события.
• Статический метод (метод класса) — это метод, для вызова кото­
рого не нужно создавать объект класса.
• Для обработки ошибок в современных программах используют
механизм исключений.
Вопросы и задания
1. Что такое компоненты? Зачем они нужны?
2. Объясните, как связаны компоненты и идея инкапсуляции.
3. Что такое родительский объект? Что такое дочерний объект?
4. Объясните роль свойства Dock в размещении элементов на форме.
5. Назовите основное свойство флажка. Как его использовать?
6. Что такое стандартный диалог? Как его использовать?
7. Объясните, что такое сложное свойство (на примере свойства Size
или Font).
8. Какой шрифт устанавливается для компонента по умолчанию?
9. Сравните свойства метки и поля ввода.
10. Как можно установить один обработчик события для нескольких
компонентов? Как в этом обработчике выяснить, какой компонент
был источником события?
11. Зачем в программе из параграфа используются методы int. Parse и
Color.FromArgb?
12. Как обрабатываются ошибки в современных программах? В чём, на
ваш взгляд, преимущества и недостатки такого подхода?

173
2 Программирование на языках C++ и C#

13. Как при вводе блокировать некорректные символы?

14. Используя дополнительные источники, выясните, какие ещё эле­
менты входят в перечисляемый тип DialogResult.
15. Используя дополнительные источники, выясните, как преобразо­
вать строку в вещественное число.
16. Проект. Измените программу для просмотра рисунков из пара­
графа так, чтобы кнопка и флажок размещались в нижней части
окна.
17. Проект. Добавьте в программу для построения HTML-кода цвета
(из параграфа) защиту от ввода слишком больших чисел (больших,
чем 255).
18. Изучите метод InitializeComponent в файле Forml.Designer.cs.
Выясните, где указано, что форма — это родительский объект для
кнопки и флажка.
*19.Проект. Разработайте свою программу, использующую компонен­
ты (например, можно написать программу для шифрования и де­
шифрования текста с помощью шифра простой замены).
Интересные сайты
ulearn.me — интерактивные онлайн-курсы по программированию на C#
professorweb.ru — программирование для среды .NET
metanit.com/sharp/ — сайт о программировании (в том числе на С#)

§20
Создание новых классов
Ключевые слова'.
• модуль • компонент
• модель • статический класс
• представление • методы класса
• класс • свойство
В этом параграфе мы создадим две программы, в которых используют­
ся модули — файлы, содержащие функции и описания новых классов
объектов.
Сначала построим программу, которая вычисляет арифметическое
выражение, записанное в символьной строке (см. § 11).

Вычисление арифметических выражений: модель

Модель в этой задаче — это функции для вычисления арифметическо­
го выражения, записанного в символьной строке. Будем использовать
те же функции, что и в § 11.

174
 Создание новых классов §20

Основная функция calc принимает один параметр — символьную

строку — и вычисляет значение записанного в ней арифметического
выражения. Напомним алгоритм её работы (на псевдокоде):
pos = позиция символа, соответствующего
последней операции
if ( pos < 0 )
результат = перевести всю строку в число
else {
nl = результат вычисления левой части
п2 = результат вычисления правой части
результат = применить операцию к nl и п2
}
Для того чтобы найти последнюю выполняемую операцию, функ­
ция calc вызывает другую функцию, lastOp, а та, в свою очередь,
использует функцию priority для определения приоритета операций.
Четвёртая функция, doOperation, вызывается из calc: она выполняет
заданную операцию с переданными ей данными. Все эти функции мы
хотим поместить в отдельный файл (модуль).

Новый класс
Создадим новый проект Stringcalculator. Для того чтобы выделить
модель задачи в отдельный файл, нужно построить новый класс. Ко­
нечно, возникает вопрос: почему нельзя сделать отдельный модуль, со­
держащий только функции, не относящиеся к какому-то классу? Но
это действительно сделать невозможно, потому что в языке C# любая
функция обязательно должна быть методом какого-то класса.
Выберем в меню Visual Studio пункт Проект — Добавить класс,
введём в диалоговом окне название класса — Calculator. После этого
в окне Обозреватель решений в списке файлов появляется новый файл
Calculator.cs (рис. 2.14).
Если открыть его двойным щелчком мышью, мы увидим заготовку,
построенную программой автоматически:
using System;
using System.Collections.Generic;
using System.Text;

namespace Stringcalculator
{
class Calculator
{
}
}

175
 Программирование на языках C++ и C#

Обозреватель решений ▼ Д X

Л ’ т© - с ® ©
Обозреватель решений — поиск (Ctrl+;) fi *

Решение "Stringcalculator" (проектов: 1)

|с*| StringCalculator
J* Properties

I> Ссылки
I* 0Р Calculator.cs
Ц=] Form1.cs
l3 Form1.Designer.cs

Ш Forml.resx
t* С* Program.cs

Обозреватель решений Team Explorer

Рис. 2.14

Итак, в отдельном файле создан новый класс Calculator, этот файл

добавлен к проекту, и он относится к тому же пространству имён
(namespace) StringCalculator, что и главная форма программы.
Новый класс нужен нам только для того, чтобы добавлять в него
функции, а не создавать объекты этого класса. Такой класс называется
статическим, перед его объявлением нужно добавить слово static:
static class Calculator
{
}
Статический класс — это просто набор функций, объединённых под
общим именем класса.

Методы класса
В класс Calculator мы поместим все функции, которые используются
для вычисления выражения (см. § 11):
static class Calculator
{
public static int calc( string expr ) {

}
static int lastOp( string expr ) {

176
 Создание новых классов §20

static int priority( char op ) {

}
static int doOperation(char op, int nl, int n2) {

}
}
В этом объявлении интересны два момента. Во-первых, все функции
объявлены с описателем static, поскольку все методы статического
класса Calculator должны быть статическими, т. е. не привязанны­
ми к конкретному объекту. Статические методы называются методами
класса (в отличие от методов объектов).
Во-вторых, для метода calc указан дополнительный описатель
public. Такой метод будет доступен не только в классе Calculator,
но и вне класса, например в методах главной формы. А остальные ме­
тоды — закрытые (private), их могут вызывать только методы самого
класса Calculator, в частности метод calc.
Напишем сначала код метода calc:
public static int calc ( string expr )
{
int pos = lastOp ( expr ); // (1)
if ( pos < 0 )
return int.Parse( expr ); // (2)
int nl = calc ( expr.Substring (0, pos) ); // (3)
int n2 = calc ( expr.Substring ( pos + 1 ) ); // (4)
return doOperation( expr[pos], nl, n2 ); // (5)
}
Обратите внимание, что функция calc — рекурсивная, она дважды
вызывает сама себя (в строках 3 и 4).
В строке 1 вызывается функция lastOp, которая возвращает
позицию последней выполняемой операции. Если эта функция вернула
-1 («операция не найдена»), в строке 2 преобразуем всю символьную
строку в число с помощью метода Parse и возвращаем это число как
результат функции.
Строки 3-5 обрабатывают случай, когда операция найдена. В этом
случае вычисляем значения выражений слева и справа от знака опе­
рации, а потом выполняем с этими значениями нужную операцию,
вызвав функцию doOperation.
Для того чтобы выделить подстроку из строки, применяется метод
Substring класса string. Первый аргумент этой функции — началь­
ная позиция, второй — длина подстроки. Вызов
expr.Substring( 0, pos )
возвращает подстроку строки expr, которая начинается с символа
ехрг[0] и имеет длину pos. Если второй аргумент не задан, метод

177
2 Программирование на языках C++ и C#

возвращает все символы с указанной позиции до конца строки. Напри­

мер, подстрока, полученная в строке 4:
expr.Substring( pos+1 )
содержит все символы после найденного знака операции.
Остальные методы практически повторяют функции, написанные на
языке Python в § 11:
static int lastOp( string expr )
{
int minPrt = 50, pos = -1;
for( int i = 0; i < expr.Length; i++ ) {
int prt = priority( expr[i] );
if( prt <= minPrt ) {
minPrt = prt;
pos = i;
}
}
return pos;
}
static int priority( char op )
{
if( op == '+' || op == '-') return 1;
if( op == ' * ’ || op == '/') return 2;
return 100;
}
static int doOperation( char op, int nl, int n2 )
{
if (op == '+') return nl + n2;
else if (op == return nl - n2;
else if (op == '*') return nl * n2;
else return nl / n2;
}
В коде эти функций есть два «новшества»:
• длина строки с C# определяется с помощью свойства Length; это
именно свойство, а не метод, поэтому круглые скобки в конце
записывать не нужно;
• оператор | |, использованный в функции priority, выполняет
логическую операцию ИЛИ1).
Таким образом, мы разработали модель задачи — класс Calculator,
с помощью которого вычисляется арифметическое выражение, записан­
ное в строке.
х) Такое же обозначение применяется в языках С, Java, JavaScript. А в C++ вмес­
то | | можно писать слово or.

178
 Создание новых классов §20

Вычисление арифметических выражений: представление

Теперь построим интерфейс программы (рис. 2.15).
Калькулятор | сЭ II В || •-- 1
5*5-13/2 ▼
25*4+190/13=114
13+6/7-4=9
12+15-6*3=9

Рис. 2.15
В верхней части окна находится выпадающий список — компонент
СошЬоВох. Под ним размещено поле вывода результата — многостроч­
ный редактор текста. Это компонент TextBox, у которого установлено
свойство Multiline, равное True.
Пользователь вводит выражение в окне выпадающего списка. При на­
жатии на клавишу Enter выражение вычисляется и его результат вы­
водится в последней строке поля вывода. Кроме того, каждое новое вы­
ражение добавляется в верхний выпадающий список. С помощью этого
списка можно вернуться к введённому ранее выражению и исправить его.
Добавляем компонент СошЬоВох на форму, назовём его input (в пе­
реводе с английского — ввод). Чтобы прижать список к верхней гра­
нице окна, установим свойство Dock равным Тор («прижать вверх»).
Для компонента TextBox выбираем выравнивание Fill (заполнить всю
свободную область), имя answers (в переводе с английского — ответы)
и свойство Multiline равное True («да», это многострочный редактор).
Чтобы пользователь не мог изменять поле вывода, у компонента
answers устанавливаем логическое свойство Readonly (в переводе с ан­
глийского — только для чтения), равное True («да»). При этом фон
компонента станет серым. Если вам это не нравится, нужно изменить
свойство BackColor.
Логика работы программы может быть записана в виде псевдокода:
if( нажата клавиша Enter ) {
х = значение выражения
добавить результат в конец поля вывода
if( выражения нет в списке )
добавить его в список
}
Перехватим нажатие клавиши Enter с помощью обработчика собы­
тия KeyPress компонента input. Клавиша Enter имеет код 13, поэто­
му условие «если нажата клавиша Enter» запишется так:
if( е.KeyChar == (char) 13 ) {

179
2 Программирование на языках C++ и C#

Значение арифметического выражения будем вычислять с помощью

функции calc:
int х = Calculator.calc( input.Text );
Эта функция принадлежит классу Calculator, поэтому перед названи­
ем функции через точку указано ещё и имя класса.
Содержимое поля вывода TextBox хранится как свойство Text, для
разбивки на строки используется сочетание двух служебных симво­
лов: \г (возврат в начало строки) и \п (перевод строки). Допишем вве­
дённое выражение и результат его вычисления в конец текста в виде
отдельной строки:
answers.Text += input.Text + "=" +
x.ToStringO + "\r\n";
Результат вычислений (x) переведён в символьный вид с помощью ме­
тода ToString.
Строки, входящие в выпадающий список, доступны как свойство-
список Items объекта input. Метод FindString служит для поиска
строки в списке и возвращает индекс найденного элемента или зна­
чение -1, если образец не найден. Поэтому добавить в список новую
строку можно следующим образом:
int i = input.FindString( input.Text );
if ( i < 0 )
input.Items.Insert( 0, input.Text );
Метод Insert добавляет строку в указанное место списка. Первый ар­
гумент — это позиция новой строки в списке. Нумерация элементов спи­
ска начинается с нуля, поэтому позиция 0 — это самое начало списка.
Приведём полностью обработчик события KeyPress:
private void inputKeyPress ( object sender,
KeyPressEventArgs e )
{
if ( e.KeyChar == (char) 13 ) {
int x = Calculator.calc ( input.Text );
answers.Text += input.Text + "=" +
x.ToStringO + "\r\n";
int i = input.FindString( input.Text );
if( i < 0 )
input.Items.Insert( 0, input.Text );
}
}

Новый компонент — зачем это нужно?

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

180
 Создание новых классов §20

пригодились бы, когда мы писали программу для работы с кодами

цвета в модели RGB.
Стандартный компонент TextBox разрешает вводить любые символы
и представляет результат ввода как текстовое свойство Text. Поэтому
для того, чтобы получить нужное нам поведение (ввод целых чисел),
мы в своей программе:
• добавили обработчик события KeyPress, заблокировав ошибочные
символы;
• для перевода текстовой строки в число каждый раз использовали
метод int.Parse.
Если такие поля ввода нужны часто и в разных программах, мож­
но избавиться от этих рутинных операций. Для этого создаётся новый
компонент, который обладает всеми необходимыми свойствами.
Конечно, можно создавать компонент «с нуля», но так почти никто
не делает. Обычно задача сводится к тому, чтобы как-то улучшить су­
ществующий стандартный компонент, который уже есть в библиотеке.
Мы будем совершенствовать поле ввода стандартной библиотеки —
компонент TextBox. Это значит, что наш компонент (назовём его
IntTextBox) будет наследником класса TextBox, а класс TextBox будет
соответственно базовым классом для нового класса IntTextBox.
Перечислим изменения, которые нужно внести в класс TextBox:
• все некорректные символы (кроме цифр и кода клавиши
Backspace) должны блокироваться автоматически, без установки
дополнительных обработчиков событий;
• компонент должен уметь сообщать числовое значение; для этого
мы добавим к нему свойство Value (в переводе с английского —
значение) целого типа.

Добавляем новый компонент

Начнём новый проект — программу, которая будет переводить целые
числа из десятичной системы в шестнадцатеричную (рис. 2.16).
Метка hexLabel
Label \

Поле decEdit Шестнадцатеричная система о ГеППО

IntTextBoxоо ij ЗЕ 9

Рис. 2.16
Для формы запретим изменение размеров: установим свойство
FormBorderStyle равным FixedSingle.
Теперь создадим новый компонент — наследник класса TextBox.
Для этого нужно добавить к проекту новый класс: выбрать пункт меню
Проект — Добавить класс и ввести имя этого класса — IntTextBox.
После этого в окне обозревателя решений появится новый исходный
файл — IntTextBox.cs.

181
2 Программирование на языках C++ и C#

Откроем этот файл двойным щелчком и укажем, что новый класс

является наследником класса TextBox:
class IntTextBox: TextBox
{
}
Если теперь попытаться запустить программу, вы увидите сообщение
об ошибке: класс TextBox неизвестен. Чтобы исправить эту ошибку,
нужно в начале файла IntTextBox.cs подключить библиотеку, в кото­
рой описан класс TextBox:
using System.Windows.Forms;
После сборки программы в верхней части окна Панель элементов
появляется новый компонент IntTextBox (рис. 2.17), который можно
добавлять на форму так же, как и стандартные компоненты. Правда,
пока он ничем не отличается от компонента TextBox.

Рис. 2.17

Изменение поведения компонента

Добавим в класс IntTextBox (в файле IntTextBox.cs) новые методы.
Сначала создадим обработчик события KeyPress, который блокирует
нежелательные символы:
protected override void OnKeyPress (
KeyPressEventArgs e )
{
if ( ! (Char.IsDigit(e.KeyChar)
II e.KeyChar == (char)8))
e.Handled = true;
base.OnKeyPress(e);
}
Слово override нам уже знакомо: оно означает, что мы переопреде­
ляем метод базового класса с таким же именем. Описатель protected

182
 Создание новых классов §20

говорит о том, что этот метод будет доступен всем наследникам класса
IntTextBox и недоступен для остальных классов.
В последней строке вызывается метод OnKeyPress базового класса:
base.OnKeyPress (е);
Здесь base — это служебное слово языка С#, которое используется
для обращения к базовому классу из методов класса-наследника. Мы
вызываем метод базового класса для того, чтобы не отключить дей­
ствия, которые там выполняются (и о которых мы не знаем!).
Теперь добавим в описание класса новое свойство:
public int Value
{
set { Text = value.ToString(); }
get {
try { return int.Parse ( Text ); }
catch { return 0; }
}
}
В первой строке объявляется свойство с именем Value. Значение
свойства — это целое число (int). Свойство будет доступно всем объ­
ектам, на это указывает слово public.
Свойство в C# определяется двумя методами — «сеттером», который
всегда называется set, и «геттером», за ним закреплено имя get.
Метод set служит для изменения значения свойства. Новое значе­
ние, которое всегда называется value (все буквы строчные!), преобра­
зуется в символьную строку и сразу копируется в свойство Text наше­
го компонента.
В методе get (чтение значения свойства) пытаемся преобразовать
строку в целое число1’, и в случае неудачи возвращаем 0.
Вот полное описание нового класса:
class IntTextBox: TextBox
{
protected override void OnKeyPress(
KeyPressEventArgs e)
{
if ( ! (Char.IsDigit( e.KeyChar )
I I e.KeyChar == (char) 8))
e.Handled = true;
base.OnKeyPress( e );
}
1J Здесь можно использовать также метод int. TryParse, который позволяет обна­
ружить ошибку при таком преобразовании без использования исключений. Его
описание вы можете найти в литературе или в Интернете.

183
2 Программирование на языках C++ и C#

public int Value

{
set { Text = value.ToString(); }
get {
try { return int.Parse( Text ); }
catch { return 0; }
}
}
}
Теперь можно использовать готовый компонент. Поместим на фор­
му компонент IntTextBox, назовём его decEdit. Кроме того, добавим
метку Label с именем hexLabel для вывода шестнадцатеричного зна­
чения.
Для нового компонента decEdit необходимо определить обработ­
чик события TextChanged — при изменении содержимого поля ввода
нужно показать соответствующее шестнадцатеричное число с помощью
метки hexLabel. Выделим поле ввода и добавим такой обработчик со­
бытия TextChanged:
private void decEdit_TextChanged( object sender,
EventArgs e )
{
hexLabel.Text = decEdit.Value.ToString("X");
}
Сначала мы запрашиваем числовое значение у поля ввода, исполь­
зуя новое свойство Value, а затем переводим его в шестнадцатеричную
систему счисления («X») с помощью метода ToString.

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

184
 Создание новых классов §20

• При переопределении методов базового класса в новом компоненте

нужно вызывать одноимённый метод базового класса.
• В языке C# объекты могут иметь свойства. Свойства определяют­
ся двумя методами: метод get вызывается при чтении значения
свойства, а метод set — при записи значения.

Вопросы и задания
1. Что такое пространство имён? Как пространства имён использу­
ются для связи между модулями программ?
2. Что означает описатель static при объявлении классов и мето­
дов?
3. Почему в классе Calculator из параграфа только функция calc
объявлена с описателем public?
4. Зачем используют свойство Readonly?
5. Как в C# преобразовать числовое значения в текстовое и обратно?
Как перевести число в шестнадцатеричную систему счисления?
6. Проект. Измените программу Stringcalculator из параграфа
так, чтобы она вычисляла выражения с вещественными числами.
Для перевода вещественных чисел из символьного вида в число­
вой можно использовать метод double. Parse.
7. Проект. Добавьте в программу Stringcalculator из парагра­
фа обработку ошибок. Подумайте, какие ошибки может сделать
пользователь. Какие ошибки могут возникнуть при вычислениях?
Как их обработать?
8. Изучите исходные тексты файлов программы Stringcalculator из
параграфа. Сделайте предположение, как связаны форма и класс
Calculator (откуда форма «знает» такой класс и его методы).
9. Пусть требуется изменить программу Stringcalculator из пара­
графа так, чтобы она обрабатывала выражения со скобками. Что
нужно изменить: модель, интерфейс или и то, и другое?
*10.Проект. Измените программу Stringcalculator из параграфа
так, чтобы она вычисляла выражения со скобками. Подсказка:
нужно искать последнюю операцию с самым низким приорите­
том, стоящую вне скобок.
**11.Проект. Измените программу из предыдущего задания так, что­
бы в выражении можно было использовать функции abs, sin,
cos, sqrt.
12. Проект. Постройте программу «Калькулятор»
для выполнения вычислений с целыми числами 1 ....... J
(см. рисунок справа). 0000
13. Проект. Постройте программу «Калькулятор» 00ВИ
для выполнения вычислений с вещественными
числами. гамгага
00BQ

185
2 Программирование на языках C++ и C#

*14. Проект. Постройте программу «Римский калькулятор» для

выполнения вычислений с числами в римской системе счисления.
15. В каких случаях имеет смысл разрабатывать свои компоненты?
16. Как вы думаете, почему программисты редко создают свои компо­
ненты «с нуля»?
17. Объясните, как связаны классы компонентов IntTextBox (из
параграфа) и TextBox. Чем они различаются?
18. Что означают описатели protected и override при описании
метода?
19. Объясните, как работает свойство Value у компонента IntTextBox
из параграфа.
20. Зачем в обработчике события OnKeyPress нового компонента (из
параграфа) вызывается метод базового класса с тем же именем?
Установите для вашего компонента обработчик события KeyPress.
Попробуйте убрать вызов метода базового класса. Проверьте, ра­
ботает ли обработчик.
21. Проект. Разработайте компонент, который позволяет вводить
шестнадцатеричные числа.
*22.Проект. Разработайте компонент FloatTextBox, который позво­
ляет вводить вещественные числа и обрабатывает ошибки.
**23.Проект. Придумайте свой компонент и напишите программу, в
которой он используется.

Интересные сайты
csharp.net-informations.com — справочник по языку C#
tutorialspoint.com/csharp/ — онлайн-учебник по C#
rextester.com — онлайн-компилятор C#

186
ЗАКЛЮЧЕНИЕ

Вся наша жизнь всё в большей степени зависит от программ, которые

управляют роботами, «умными домами», автомобилями, самолётами.
Поэтому роль программистов в современном мире очень велика. Мож­
но сказать, что они во многом определяют, насколько комфортным и
безопасным будет дальнейший путь развития человечества.
Одна из главных задач современного программиста — написать на­
дёжную программу, которая содержит минимальное число ошибок. Для
этого программа должна быть хорошо спроектирована, т. е. правильно
разбита на составные части, которые можно отлаживать отдельно друг
от друга.
Многолетний опыт показал, что разбиение на объекты и использо­
вание ООП позволяет успешно разрабатывать очень сложные системы,
содержащие сотни тысяч и даже миллионы строк исходного кода.
В этой части пособия мы познакомились с ООП на примере совре­
менных языков программирования: Python, C++ и немного С#. Ко­
нечно, мы изучили лишь небольшую часть возможностей этих языков.
Хочется надеяться, что вы этим не ограничитесь и будете дальше со­
вершенствовать свои знания. Для этого нужно изучать дополнительную
литературу, справочники, источники в сети Интернет. Небольшой спи­
сок литературы приведён в конце этой книги.
И самое главное — не забывайте, что для того чтобы научиться
программировать, нужно программировать. Пишите самые разные про­
граммы: программируйте игры, анализируйте «большие данные», об­
рабатывайте информацию с веб-сайтов, попытайтесь с помощью своих
программ автоматизировать операции, которые вы обычно выполняете
вручную.
Успехов вам на этом интересном, но трудном пути!

Литература для дальнейшего изучения

Язык Python
1. Доусон М. Программируем на Python: Пер. с англ. — СПб.: Питер,
2014.
2. Мэтиз Э. Изучаем Python. Программирование игр, визуализация
данных, веб-приложения.: Пер. с англ. — СПб.: Питер, 2017
3. Любанович Б. Простой Python. Современный стиль программирова­
ния.: Пер. с англ. — СПб.: Питер, 2016.

187
 Заключение

4. Прохоренок Н. A., Python 3 и PyQt. Разработка приложений. —

СПб.: БХВ-Петербург, 2012.
5. Саммерфилд М. Программирование на Python 3. Подробное руко­
водство.: Пер. с англ. — СПб.: Символ-Плюс, 2009.
6. Лутц М. Изучаем Python, 4-е изд.: Пер. с англ. — СПб.: Символ-
Плюс, 2011.
7. Рамалъо Л. Python. К вершинам мастерства.: Пер. с англ. — М.:
ДМК Пресс, 2016.

Язык C++
1. Страуструп Б. Программирование: принципы и практика с исполь­
зованием C++, 2-е изд.: Пер. с англ. — М.: ООО «И. Д. Вильямс»,
2016.
2. Липпман С. Б., Лажойе Ж., Му Б. Э. Язык программирования C++.
Базовый курс, 5-е изд.: Пер. с англ. — М.: ООО «И. Д. Вильямс»,
2014.
3. Шилдт Г. C++. Базовый курс, 3-е изд.: Пер. с англ. — М.: ООО
«И. Д. Вильямс», 2010.
4. Лафоре Р. Объектно-ориентированное программирование в C++, 4-е
изд.: Пер. с англ. — СПб.: Питер, 2004.
5. Мюссер Д., Дердж Ж., Сейни А. C++ и STL: справочное руководство,
2-е изд.: Пер. с англ. - М.: ООО «И. Д. Вильямс», 2010.

Язык C#
1. Дрейер М. C# для школьников: Учебное пособие: Пер. с англ. —
М.: Интернет-Университет Информационных Технологий; БИНОМ.
Лаборатория знаний, 2009.
2. Хейлсберг А., Торгерсен М., Вилтамут С., Голд П. Язык програм­
мирования С#. Классика Computers Science. 4-е изд.: Пер. с англ. —
СПб.: Питер, 2012.
3. Троелсен Э. Язык программирования C# 5.0 и платформа .NET 4.5,
6-е изд.: Пер. с англ. — М. : ООО «И. Д. Вильямс», 2013.
4. Шилдт Г. C# 4.0. Полное руководство: Пер. с англ. — М.: ООО
«И. Д. Вильямс», 2011.

188
ОГЛАВЛЕНИЕ

Предисловие........................................................................................................ 3
Глава 1. Программирование на языке Python......................................... 5
§1 . Что такое ООП?................................................................................... 5
Проблема сложности программ........................................................... 5
Процедурное программирование........................................................... 5
Объектный подход.................................................................................. 6
Взаимодействие объектов..................................................................... 7
Выводы.......................................................................................................8
§2 . Модель задачи: классы и объекты................................................ 8
Объектно-ориентированный анализ..................................................... 9
«Торпедная атака».................................................................................. 9
Объекты и классы.................................................................................. 9
Классы объектов в игре........................................................................10
Взаимодействие объектов................................................................... 11
Выводы.....................................................................................................12
§3 . Классы и объекты в программе................................................... 13
Объявление класса................................................................................ 13
Поля класса............................................................................................ 14
Конструктор............................................................................................ 15
Конструктор с параметрами............................................................... 16
Данные класса...................................................................................... 17
Методы..................................................................................................... 17
Анимация.............................................................................................. 18
Строим флотилию.................................................................................. 19
Выводы..................................................................................................... 19
§4 . Скрытие внутреннего устройства................................................ 21
Зачем это делать?.................................................................................. 21
Скрытие полей...................................................................................... 22
Доступ к полям через методы........................................................... 23
Свойства (property)................................................................................ 24
Меняем внутреннее устройство........................................................... 25
Свойство «только для чтения»........................................................... 26
Выводы.....................................................................................................28

189
 Оглавление

§5 . Иерархия классов............................................................................. 29
Наследование.......................................................................................... 29
Иерархия объектов в игре................................................................. 30
Базовый класс........................................................................................ 31
Доступ к полям.................................................................................... 34
Выводы.....................................................................................................35
§6 . Классы-наследники (I).................................................................... 37
Классы-наследники................................................................................ 37
Пульсар...................................................................................................39
Полиморфизм........................................................................................ 40
Выводы.....................................................................................................41
§7 . Классы-наследники (II).................................................................... 42
Подвижные объекты............................................................................ 42
Космические корабли............................................................................ 44
Модуль с классами................................................................................ 46
Выводы.....................................................................................................48
§ 8. Событийно-ориентированное программирование...................... 48
Особенности современных прикладных программ..........................49
Программы с графическим интерфейсом........................................ 51
Простейшая программа........................................................................52
Свойства формы.................................................................................... 52
Обработчик события.............................................................................. 53
Выводы..................................................................................................... 54
§9 . Использование компонентов (виджетов)................................... 55
Программа с компонентами............................................................... 55
Новый класс: всё в одном................................................................... 60
Ввод и вывод данных..........................................................................61
Обработка ошибок................................................................................ 64
Выводы.....................................................................................................66
§ 10. Создание компонентов.................................................................... 67
Зачем это нужно?.................................................................................. 67
Компонент для ввода целых чисел................................................... 68
Программа с новым компонентом..................................................... 69
Выключатель с рисунком................................................................... 70
Перехват щелчка мышью................................................................... 72
Новое свойство onChange..................................................................... 73
Составной компонент............................................................................ 74
Выводы..................................................................................................... 76
§11 . Модель и представление.................................................................. 77
Зачем это нужно?.................................................................................. 77
Вычисление арифметических выражений: модель........................78
Представление........................................................................................ 80
Выводы.....................................................................................................82

190
 Оглавление §16.

Глава 2. Программирование на языкахC++ и C#................................ 84

§12. Классы и объекты в C++.................................................................. 84
Новая задача и её анализ ................................................................. 84
Класс СМар............................................................................................ 85
Пишем свой конструктор................................................................... 87
Рефакторинг.......................................................................................... 89
Рисуем карту.......................................................................................... 92
Выводы.....................................................................................................94
§13. Программа с классами (практикум)............................................... 96
Класс ССаг.............................................................................................. 96
Снова рефакторинг................................................................................ 99
Основная программа............................................................................ 100
Разбиение на модули.......................................................................... 101
Выводы...................................................................................................104
§ 14. Инкапсуляция.................................................................................. 105
Объект защищает свои данные......................................................... 106
Изменение внутреннего устройства................................................. 107
Свойство «только для чтения»......................................................... 110
Свойства в C#...................................................................................... 110
Выводы...................................................................................................112
§15 . Наследование................................................................................... 113
Моделирование жизни в океане....................................................... 113
Иерархия классов................................................................................ 113
Базовый класс...................................................................................... 114
Абстрактный класс.............................................................................. 116
Защищённые поля и методы (protected)........................................ 117
Неподвижные объекты........................................................................ 118
Подвижные объекты..........................................................................120
Рыбы..................................................................................................... 121
Хищники...............................................................................................122
Вспомогательные процедуры и функции...................................... 123
Основная программа............................................................................ 124
Выводы................................................................................................... 127
§ 16. Полиморфизм.................................................................................... 129
Указатели на базовый класс............................................................. 129
Полиморфизм в действии................................................................. 131
Немного теории.................................................................................... 132
Позднее связывание............................................................................ 134
Класс Океан.......................................................................................... 135
Деструктор............................................................................................ 138
Выводы...................................................................................................140

191
 Оглавление

§17 . Взаимодействие объектов..............................................................142

Столкновения...................................................................................... 142
Изменение базового класса............................................................... 144
Изменение других классов............................................................... 146
«Умные» указатели............................................................................ 148
Применяем «умные» указатели....................................................... 149
Выводы...................................................................................................151
§18 . Простая программа на C#........................................................... 153
RAD-среды для разработки программ.............................................153
Язык C# и среда .NET......................................................................154
Проект в C#........................................................................................ 155
Первый проект.................................................................................... 155
Свойства объектов.............................................................................. 159
Обработчики событий.......................................................................... 160
Выводы................................................................................................... 163
§ 19. Использование компонентов........................................................ 164
Программа для просмотра рисунков...............................................165
Ввод и вывод данных........................................................................169
Обработка ошибок.............................................................................. 171
Выводы...................................................................................................173
§20 . Создание новых классов................................................................ 174
Вычисление арифметических выражений: модель...................... 174
Новый класс........................................................................................ 175
Методы класса.................................................................................... 176
Вычисление арифметических выражений: представление........ 179
Новый компонент — зачем это нужно?........................................ 180
Добавляем новый компонент........................................................... 181
Изменение поведения компонента................................................... 182
Выводы...................................................................................................184
Заключение...................................................................................................... 187
Литература для дальнейшего изучения........................................ 187

192
 Поле ввода rEdit

TEdit TEdit

Флажок Панель

PictureBox