5.2. Виртуальные функции. Абстрактные классы

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

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

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

virtual void print() const;

//////////////////////////////////////////////

void main ()

{

// виртуальные функции важны, когда создаются указатели на класс

Detail *p=new Lens;

}

//////////////////////////////////////////////

Реализация функции в базовом классе не изменится, а классе-наследнике и реализация и описание функции останется прежним.

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

Detail *p=new Lens;

При этом:

• Если должны вызываться "родные" функции-члены классов, то используется обычная перегрузка

l.print(); // Detail::print

• Если функция-член базового класса должна подменяться функцией-членом класса-наследника, то при ее объявлении используется модификатор virtual

l.print(); // Lens::print

l.print(); // Lens::print

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

Detail::print();

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

5.2.2. Абстрактные классы

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

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

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

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

Рассмотрим как будет выглядеть описание абстрактного базового класса Деталь из примера 5.1. Реализация базоваго класса, и описание и реализация классов-наследников не изменятся.

/////////////////////////////////////////////////////////////////////////////

// класс Деталь - базовый класс для всех оптических деталей

class Detail

{

protected:

// координата детали по оси z

double m_z;

// диаметр детали

double m_D;

public:

// конструкторы и деструктор

Detail();

Detail(double z, double D);

virtual ~Detail();

// установить диаметр детали

void Set_D(double D);

// получить диаметр детали

double Get_D() const;

// установить координату по оси z

void Set_z(double z);

// получить координату по оси z

double Get_z() const;

// печать параметров детали

virtual void print() const;

// вычисление хода луча через деталь

// должно быть реализовано во всех классах-наследниках

virtual void RayTrace() = 0;

};

/////////////////////////////////////////////////////////////////////////////

Тестирующая функция для абстрактного класса:

///////////////////////////////////////////////////////////////////////

void main()

{

// массив указателей на детали

vector<Detail*> details(2);

// первый элемент - линза

details[0] = new Lens;

// второй элемент - зеркало

details[1] = new Mirror;

// печать всех деталей

cout<<"-------------------------"<<endl;

for(size_t i=0; i<details.size(); ++i)

{

details[i]->print();

}

// расчет хода луча через все детали

cout<<"-------------------------"<<endl;

for(size_t i=0; i<details.size(); ++i)

{

details[i]->RayTrace();

}

// освобождение памяти для всех деталей (вызов деструкторов)

cout<<"-------------------------"<<endl;

for(size_t i=0; i<details.size(); ++i)

{

delete details[i];

}

}

/////////////////////////////////////////////////////////////////////////////