Реализация динамического полиморфизма

Размещено на http://www.allbest.ru/

Реализация динамического полиморфизма



Содержание

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

Множественное наследование

Адреса базовых классов

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



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

Абстрактным называется класс, который содержит как минимум одну чистую виртуальную функцию.

Чисто виртуальная функция - это виртуальная функция, для которой программист не планирует иметь каких-либо реализаций. Объявление такой функции имеет следующий вид:

class Employee

{

private:

char name[40];

public:

Employee(char *n);

// чистая виртуальная функция

virtual void* promote()=0;

};

Для абстрактного класса не могут быть созданы объекты.

Employee s("My name")

//вызовет ошибку

Но программа может объявить указатель абстрактного класса, например

Employee *sPtr;

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

class Secretary : public Employee

{

private:

int MoreDate;

public:

Secretary(char *n):Employee(n) {}

virtual void* promote() {};

};

Secretary sec("Another Name");

Адрес объекта Secretary может быть передан в функцию, которая ожидает передачи Employee:

void fn(Employee*);

Secretary sec("Another Name");

fn(&sec);

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

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

Конструкторы не могут быть виртуальными. Производный класс не наследует конструкторы базового класса, поэтому бессмысленно делать их виртуальными.



Множественное наследование

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

Class Subclass:public Base1, private Base2

{//остальная часть определения класса

}

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

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

1) Конструкторы всех виртуальных базовых классов; если их более одного, то конструкторы вызываются в порядке их наследования;

2) Конструкторы невиртуальных базовых классов в порядке их наследования;

3) Конструкторы всех компонентных классов.

#include<iostream>

struct Base1

{Base1(){cout<<"Создание Base1"<<endl;

};

struct Base2

{Base2(){cout<<"Создание Base2"<<endl;

};

struct Base3

{Base3(){cout<<"Создание Base3"<<endl;

};

struct Base4

{Base4(){cout<<"Создание Base4"<<endl;

};

struct Derived:private Base1, private Base2, private Base3

{Base4 anObject;

Derived(){};

};

void main()

{ Derived anObject;

}

Конструкторы вызовутся в порядке: Base1, Base2, Base3, Base4. Добавление в конструктор для Derived конкретных вызовов с другим порядком и повторение программы не изменит сообщения на выходе этой программы. Например:

struct Derived:private Base1, private Base2, private Base3

{Base4 anObject;

Derived(): anObject(), Base3(), Base2(), Base1() {};

};

void main()

{ Derived anObject;

}

Только изменение порядка наследования классов изменит последовательность появления сообщений на выходе программы.

Последовательность вызова деструкторов будет обратной последовательности вызовов конструкторов.



Адреса базовых классов

Основная проблема возникает в связи со способом размещения производных классов в памяти.

struct Base

{

int a;

float b;

void f1();

};

struct Derived:public Base

{int c;

} object;

Схема размещения в памяти простого производного класса:

Если Derived* передан в функцию, ожидающую получения Base*, то проблем не будет, так как их адреса совпадают.

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

struct Base1

{

int a;

float b;

void f1();

};

struct Base1

{

int с;

float в;

void f2();

};

struct Derived:public Base1, public Base2

{int e;

} object;

Схема размещения в памяти класса Derived:

Если Derived* передан в функцию, ожидающую Base1*, то проблем не будет, если же Derived* передан в функцию, ожидающую Base2*, то так как их адресы не совпадают, возникает ошибка. Чтобы исправить этот адрес, необходимо прибавить к адресу Derived::object смещение Base2 Derived, таким образом, чтобы результат указывал на ту часть, которая относится к Base2. Такая же коррекция должна выполняться для каждого случая приведения типа указателей из Derived* в Base2*, включая и скрытый указатель this, передаваемый компонентным функциям Base2.

По тем же причинам С++ также должен выполнить коррекцию и при обратном приведении типа из Base2* в derived*



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

Рассмотрим пример.

struct Base

{

int object;

};

struct FirstBase : public Base

{

int a;

};

struct SecondBase : public Base

{

float b;

};

class Derived : public FirstBase, public SecondBase

{

long dObject;

};

Схема размещения в памяти класса Derived:



Чтобы позволить наследование в таких случаях одной и той же копии Base, в C++ необходимо включить в команду наследования ключевое слово virtual.

struct Base

{

int object;

};

struct FirstBase : virtual public Base

{

int a;

};

struct SecondBase : virtual public Base

{

float b;

};

class Derived : virtual public FirstBase, virtual public SecondBase

{

long dObject;

};

Схема размещения в памяти класса Derived в этом случае:

Теперь осталась одна копия объекта Base.

Правило isA()

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

Для решения этой проблемы программист должен определить правило идентификации, обычно называемое isA(). Это виртуальное правило возвращает константу, которая является уникальной для каждого типа подкласса. абстрактный виртуальный реализация наследование

Пример.

#include <iostream>

using namespace std;

struct Base

{

enum ClassType{BASE,SUBCLASS};

virtual ClassType isA()

{

return BASE;

}

};

struct SubClass:public Base

{

virtual ClassType isA()

{

return SUBCLASS;

}

};

void print(Base& obj)

{

if(obj.isA()==Base::BASE) cout<<"Это объект ,fpjdjuj rkfccf\n";

else if (obj.isA()==Base::SUBCLASS)

cout<<"Это объект подкласса\n";

else cout<<"Это неизвестный тип объекта\n";

}

void fn(Base& obj)

{

print(obj);

}

int main()

{

Base aBaseClass;

SubClass aSubClass;

fn(aBaseClass);

fn(aSubClass);

return 0;

}

Размещено на Allbest.ru

...