32. Полиморфизм.

Полиморфизм (polymorphism) (от греческого polymorphos) - это свойство, которое позволяет одно и то же имя использовать для решения двух или более схожих, но технически разных задач. Целью полиморфизма, применительно к объектно-ориентированному программированию, является использование одного имени для задания общих для класса действий. Выполнение каждого конкретного действия будет определяться типом данных. Например для языка Си, в котором полиморфизм поддерживается недостаточно, нахождение абсолютной величины числа требует трёх различных функций: abs(), labs() и fabs(). Эти функции подсчитывают и возвращают абсолютную величину целых, длинных целых и чисел с плавающей точкой соответственно. В С++ каждая из этих функций может быть названа abs(). Тип данных, который используется при вызове функции, определяет, какая конкретная версия функции действительно выполняется. В С++ можно использовать одно имя функции для множества различных действий. Это называется перегрузкой функций (function overloading).

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

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

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

33. Виртуальная функция.

Виртуальные функции преодолевают сложности решения с пмощью полей типа, позволяя программисту описывать в базовом классе функции, которые можно переопределять в любом проиводном классе. Компилятор и загрузчик обеспечивают правильное соответствие между объектами и применяемыми к ним функциями. Например: struct employee (* employee* next; char* name; short department; // ... virtual void print(); *); Ключевое слово virtual указывает, что могут быть разлиные варианты функции print() для разных производных классов, и что поиск среди них подходящей для каждого вызова print() является задачей компилятора. Тип функции описывается в базвом классе и не может переописываться в производном классе. Виртуальная функция должна быть определена для класса, в ктором она описана впервые. Например: void employee::print() (* cout «„ e-“name „„ „\t“ «« e-“department «« «\n“; // ... *) Виртуальная функция может, таким образом, использоваться даже в том случае, когда нет производных классов от ее класа, и в производном классе, в котором не нужен специальный вариант виртуальной функции, ее задавать не обязательно. Просто при выводе класса соответствующая функция задается в том случае, если она нужна. Например: struct manager : employee (* employee* group; short level; // ... void print(); *); void manager::print() (* employee::print(); cout «„ „\tуровень“ «« level «« «\n“; // ... *) Функция print_employee() теперь не нужна, поскольку ее место заняли функции члены print(), и теперь со списком слжащих можно работать так: void f(employee* ll) (* for (; ll; ll=ll-»next) ll-»print(); *) Каждый служащий будет печататься в соответствии с его типом. Например: main() (* employee e; e.name = «Дж.Браун»; e.department = 1234; e.next = 0; manager m; m.name = «Дж.Смит»; e.department = 1234; m.level = 2; m.next = amp;e; f( amp;m); *) выдаст Дж.Смит 1234 уровень 2 Дж.Браун 1234 Заметьте, что это будет работать даже в том случае, если f() была написана и откомпилирована еще до того, как проиводный класс manager был задуман! Очевидно, при реализации этого в каждом объекте класса employee сохраняется некоторая информация о типе. Занимаемого для этого пространства (в ткущей реализации) как раз хватает для хранения указателя. Это пространство занимается только в объектах классов с виртуалными функциями, а не во всех объектах классов и даже не во всех объектах производных классов. Вы платите эту пошлину только за те классы, для которых описали виртуальные функции. Вызов функции с помощью операции разрешения области вдимости ::, как это делается в manager::print(), гарантирует, что механизм виртуальных функций применяться не будет. Иначе manager::print() подвергалось бы бесконечной рекурсии. Примнение уточненного имени имеет еще один эффект, который может оказаться полезным: если описанная как virtual функция описна еще и как inline (в чем ничего необычного нет), то там, где в вызове применяется ::, может применяться inline-подстновка. Это дает программисту эффективный способ справляться с теми важными специальными случаями, когда одна виртуальная функция вызывает другую для того же объекта. Поскольку тип объекта был определен при вызове первой виртуальной функции, обычно его не надо снова динамически определять другом вызове для того же объекта.

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

Приведенный пример в определенной мере отражает смысл применения раннего и позднего связывания, соответственно. Очевидно, что для данного примера первый вариант оптимален. Во втором случае мы слишком много всего предусмотрели, но нам это не понадобилось. С другой стороны, если по дороге на рынок мы решим, что апельсины нам не нужны и решим купить 10 кг. яблок, то в первом случае мы уже не сможем этого сделать. Во втором же случае - легко.

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

Таким образом, во время раннего связывания вызывающий и вызываемый методы связываются при первом удобном случае, обычно при компиляции.

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

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

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

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

Приведем определение виртуальных методов:

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

Адрес виртуального метода известен только в момент выполнения программы. Когда происходит вызов виртуального метода, его адрес берется из таблицы виртуальных методов своего класса. Таким образом вызывается то, что нужно.

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

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

#include <iostream.h> // подключение стандартной библиотек С++, в

// которой описаны некоторый функции, применяемые в программе

class vehicle // класс "транспортное средство"

{

int wheels;

float weight;

public: // начало публичного(открытого) раздела класса

virtual void message(void) {cout << "Транспортное средство\n";}

// описание виртуальной функции message класса vehicle и реализация этой

// функции. При вызове функции message класса vehicle на экран монитора

// будет выведена строка "Транспортное средство"

};

class car : public vehicle // класс "легковая машина", унаследованный из

// класса "транспортное средство"

{

int passenger_load;

public: // начало публичного(открытого) раздела класса

void message(void) {cout << "Легковая машина\n";}

// описание виртуальной функции message класса car и реализация этой

// функции. При вызове функции message класса car на экран монитора

// будет выведена строка " Легковая машина "

};

class truck : public vehicle // класс "грузовая машина", унаследованный из

// класса "транспортное средство"

{

int passenger_load;

float payload;

public: // начало публичного(открытого) раздела класса

int passengers(void) {return passenger_load;}

};

class boat : public vehicle // класс "лодка", унаследованный из

// класса "транспортное средство"

{

int passenger_load;

public: // начало публичного(открытого) раздела класса

int passengers(void) {return passenger_load;}

void message(void) {cout << "Лодка\n";}

// описание виртуальной функции message класса boat и реализация этой

// функции. При вызове функции message класса boat на экран монитора

// будет выведена строка "Лодка"

};

void main() // основной исполняемый блок программы

{

vehicle *unicycle; // описываем переменной unicycle как указатель на

// объект класса vehicle

unicycle = new vehicle; // Создаем объект класса vehicle,

// указатель unicycle указывает на этот объект

unicycle->message(); // вызываем метод message объекта

delete unicycle; // удаляем объект unicycle

// Все последующие блоки по 3 строки абсолютно идентичны первому

// блоку с той лишь разницей, что изменяется класс создаваемого объекта

// на car, truck, boat

unicycle = new car;

unicycle->message();

delete unicycle;

unicycle = new truck;

unicycle->message();

delete unicycle;

unicycle = new boat;

unicycle->message();

delete unicycle;

}

Результаты работы программы(вывод на экран):

Транспортное средство

Легковая машина

Транспортное средство

Лодка

Рассмотрим приведенный пример. У нас есть три класса car, truck и boat, которые являются производными от базового класса vehicle. В базовом классе vehicle описана виртуальная функция message. В двух из трех классов(car, boat) также описаны свои функции message, а в классе truck нет описания своей функции message. Все строки, к которым я не приводил комментарии, не имеют принципиального для данного примера значения. Теперь пробежимся по основному блоку программы - функции main(). Описываем переменную unicycle, как указатель на объект типа vehicle. Не буду вдаваться в подробности, почему именно указатель на объект. Так надо. В данном случае воспринимайте работу с указателем, как с самим объектом. Подробности работы с указателями можно найти в описаниях конкретного языка ООП. Затем, создаем объект класса vehicle, переменная unicycle указывает на этот объект. После этого вызываем метод message объекта unicycle, а в следующей строке удаляем этот объект. В следующих трех блоках по 3 строки проводим аналогичные операции, с той лишь разницей, что работаем с объектами классов car, truck, boat. Применение указателя позволяет нам использовать один и этот же указатель для всех производных классов. Нас интересует вызов функции messageдля каждого из объектов. Если бы мы не указали, что функция message класса vehicle является виртуальной(virtual), то компилятор статически(жестко) связал бы любой вызов метода объекта указателя unicycle с методомmessage класса vehicle, т.к. при описании мы сказали, что переменная unicycle указывает на объект класса vehicle. Т.е. произвели бы раннее связывание. Результатом работы такой программы был бы вывод четырех строк "Транспортное средство". Но за счет применения виртуальной функции в классе мы получили несколько другие результаты.

При работе с объектами классов car и boat вызываются их собственные методы message, что и подтверждается выводом на экран соответствующих сообщений. У класса truck нет своего метода message, по этой причине производится вызов соответствующего метода базового класса vehicle.

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

Виртуальные методы описываются с помощью ключевого слова virtual в базовом классе. Это означает, что в производном классе этот метод может быть замещен методом, более подходящим для этого производного класса. Объявленный виртуальным в базовом классе, метод останется виртуальным для всех производных классов. Если в производном классе виртуальный метод не будет переопределен, то при вызове будет найден метод с таким именем вверх по иерархии классов (т.е. в базовом классе).