Полиморфизм. Виртуальные функции

Концепция полиморфизма является очень важной в ООП. Этот термин, как показано выше, используется для описания процесса, при котором различ­ные реализации функции могут быть доступны с использованием одного имени. В С++ полиморфизм поддерживается и во время компиляции, и во время испол­нения программы. Рассмотренные выше перегрузки функций и операций — это примеры полиморфизма во время компиляции.

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

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

1. Имеются отличия в типах параметров в объявлении функции, напри­мер, при перегрузке функций – Show(int, char) и Show(int, *char) не одно и то же.

2. Задана операция доступа к области действия, поэтому Circle::Show отличается от Point::Show и::Show.

3. Объект класса идентифицирует метод: Acircle.Show вызывает метод Circle::Show, а Apoint.Show – Point::Show. Аналогично и в случае указа­телей на объекты: pointptr->Show инициирует Point::Show.

 

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

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

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

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

 

Указатели на производные типы.

Для лучшего понимания виртуальных функций важно понимать принцип взаимодействия классов в С++, связанных отношением наследования — указа­тели на базовый тип и на производный тип зависимы: указатель на базовый класс может ссылаться на объект этого класса или любой объект производного класса, но указатель производного класса не может ссылаться на объекты базового класса:

Объект базового класса

Указатель на базовый класс Объект производного Указатель на

класса производный

Объект производного класс

класса

Пусть есть цепь наследования классов: А <- B <- C. В программе объекты классов могут объявляться так:

A obA; B obB; C obC;

A* p; // объявлен указатель на базовый класс типаA *

p = &obB; // указателю р присвоен адрес объекта obB

Объект obB можно представлять как особый вид объекта класса А (так зо­лотая рыбка — особая разновидность рыб, но это рыба). Но объект типа А не является особым видом объектов классов В и С. Например, вы обладаете мно­гими чертами ваших родителей, наследуемых от них и их родителей (цвет во­лос, глаз). Ваши родители и их родители – часть вас, но вы не являетесь их ча­стью.

Все элементы класса С, наследуемые от классов А и В, могут быть до­ступны через использование указателя р. Однако на элементы, объявленные (собственные) в классе С нельзя ссылаться, используя р. Если требуется иметь доступ к элементам, объявленным в производном классе, используя указатель на базовый класс, его надо привести к указателю на производный класс так:

((С*)р) -> f(), где функция f() является элементом класса С, причем внешние скобки необходимы. И, наконец, указатель р изменяется при операци­ях ++ и -- относительно базового класса.

Пример 31.

Рассмотрим программу использования указателей на базовый класс из производных классов по цепи наследования: Base <- Derive <- Derive1.

#include<iostream.h>

#include<conio.h>

#include<stdio.h>

class Base // базовый класс Base

{ public:

void show(void)

{ cout<<"In Base class\n"; }

};

class Derive: public Base // производный класс от Base

{ public:

void show(void)

{ cout<<"In Derive class\n"; }

};

class Derive1: public Derive // производный класс от Base, Derive

{ public:

void show(void)

{ cout<<"In Derive1 class\n"; }

};

 

void main() // главная функция

{ clrscr();

Base bobj, *pb; // объект и указатель базового класса

Derive dobj, *pd; // объекты и указатели производных классов

Derive1 d1obj, *pd1;

 

pb=&bobj; // указатель на объект класса Base

bobj.show(); // вызов объектом функции show() класса Base

pb->show(); // вызов указателем функции show() класса Base

 

pd=&dobj; // указатель на объект класса Derive

dobj.show(); // вызов объектом функции show() класса Derive

pd->show(); // вызов указателем функции show() класса Derive

 

pd1=&d1obj; // указатель на объект класса Derive1

d1obj.show(); // вызов объектом функции show() класса Derive1

pd1->show(); // вызов указателем функции show() класса Derive1

 

pb=&dobj; // базовый указатель на объект класса Derive

pb->show(); // вызов указателем функции show() класса Base!

 

pb=&d1obj; // базовый указатель на объект класса Derive1

pb->show(); // вызов указателем функции show() класса Base!

 

((Derive1 *)pb)->show(); // вызов show() класса Derive1 указателем Base,

// приведенным к типу Derive1

getch();

}

Результаты программы:

In Base class

In Base class

In Derive class

In Derive class

In Derive1 class

In Derive1 class

In Base class!

In Base class!

In Derive1 class

 

Виртуальные функции.

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

Виртуальная функция должна быть элементом класса (она не может иметь спецификатор friend). Однако виртуальная функция может быть "другом" другого класса. Допустимо, чтобы деструктор имел спецификатор virtual, од­нако для конструктора это запрещено. Вследствие запретов и различий между перегрузкой обычных функций и переопределением виртуальных функций для них часто используется термин " замещение " (overriding).

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

 

Пример 32.

Модифицируем программу примера 31 так, что в классе Base объявим функцию show() как виртуальную:

class Base // базовый класс Base

{ public:

virtual void show(void) // виртуальная функция класса

{ cout<<"In Base class\n";}

};

В главной функции исключим операторы вызова объектом функции show() (например, bobj.show(); и др.) и оставим вызовы функции show() толь­ко с помощью указателей (pb->show(); и др.).

 

Результаты программы примера 32:

In Base class

In Derive class

In Derive1 class

In Derive class

In Derive1 class

 

Особенность использования виртуальных функций — при вызове функ­ции, объявленной виртуальной, определяется версия функции в зависимости от того, на объект какого класса будет ссылаться указатель базового класса.

Базовый класс задает основной интерфейс виртуальных функций, кото­рый будут иметь производные классы. Но производные классы задают свой ме­тод согласно принципу полиморфизма: " один интерфейс – разные методы". Отделение интерфейса и реализации функций позволяет создавать библиотеки классов (class libraries).

Возникает вопрос: как осуществляется вызов виртуальной функции для активного объекта? Реализации компиляторов пользуются технологией преоб­разования имени виртуальной функции в индекс в таблице, содержащей указа­тели на функции, называемой " таблицей виртуальных функций" (virtual function table — vtbl). Каждый класс с виртуальными функциями имеет свою vtbl, иден­тифицирующую его виртуальные функции. Это можно изобразить схематиче­ски:

Объект класса Base: vtbl:

	*pf1	f1()
	*pf2	f2()

 

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

 

Пример 33.

Рассмотрим программу использования виртуальных функций при расши­ряющемся наследовании. Базовый класс Figure описывает плоскую фигуру для вычисления площади, которой достаточно двух измерений. Виртуальная функ­ция show_area() печатает значение площади фигуры. На основе этого класса создаются производные классы – Triangle (треугольник), Rectangle (прямо­угольник), Circle (круг с одним измерением), в которых определены конкретные формулы (методы) вычисления площадей. Классы связаны расширяющимся на­следованием по схеме: Figure <- (Triangle, Rectangle, Circle).

 

#include<iostream.h>

#include<conio.h>

class Figure // базовый класс

{ protected: // защищенные элементы, доступные в производных классах

double x, y;

public:

void set_dim (double i, double j=0) // 2-й параметр по умолчанию

{ x = i, y = j; } // задание измерений фигур

virtual void show_area() // виртуальная функция Figure

{ cout<<"Площадь не определена для Figure\n";}

};

class Triangle: public Figure // производный класс

{ public:

void show_area() // виртуальная функция Triangle

{ cout<<"Треугольник с высотой "<< x <<" и основанием "<< y;

cout<<" имеет площадь = "<< x*0.5*y <<"\n";

}

};

class Rectangle: public Figure // производный класс

{ public:

void show_area() // виртуальная функция Rectangle

{ cout<<"Прямогольник со сторонами "<< x <<" и "<< y;

cout<<" имеет площадь = "<< x*y <<"\n";

}

};

class Circle: public Figure // производный класс

{ public:

void show_area() // виртуальная функция Circle

{ cout<<"Круг с радиусом "<< x;

cout<<" имеет площадь = "<< 3.14*x*x <<"\n";

}

};

void main ()

{ clrscr();

Figure f, *p; // объявление объекта и указателя класса Figure

Triangle t; // объявление объекта класса Triangle

Rectangle r; // объявление объекта класса Rectangle

Circle c; // объявление объекта класса Circle

p = &f; // указатель базового типа Figure

p -> set_dim (1,2); // задание размерностей объекта Figure

p -> show_area(); // вывод сообщения о площади объекта типа Figure

p = &t; // базовый указатель на объект типа Triangle

p -> set_dim (3,4); // задание размерностей объекта типа Triangle

p -> show_area(); // вывод сообщения о площади объекта типа Triangle

p = &r; // базовый указатель на объект типа Rectangle

p -> set_dim (5,6); // задание размерностей объекта типа Rectangle

p -> show_area(); // вывод сообщения о площади объекта типа Rectangle

p = &c; // базовый указатель на объект типа Circle

p -> set_dim (2); // задание размерностей объекта типа Circle

p -> show_area(); // вывод сообщения о площади объекта типа Circle

getch(); // задержка экрана результатов

}

Результаты программы:

Треугольник с высотой 3 и основанием 4 имеет площадь = 6

Прямогольник со сторонами 5 и 6 имеет площадь = 30

Круг с радиусом 2 имеет площадь = 12.56

 

Пример 34.

Рассмотрим программу использования виртуальных функций в классах с конструкторами. Вводится базовый класс Value, который задает некоторое зна­чение. В этом классе описана виртуальная функция getvalue(), печатающая по­лученное значение. На основе этого класса строится производный класс Mult, вычисляющий произведение двух чисел. Он тоже имеет виртуальную функцию. Оба класса используют конструкторы.

 

#include<iostream.h>

#include<conio.h>

class Value // базовый класс

{ protected:

int value;

public:

Value (int n) { value = n; } // конструктор с параметром

virtual int getvalue () { return value; } // виртуальная функция

};

class Mult: public Value // производный класс

{ protected:

int mult;

public:

Mult (int n, int m): Value (n) // конструктор производного класса

{ mult = m;}

int getvalue () { return value * mult;}

};

void main ()

{ clrscr ();

cout<<"Работа программы";

Value *basep; // указатель базового типа

basep = new Value (10); // дин-ое создание объекта класса Value

cout<<"Для базового класса Value число = "<<basep->getvalue()<<endl;

delete basep; // освобождение динамической памяти объекта Value

basep = new Mult (10, 2); // базовый указатель на объект типа Mult

cout<<"Для производ. класса Mult число = "<<basep->getvalue()<<endl;

delete basep; //освобождение динамической памяти объекта типа Mult

}

Результаты программы:

Работа программы

Для базового класса Value число = 10

Для производ. класса Mult число = 20

 

Обычные или виртуальные функции.

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

Предположим, что объявляется класс Base с методом Action. Должен ли он быть виртуальным? Общее правило: если существует вероятность, что в производном от Base классе будет использована функция, перекрывающая Action, которой нужен доступ к Base, то Action должна быть виртуальной. Но она должна быть обычной функцией, если очевидно, что в производных типах Action будет выполнять те же действия (даже если это вызывает инициацию других виртуальных функций) или же производные типы не будут пользовать­ся Action.