Реклама
d-link 860
Спонсорские ссылки
-
Статья
Версия для печати
Обсудить на форуме
Виртуальные функции. Что это такое? Часть 1


Часть 1. Общая теория виртуальных функций


Посмотрев на название этой статьи, вы можете подумать: "Хм! Кто же не знает, что такое виртуальные функции! Это же..." Если это так, можете смело бросить чтение прямо на этом месте.

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

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

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

Так что же это такое?


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

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

Ну вот, а теперь к делу!

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



В программе объекты этих классов могут быть объявлены, например, таким образом.
Код:
A object_A; //объявление объекта типа А
B object_B; //объявление объекта типа В
C object_C; //объявление объекта типа С

Согласно данному правилу указатель типа А может ссылаться на любой из этих трех объектов. То есть вот это будет верным:
Код:
A *point_to_Object; // объявим указатель на базовый класс
point_to_Object=&object_C; //присвоим указателю адрес объекта С
point_to_Object=&object_B; //присвоим указателю адрес объекта В

А вот это уже не правильно:
Код:
В *point_to_Object; // объявим указатель на производный класс
point_to_Object=&object_А; //нельзя присвоить указателю адрес базового объекта

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

Этот принцип становится особенно важным, когда в классах, связанных наследованием определяются виртуальные функции. Виртуальные функции имеют точно такой же вид и программируются так же, как и самые обычные функции. Только их объявление производится с ключевым словом virtual. Например, наш базовый класс А может объявить виртуальную функцию v_function().
Код:
class A
{
  public:
   virtual void v_function(void);//функция описывает некое поведение класса А
};

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

Если в классе В, порожденном от класса А нужно описать коке-то другое поведение, то можно объявить виртуальную функцию, названную опять-таки v_function().
Код:
class B: public A
{
  public:
   virtual void v_function(void);//замещающая функция описывает некое
                                 //новое поведение класса В
};

Когда в классе, подобном В, определяется виртуальная функция, имеющая одинаковое имя с виртуальной функцией класса-предка, такая функция называется замещающей. Виртуальная функция v_function()в В замещает виртуальную функцию с тем же именем в классе А. На самом деле все несколько сложнее и не сводится к простому совпадению имен. Но об этом чуть позже, в разделе "Некоторые тонкости применения".
Ну, а теперь самое важное!

Вернемся к указателю point_to_Object типа А*, который ссылается на объект object_В типа В*. Давайте внимательно посмотрим на оператор, который вызывает виртуальную функцию v_function()для объекта, на который указывает point_to_Object.
Код:
A *point_to_Object; // объявим указатель на базовый класс
point_to_Object=&object_B; //присвоим указателю адрес объекта В
point_to_Object->;v_function(); //вызовем функцию

Указатель point_to_Object может хранить адрес объекта типа А или В. Значит во время выполнения этот оператор point_to_Object-gt;v_function(); вызывает виртуальную функцию класса на объект которого он в данный момент ссылается. Если point_to_Object ссылается на объект типа А, вызывается функция, принадлежащая классу А. Если point_to_Object ссылается на объект типа В, вызывается функция, принадлежащая классу В.  Итак, один и тот же оператор вызывает функцию класса адресуемого объекта. Это и есть действие, определяемое во время выполнения программы.

Ну и что нам это дает?


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

Классический пример (по моему опыту - в 90% всей литературы по С++), который приводят в этих целях - написание графической программы. Строится иерархия классов, что-то типа "точка -gt; линия -gt; плоская фигура -gt; объемная фигура". И рассматривается виртуальная функция, скажем, Draw(), которая рисует все это... Скучно!

Давайте рассмотрим менее академичный, но все же графический пример. (Классика! Куда от нее деться?). Попробуем рассмотреть гипотетически принцип, который может быть заложен в компьютерную игру. И не просто в игру, а в основу любого (не важно 3D или 2D, крутого или так себе) шутера. Стрелялки, проще говоря. Я не кровожаден по жизни, но, грешен, люблю иногда постреляться!

Итак, мы задумали сделать крутой шутер. Что понадобиться в первую очередь? Конечно же оружие! (Ну, пусть не в первую. Не важно.) В зависимости от того, на какую тему будем сочинять, такое оружие и понадобится. Может это будет набор от простой дубины до арбалета. Может от аркебуза до гранатомета. А может и вовсе от бластера до дезинтегратора. Скоро мы увидим, что это-то как раз и не важно.

Что же, раз есть такая масса возможностей, надо завести базовый класс.
Код:
class Weapon
{
   public:
      ... //тут будут данные-члены, которыми может описываться, например, как
        //толщина дубины, так и количество гранат в гранатомете
        //эта часть для нас не важна

      virtual void Use1(void);//обычно - левая кнопка мыши
      virtual void Use2(void);//обычно - правая кнопка мыши

      ... //тут будут еще какие-то данные-члены и методы
};

Не вдаваясь в подробности этого класса, можно сказать, что самыми важными, пожалуй, будут функции Use1() и Use2(), которые описывают поведение (или применение) этого оружия. От этого класса можно порождать любые виды вооружения. Будут добавляться новые данные-члены (типа количества патронов, скорострельности, уровня энергии, длинны лезвия и т.п.) и новые функции. А переопределяя функции Use1() и Use2(), мы будем описывать различие в применении оружия (для ножа это может быть удар и метание, для автомата - стрельба одиночными и очередями).

Коллекцию вооружения надо где-то хранить. Видимо, проще всего организовать для этого массив указателей типа Weapon*. Для простоты предположим, что это глобальный массив Arms, на 10 видов оружия, и все указатели для начала инициализированы нулем.
Код:
Weapon *Arms[10]; //массив указателей на объекты типа Weapon

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

Для того чтобы указать, какое оружие находится в пользовании, заведем переменную-индекс массива, значение которой будем изменять в зависимости от выбранного вида оружия.
Код:
int TypeOfWeapon;

В результате этих усилий, код, описывающий применение оружия в игре может выглядеть, например, так:
Код:
if(LeftMouseClick) Arms[TypeOfWeapon]-gt;Use1();
else Arms[TypeOfWeapon]->Use2();

Все! Мы создали код, который описывает стрельбу-пальбу-войну еще до того, как решили, какие типы оружия будут использоваться. Более того. У нас вообще еще нет ни одного реального типа вооружения! Дополнительная (иногда очень важная) выгода - этот код можно будет скомпилировать отдельно и хранить в библиотеке. В дальнейшем вы (или другой программист) можете вывести новые классы из Weapon, сохранить их в массиве Arms[] и использовать. При этом не потребуется перекомпиляции вашего кода.

Особо заметьте, что этот код не требует от вас точного задания типов данных объектов на которые ссылаются указатели Arms[], требуется только, чтобы они были производными от   Weapon. Объекты определяют во время выполнения, какую функцию Use() им следует вызвать.

Некоторые тонкости применения


Давайте немного времени уделим проблеме замещения виртуальных функций.

Вернемся к началу - к скучным классам А, В и С. Класс С на данный момент стоит у нас в самом низу иерархии, в конце линии наследования. В классе С точно также можно определить замещающую виртуальную функцию. Причем применять ключевое слово virtual совсем необязательно, поскольку это конечный класс в линии наследования. Функция и так будет работать и выбираться как виртуальная. Но! А вот если вам приспичит вывести некий класс D из класса С, да еще и изменить поведение функции v_function(), то тут как раз ничего и не выйдет. Для этого в классе С функция v_function() должна быть объявлена, как virtual. Отсюда правило, которое можно сформулировать так: "единожды виртуальный - всегда виртуальный!". То есть, ключевое слово virtual лучше не отбрасывать - вдруг пригодится?

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

Далее. Если в производном классе ввести функцию с тем же именем и типом возвращаемого значения, что и виртуальная функция базового класса, но с другим набором параметров, то эта функция производного класса уже не будет виртуальной. Даже если вы сопроводите ее ключевым словом virtual, она не будет тем, что вы ожидали. В этом случае с помощью указателя на базовый класс при любом значении этого указателя будет выполняться обращение к функции базового класса. Вспомните правило о перегрузке функций! Это просто разные функции. У вас получится совсем другая виртуальная функция. Вообще говоря подобные ошибки весьма трудноуловимы, поскольку обе формы записи вполне допустимы и надеяться на диагностику компилятора в этом случае не приходится.

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

И еще. Виртуальной функцией может быть только нестатическая компонентная функция класса. Виртуальной не может быть глобальная функция.  Виртуальная функция может быть объявлена дружественной (
Код:
friend
) в другом классе. Но о дружественных функциях мы поговорим как ни будь  в другой статье.

Вот, собственно, и все на этот раз.

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

При написании этого материала использовались следующие книги:

Tom Swan "Mastering Borland C++ 5"
Перевод - Диалектика, Киев, 1996

В.В. Подбельский "Язык С++" 5-е издание
Издание - Москва, "Финансы и статистика", 2001

Paul Kimmel "Using Borland C++ 5" Special Edition
Перевод - "BHV Санкт-Петербург", 1997

Если у вас есть вопросы - пишите, будем разбираться.

Сергей Малышев (aka Михалыч).
Версия для печати
Обсудить на форуме