Visual C++ Лекция 1 1

ЛЕКЦИЯ 1
ВВЕДЕНИЕ В VISUAL C++ ________________________________________________________________ 1
Интерфейс вызовов функций в Windows ____________________________________________________ 1
Библиотеки динамической загрузки (DLL) ___________________________________________________ 2
Многозадачность в Windows ______________________________________________________________ 2
Взаимодействие программ и Windows ______________________________________________________ 2
ОСНОВЫ ПРОГРАММИРОВАНИЯ ПОД WINDOWS ________________________________________ 3
Функция WinMain() ______________________________________________________________________ 3
Функция окна __________________________________________________________________________ 3
Цикл сообщений________________________________________________________________________ 3
Класс окна_____________________________________________________________________________ 3
Специфика программ для Windows ________________________________________________________ 3
Типы данных в Windows _________________________________________________________________ 4
Преимущества использования MFC________________________________________________________ 4
ВВЕДЕНИЕ В ОБЪЕКТНО-ОРИЕНТИРОВАННУЮ ПАРАДИГМУ ___________________________ 5
Инкапсуляция __________________________________________________________________________ 5
Наследование _________________________________________________________________________ 6
Полиморфизм__________________________________________________________________________ 7

ВВЕДЕНИЕ В VISUAL C++

В связи с тем, что сегодня уровень сложности программного обеспечения очень высок, разработка
приложений Windows с использованием только какого-либо языка программирования (например, языка C)
значительно затрудняется. Программист должен затратить массу времени на решение стандартных задач
по созданию многооконного интерфейса. Реализация технологии связывания и встраивания объектов -
OLE - потребует от программиста еще более сложной работы.
Чтобы облегчить работу программиста практически все современные компиляторы с языка C++ со-
держат специальные библиотеки классов. Такие библиотеки включают в себя практически весь программ-
ный интерфейс Windows и позволяют пользоваться при программировании средствами более высокого
уровня, чем обычные вызовы функций. За счет этого значительно упрощается разработка приложений,
имеющих сложный интерфейс пользователя, облегчается поддержка технологии OLE и взаимодействие с
базами данных.
Современные интегрированные средства разработки приложений Windows позволяют автоматизи-
ровать процесс создания приложения. Для этого используются генераторы приложений. Программист от-
вечает на вопросы генератора приложений и определяет свойства приложения - поддерживает ли оно
многооконный режим, технологию OLE, трехмерные органы управления, справочную систему. Генератор
приложений, создаст приложение, отвечающее требованиям, и предоставит исходные тексты. Пользуясь
им как шаблоном, программист сможет быстро разрабатывать свои приложения.
Подобные средства автоматизированного создания приложений включены в компилятор Microsoft
Visual C++ и называются MFC AppWizard. Заполнив несколько диалоговых панелей, можно указать харак-
теристики приложения и получить его тексты, снабженные обширными комментариями. MFC AppWizard
позволяет создавать однооконные и многооконные приложения, а также приложения, не имеющие главно-
го окна, -вместо него используется диалоговая панель. Можно также включить поддержку технологии OLE,
баз данных, справочной системы.
Конечно, MFC AppWizard не всесилен. Прикладную часть приложения программисту придется раз-
рабатывать самостоятельно. Исходный текст приложения, созданный MFC AppWizard, станет только ос-
новой, к которой нужно подключить остальное. Но работающий шаблон приложения - это уже половина
всей работы. Исходные тексты приложений, автоматически полученных от MFC AppWizard, могут состав-
лять сотни строк текста. Набор его вручную был бы очень утомителен.
Нужно отметить, что MFC AppWizard создает тексты приложений только с использованием библио-
теки классов MFC (Microsoft Foundation Class library). Поэтому только изучив язык C++ и библиотеку MFC,
можно пользоваться средствами автоматизированной разработки и создавать свои приложения в крат-
чайшие сроки.
Интерфейс вызовов функций в Windows
Благодаря данному интерфейсу доступ к системным ресурсам осуществляется через целый рад
системных функций. Совокупность таких функций называется прикладным программным интерфейсом,
или API (Application Programming Interfase). Для взаимодействия с Windows приложение запрашивает
функции API, с помощью которых реализуются все необходимые системные действия, такие как выделе-
ние памяти, вывод на экран, создание окон и т.п.

Выжол Ю.А.
Visual C++ Лекция 1 2
Библиотека MFC инкапсулирует многие функции API. Хотя программам и разрешено обращаться к
ним напрямую, все же чаще это будет выполняться через соответствующие функции-члены. Как правило,
функции-члены либо аналогичны функциям API, либо непосредственно обращаются к нужной части ин-
терфейса.
Библиотеки динамической загрузки (DLL)
Поскольку API состоит из большого числа функций, может сложиться впечатление, что при компиля-
ции каждой программы, написанной для Windows, к ней подключается код довольно значительного объё-
ма. В действительности это не так. Функции API содержатся в библиотеках динамической загрузки
(Dynamic Link Libraries, или DLL), которые загружаются в память только в тот момент, когда к ним происхо-
дит обращение, т.е. при выполнении программы. Рассмотрим, как осуществляется механизм динамиче-
ской загрузки.
Динамическая загрузка обеспечивает ряд существенных преимуществ. Во-первых, поскольку прак-
тически все программы используют API-функции, то благодаря DLL-библиотекам существенно экономится
дисковое пространство, которое в противном случае занималось бы большим количеством повторяюще-
гося кода, содержащегося в каждом из исполняемых файлов. Во-вторых, изменения и улучшения в
Windows-приложениях сводятся к обновлению только содержимого DLL-библиотек. Уже существующие
тексты программ не требуют перекомпиляции.
Многозадачность в Windows
Как известно, все версии Windows поддерживают многозадачность. В Windows 3.1 имеется только
один тип многозадачности – основанный на процессах. В более передовых системах, таких как Windows
95 и Windows NT, поддерживается два типа многозадачности: основанный на процессах и основанный на
потоках. Давайте рассмотрим их чуть подробнее.
Процесс – это программа, которая выполняется. При многозадачности такого типа две или более
программы могут выполняться параллельно. Конечно, они по очереди используют ресурсы центрального
процессора и с технической точки зрения, выполняются неодновременно, но благодаря высокой скорости
работы компьютера это практически незаметно.
Поток – это отдельная часть исполняемого кода. Название произошло от понятия “направление
протекания процесса”. В многозадачности данного типа отдельные потоки внутри одного процесса также
могут выполняться одновременно. Все процессы имеют, по крайней мере, один поток, но в Windows 95 и
Windows NT их может быть несколько.
Отсюда можно сделать вывод, что в Windows 95 и Windows NT допускается существование процес-
сов, две или более частей, которых выполняются одновременно. Оказывается, такое предположение вер-
но. Следовательно, при работе в этих операционных системах возможно параллельное выполнение, как
программ, так и отдельных частей самих программ. Это позволяет писать очень эффективные программы.
Есть и другое существенное различие между многозадачностями Windows 3.1 и Windows 95/NT. В
Windows 3.1 используется неприоритетная многозадачность. Это означает, что процесс, выпол-
няющийся в данный момент, получает доступ к ресурсам центрального процессора и удерживает их в те-
чение необходимого ему времени. Таким образом, неправильно выполняющаяся программа может захва-
тить все ресурсы процессора и не давать выполняться другим процессам. В отличие от этого в Windows
95 и Windows NT используется приоритетная многозадачность. В этом случае каждому активному
потоку предоставляется определенный промежуток времени работы процессора. По истечению данного
промежутка управление автоматически передается следующему потоку. Это не дает возможность про-
граммам полностью захватывать ресурсы процессора. Интуитивно должно быть понятно, что такой способ
более предпочтителен.
Взаимодействие программ и Windows
Во многих операционных системах взаимодействие между системой и программой инициализирует
программа. Например, в DOS программа запрашивает разрешение на ввод и вывод данных. Говоря дру-
гими словами, не- Windows-программы сами вызывают операционную систему. Обратного процесса не
происходит. В Windows все совершенно наоборот: именно система вызывает программу. Это осуществля-
ется следующим образом: программа ожидает получения сообщения от Windows. Когда это происхо-
дит, то выполняется некоторое действие. После его завершения программа ожидает следующего сообще-
ния.
Windows может посылать программе сообщения множества различных типов. Например, каждый раз
при щелчке мышью в окне активной программы посылается соответствующее сообщение. Другой тип со-
общений посылается, когда необходимо обновить содержимое активного окна. Сообщения посылаются
также при нажатии клавиши, если программа ожидает ввода с клавиатуры. Необходимо запомнить одно:
по отношению к программе сообщения появляются случайным образом. Вот почему Windows-программы
похожи на программы обработки прерываний: невозможно предсказать, какое сообщение появиться в
следующий момент.

Выжол Ю.А.
Visual C++ Лекция 1 3
ОСНОВЫ ПРОГРАММИРОВАНИЯ ПОД WINDOWS
Поскольку архитектура Windows-программ основана на принципе сообщений, все эти программы со-
держат некоторые общие компоненты. Обычно их приходится в явном виде включать в исходный код. Но,
к счастью, при использовании библиотеки MFC это происходит автоматически; нет необходимости тратить
время и усилия на их написание. Тем не менее, чтобы до конца разобраться, как работает Windows-
программа, написанная с использованием MFC, и почему она работает именно так, необходимо в общих
чертах понять назначение этих компонентов.
Функция WinMain()
Все Windows-программы начинают выполнение с вызова функции WinMain(). При традиционном ме-
тоде программирования это нужно делать явно. С использованием библиотеки MFC такая необходимость
отпадает, но функция все-таки существует.
Функция окна
Все Windows-программы должны содержать специальную функцию, которая не используется в са-
мой программе, но вызывается самой операционной системой. Эту функцию обычно называют функ-
цией окна, или процедурой окна. Она вызывается Windows, когда системе необходимо передать
сообщение в программу. Именно через нее осуществляется взаимодействие между программой и систе-
мой. Функция окна передает сообщение в своих аргументах. Согласно терминологии Windows, функции,
вызываемые системой, называются функциями обратного вызова. Таким образом, функция окна
является функцией обратного вызова.
Помимо принятия сообщения от Windows, функция окна должна вызывать выполнение действия,
указанного в сообщении. Конечно, программа не обязана отвечать на все сообщения, посылаемые
Windows. Поскольку их могут быть сотни, то большинство сообщений обычно обрабатывается самой сис-
темой, а программе достаточно поручить Windows выполнить действия, предусмотренные по умолчанию.
В большинстве Windows-программ задача создания функции окна лежит на программисте. При ис-
пользовании библиотеки MFC такая функция создается автоматически. В этом заключается одно из пре-
имуществ библиотеки. Но в любом случае, если сообщение получено, то программа должна выполнить
некоторое действие. Хотя она может вызывать для этого одну или несколько API-функций, само действие
было инициировано Windows. Поэтому именно способ взаимодействия с операционной системой через
сообщения диктует общий принцип построения всех программ для Windows, написанных как с использо-
ванием MFC, так и без нее.
Цикл сообщений
Как объяснялось выше, Windows взаимодействует с программой, посылая ей сообщения. Все при-
ложения Windows должны организовать так называемый цикл сообщений (обычно внутри функции
WinMain()). В этом цикле каждое необработанное сообщение должно быть извлечено из очереди сообще-
ний данного приложения и передано назад в Windows, которая затем вызывает функцию окна программы
с данным сообщением в качестве аргумента. В традиционных Windows-программах необходимо самостоя-
тельно создавать и активизировать такой цикл. При использовании MFC это также выполняется автомати-
чески. Однако важно помнить, что цикл сообщений все же существует. Он является неотъемлемой частью
любого приложения Windows.
Процесс получения и обработки сообщений может показаться чересчур сложным, но, тем не менее,
ему должны следовать все Windows-программы. К счастью, при использовании библиотеки MFC большин-
ство частных деталей скрыты от программиста, хотя и продолжают неявно присутствовать в программе.
Класс окна
Как будет показано дальше, каждое окно в Windows-приложении характеризуется определенными
атрибутами, называемыми классом окна. (Здесь понятие “класс” не идентично используемому в С++.
Оно, скорее, означает стиль или тип.) В традиционной программе класс окна должен быть определен и
зарегистрирован прежде, чем будет создано окно. При регистрации необходимо сообщить Windows, какой
вид должно иметь окно и какую функцию оно выполняет. В то же время регистрация класса окна еще не
означает создание самого окна. Для этого требуется выполнить дополнительные действия. При использо-
вании библиотеки MFC создавать собственный класс окна нет необходимости. Вместо этого можно рабо-
тать с одним из заранее определенных классов, описанных в библиотеке. В этом еще одно ее преимуще-
ство.
Специфика программ для Windows
Структура Windows-программ отличается от структуры программ других типов. Это вызвано двумя
обстоятельствами: во-первых, способом взаимодействия между программой и Windows, описанным выше;

Выжол Ю.А.
Visual C++ Лекция 1 4
во-вторых, правилами, которым следует подчиняться для создания стандартного интерфейса Windows-
приложения (т.е. чтобы сделать программу “похожей “ на Windows-приложение).
Цель Windows – дать человеку, который хотя бы немного знаком с системой, возможность сесть за
компьютер и запустить любое приложение без предварительной подготовки. Для этого Windows предос-
тавляет дружественный интерфейс пользователя. Теоретически, если пользователь сумел запустить одно
Windows-приложение, то он сумеет запустить и любое другое. Конечно, на практике придется немного по-
тренироваться, чтобы научиться использовать большинство программ с максимальной эффективностью.
Однако это связано исключительно с тем, что программа делает, а не с тем, как ею пользоваться. Ведь,
фактически, значительная часть кода Windows-приложения предназначена именно для организации ин-
терфейса с пользователем.
Хотя создание удобного интерфейса “под Windows” является основной задачей при написании лю-
бой Windows-программы, такой интерфейс не создается автоматически. То есть вполне можно написать
программу, в которой элементы интерфейса используются неэффективно. Чтобы этого избежать, необхо-
димо целенаправленно применять методику, описанную в данной книге. Только программы, написанные
таким способом, будут выглядеть, и работать действительно так, как надлежит Windows-программам.
Чтобы отойти от философии создания традиционного Windows-интерфейса, должны быть достаточ-
но веские основания. Иначе пользователи этой программы будут разочарованы. В общем, если програм-
мист собирается писать приложения для Windows, то он должен дать пользователям возможность рабо-
тать с обычным интерфейсом и руководствоваться стандартной методикой разработки.
Типы данных в Windows
В Windows-программах вообще (и в использующих библиотеку MFC в частности) не слишком широко
применяются стандартные типы данных из С или С++, такие как int или char*. Вместо них используются
типы данных, определенные в различных библиотечных (header) файлах. Наиболее часто используемыми
типами являются HANDLE, HWND, BYTE, WORD, DWORD, UNIT, LONG, BOOL, LPSTR и LPCSTR.
Тип HANDLE обозначает 32-разрядное целое, используемое в качестве дескриптора. Есть несколько по-
хожих типов данных, но все они имеют ту же длину, что и HANDLE, и начинаются с литеры Н. Дескрип-
тор – это просто число, определяющее некоторый ресурс. Например, тип HWND обозначает 32-
разрядное целое – дескриптор окна. В программах, использующих библиотеку MFC, дескрипторы приме-
няются не столь широко, как это имеет место в традиционных программах. Тип BYTE обозначает 8-
разрядное беззнаковое символьное значение, тип WORD – 16-разрядное беззнаковое короткое целое,
тип DWORD – беззнаковое длинное целое, тип UNIT - беззнаковое 32-разрядное целое. Тип LONG эк-
вивалентен типу long. Тип BOOL обозначает целое и используется, когда значение может быть либо ис-
тинным, либо ложным. Тип LPSTR определяет указатель на строку, а LPCSTR – константный (const) ука-
затель на строку.
Преимущества использования MFC
Как уже упоминалось, MFC – это базовый набор (библиотека) классов, написанных на языке С++ и
предназначенных для упрощения и ускорения процесса программирования для Windows. Библиотека со-
держит многоуровневую иерархию классов, насчитывающую около 200 членов. Они дают возможность
создавать Windows-приложения на базе объектно-ориентированного подхода. С точки зрения программи-
ста, MFC представляет собой каркас, на основе которого можно писать программы для Windows.
Библиотека MFC разрабатывалась для упрощения задач, стоящих перед программистом. Как из-
вестно, традиционный метод программирования под Windows требует написания достаточно длинных и
сложных программ, имеющих ряд специфических особенностей. В частности, для создания только каркаса
программы таким методом понадобится около 75 строк кода. По мере же увеличения сложности програм-
мы ее код может достигать поистине невероятных размеров. Однако та же самая программа, написанная
с использованием MFC, будет примерно в три раза меньше, поскольку большинство частных деталей
скрыто от программиста.
Одним из основных преимуществ работы с MFC является возможность многократного использова-
ния одного и того же кода. Так как библиотека содержит много элементов, общих для всех Windows-
приложений, нет необходимости каждый раз писать их заново. Вместо этого их можно просто наследовать
(говоря языком объектно-ориентированного программирования). Кроме того, интерфейс, обеспечиваемый
библиотекой, практически независим от конкретных деталей, его реализующих. Поэтому программы, на-
писанные на основе MFC, могут быть легко адаптированы к новым версиям Windows (в отличие от боль-
шинства программ, написанных обычными методами).
Еще одним существенным преимуществом MFC является упрощение взаимодействия с прикладным
программным интерфейсом (API) Windows. Любое приложение взаимодействует с Windows через API, ко-
торый содержит несколько сот функций. Внушительный размер API затрудняет попытки понять и изучить
его целиком. Зачастую, даже сложно проследить, как отдельные части API связанны друг с другом! Но по-

Выжол Ю.А.
Visual C++ Лекция 1 5
скольку библиотека MFC объединяет (путем инкапсуляции) функции API в логически организованное мно-
жество классов, интерфейсом становится значительно легче управлять.
Поскольку MFC представляет собой набор классов, написанных на языке С++, поэтому программы,
написанные с использованием MFC, должна быть в то же время программами на С++. Для этого необхо-
димо владеть соответствующими знаниями. Для начала необходимо уметь создавать собственные клас-
сы, понимать принципы наследования и уметь переопределять виртуальные функции. Хотя программы,
использующие библиотеку MFC, обычно не содержат слишком специфических элементов из арсенала
С++, для их написания тем не менее требуются солидные знания в данной области.

ВВЕДЕНИЕ В ОБЪЕКТНО-ОРИЕНТИРОВАННУЮ ПАРАДИГМУ

Термин "объектно-ориентированный" является сравнительно новым в компьютерной индустрии.
Компании активно работают, адаптируя эту технологию и интегрируя ее в существующие приложения.
Большинство создаваемых сегодня приложений фактически уже являются объектно-ориентированными.
Но что это такое?
Объектно-ориентированная парадигма представляет другой способ описания приложений. С помо-
щью объектно-ориентированного подхода приложение делится на множество маленьких кусочков, или
объектов, относительно независимых друг от друга. Готовое приложение можно затем создать, сложив эти
объекты вместе. Вспомните, как строится дом из блоков. Первым этапом является создание или покупка
нескольких базовых объектов – блоков различных типов. Полученные блоки можно сложить вместе и по-
строить целый дом. После того как вы разработали или приобрели базовые программные объекты, их
можно сложить вместе, создав таким способом новое приложение.
Одним из главных преимуществ объектно-ориентированной парадигмы является то, что можно раз-
работать компоненты только один раз и затем использовать их снова и снова. Точно так же, как одни и те
же строительные блоки многократно используются при строительстве замка, дома или космического ко-
рабля, основные элементы объектно-ориентированного проекта и кода можно многократно применять для
создания инвентарной системы, бухгалтерской системы или системы обработки заказов.
Итак, чем же объектно-ориентированная парадигма отличается от традиционного подхода к разра-
ботке приложений? В соответствии с традиционным подходом основное внимание должно уделяться ин-
формации, с которой работает система. Мы спрашиваем пользователей, какая информация им нужна,
проектируем базы данных для хранения этой информации, создаем экраны для ее вывода и встраиваем
возможность печати отчетов. Иначе говоря, прежде всего мы "фокусируемся" на самой информации, а
том, что с ней делать, т.е. поведению системы, уделяем меньше внимания. Такой подход называется о-
риентированным на данные (data-centric), он применялся при разработке тысяч различных систем в
течение многих лет.
Ориентированный на данные подход неоценим при проектировании баз данных и систем сбора ин-
формации, но при разработке бизнес-приложений возникают проблемы. Одной из главных является то,
что требования к системе могут со временем меняться. Система, ориентированная на данные, легко при-
спосабливается к изменениям базы данных, однако изменить деловые правила или поведение такой сис-
темы значительно труднее.
Для решения этой проблемы и была создана объектно-ориентированная парадигма. При этом под-
ходе внимание уделяется как информации, так и поведению, что позволяет создавать гибкие системы, до-
пускающие изменение их поведения и/или содержащейся в них информации.
Указанные преимущества могут быть реализованы только при правильном проектировании систем.
Это требует знания нескольких принципов объектно-ориентированного подхода: инкапсуляции, наследо-
вания и полиморфизма.
Инкапсуляция
В объектно-ориентированных системах данные комбинируются с конкретным поведением, т.е. с
действиями, осуществляемыми над ними. Все это объединяется в объект. Данный процесс называется
инкапсуляцией. По-другому ее можно описать, сказав, что мы разделяем приложение на небольшие
фрагменты связанной функциональности. Допустим, что у нас имеется информация, касающаяся банков-
ского счета: номер счета, баланс, имя и адрес владельца, тип счета, начисляемые на него проценты и да-
та открытия. Со счетом также связаны определенные действия: открыть, закрыть счет, положить или
снять некоторую сумму денег, изменить тип, владельца или адрес. Вся эта информация и действия (пове-
дение) совместно инкапсулируются в объект account (счет). В результате все изменения банковской сис-
темы, связанные со счетами, могут быть реализованы в одном только объекте account. Это напоминает
покупку всех необходимых товаров в одном магазине (one-stop shopping).
Еще одним преимуществом инкапсуляции является то, что она ограничивает последствия измене-
ний, вносимых в систему. Представьте себе, что система — это водоем, а изменения в требованиях к ней
– большой камень. Вы бросаете камень в воду, и огромные волны немедленно начинают распространять-

Выжол Ю.А.
Visual C++ Лекция 1 6
ся во всех направлениях. Они проходят по всему озеру, разбиваются о его берега, отражаются от них и
сталкиваются с другими волнами. Часть воды может даже выйти на берег. Иначе говоря, падение камня в
воду вызывает рябь. Теперь мы инкапсулируем озеро, разделив его на небольшие "фрагменты", разде-
ленные барьерами. Опять изменения в требованиях ударяют по системе. Бах!!! Во все стороны начинают
расходиться волны. Но теперь они не могут пройти за барьеры и останавливаются там. Таким образом,
инкапсулировав озеро, мы ограничили эффект ряби от падения камня
Теперь применим идею инкапсуляции к банковской системе. Допустим, управление банка постано-
вило, что если клиент имеет кредитный счет, этот кредит может быть использован как овердрафт на его
счете "до востребования". В неинкапсулированной системе мы начинаем с узконаправленного анализа
изменений, которые необходимо внести в систему. Как правило, мы не знаем, где в системе находятся все
обращения к функции снятия со счета, поэтому приходится искать их везде. После того как они найдены,
мы должны внести в них некоторые изменения, чтобы реализовать новые требования. Если мы работаем
тщательно, то, вероятно, сможем обнаружить около 80% случаев использования данной функции. В ин-
капсулированной системе не требуется проводить такой детальный анализ. Мы смотрим на модель сис-
темы и выявляем, где инкапсулировано соответствующее поведение (действие снятия со счета). После
его локализации остается внести требуемые поправки один раз только в этом объекте, и наша задача вы-
полнена! Как видно на рис.1, в модификации нуждается только класс Account (Счет).
Инкапсуляция подобна понятию сокрытия информации (information hiding). Это возможность скры-
вать многочисленные детали объекта от внешнего мира. Внешним миром объекта является все то, что
находится вне объекта, включая остальную часть системы. Сокрытие информации предоставляет то же
преимущество, что и инкапсуляция – гибкость. Эта концепция рассматривается подробнее в последующей
работе.

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

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

Выжол Ю.А.
Visual C++ Лекция 1 7
теристики. Он порождает объекты-потомки: "кошка", "собака", "человек", "кит" и другие. Объект "собака"
наследует характеристики объекта "млекопитающие", но в то же время имеет и свои собственные, напри-
мер бегание по кругу и пускание слюней. Объектно-ориентированная парадигма переняла идею наследо-
вания у природы, так что мы можем применять эту концепцию к нашим системам.
Одним из основных преимуществ механизма наследования является простота его поддержки. Когда
происходит событие, влияющее на всех млекопитающих, изменение надо внести только в родительский
объект, а все потомки автоматически его наследуют. Если млекопитающие, например, внезапно станут
холоднокровными, достаточно будет изменить объект "млекопитающие". Кошка, собака, человек, кит и все
другие объекты-потомки автоматически наследуют новую характеристику.
В качестве примера наследования в объектно-ориентированных системах можно привести окна. До-
пустим, имеется большая система, содержащая 125 окон. Однажды потребовалось вывести во всех окнах
сообщение. В системе без наследования придется внести изменение в каждое из этих 125 окон – доволь-
но трудоемкая задача. В объектно-ориентированной системе окна являются потомками какого-то общего
предка. Все, что требуется сделать в таком случае, – внести изменение в родителе. Остальные окна ав-
томатически наследуют его.
В банковской системе наследование можно применять для работы с различными типами счетов.
Наш гипотетический банк обслуживает четыре типа счетов: до востребования (checking), сберегательный
(savings), кредитный (credit) и депозитный сертификат. Эти различные типы счетов имеют сходные черты,
к которым относятся номер счета, ставка процента и владелец. Итак, можно создать родительский объект
account (счет) с общими характеристиками всех счетов. Объекты-потомки будут иметь наследуемые и
свои собственные уникальные характеристики. Например, кредитный счет будет содержать лимит кредита
и размер минимального взноса, а депозитный сертификат – срок платежа. Изменения в родительском
объекте повлияют на всех потомков, но потомки могут адаптироваться и самостоятельно, не влияя друг на
друга и на своего предка.
Полиморфизм
Третий принцип объектной ориентации – это полиморфизм. В словаре данный термин определен как
проявление различных форм, стадий или типов. Полиморфизм означает наличие множества форм или
реализации конкретной функциональности. Как и в случае наследования, полиморфизм можно наблюдать
в природе. Получив команду или реализуя функцию "Говорить", человек может ответить "Как дела?", со-
бака скажет "Гав", кошка – "Мяу", или скорее всего просто проигнорирует вас.
В терминах объектно-ориентированных систем это означает, что конкретные функциональные воз-
можности могут иметь множество реализации. Допустим, что мы разрабатываем систему рисования гра-
фиков. Когда пользователь хочет что-то начертить – будь то линия или прямоугольник, система должна
выполнить команду Draw (нарисовать). Наша система включает множество типов различных форм, каждая
из которых содержит поведение, позволяющее ей нарисовать себя. Итак, когда пользователь хочет начер-
тить круг, запускается команда draw() объекта "круг". С помощью полиморфизма система определяет, ка-
кую фигуру она должна нарисовать. Без полиморфизма код функции draw() выглядит приблизительно
следующим образом:
Function Shape.drawMe()
{
CASE Shape.Type
Case "Circle" Shape. drawCircle();
Case "Rectangle" Shape. drawRectangle();
Case "Line" Shape. drawLlne();
END CASE
}
При использовании полиморфизма код для рисования представляет собой обращение к функции
drawMe() вычерчиваемого объекта, например:
Function draw()
{
Shape.drawMe();
}
При этом каждая форма (круг, линия, прямоугольник и т.д.) должна содержать собственную функцию
drawMe() для ее рисования.
Одним из преимуществ полиморфизма, как и других принципов объектной ориентации, является
простота поддержки. Что случится, например, если потребуется нарисовать треугольник? Если полимор-
физм не используется, придется добавить к объекту Shape новую функцию drawTriangle(). Кроме того, не-
обходимо будет модифицировать функцию drawMe() этого объекта, чтобы привести в соответствие с но-
вым типом формы. При применении полиморфизма достаточно создать новый объект "треугольник" с

Выжол Ю.А.
Visual C++ Лекция 1 8
функцией drawMe() для рисования. Функцию Draw(), инициирующую операцию рисования, изменять не
требуется.

Выжол Ю.А.