ООП / учебное_пособие

class circl : public base // производный класс «окружность»

{ int r; public:

virtual char *name(){ return " круга ";} circl(int R): r(R){}

double area(){ return 3.14*r*r;}

};

int main()

{ base *p[N],a; double s_area=0; rect b(2,3);

circl c(4);

for(int i=0;i<N;i++) p[i]=&a; p[0]=&b;

p[1]=&c;

for(i=0;i<N;i++)

cout << "плошадь" << p[i]->name() << p[i]->area() << endl; return 0;

}

Массив указателей p хранит адреса объектов базового и производных классов и необходим для вызова виртуальных функций этих классов. Виртуальная функция базового класса необходима тогда, когда она явно вызывается для базового класса или не определена (не переопределена) для некоторого производного класса.

Если функция была объявлена как виртуальная в некотором классе (базовом классе), то она остается виртуальной независимо от количества уровней в иерархии классов, через которые она прошла.

class A

{. . .

public: virtual void fun() {}

};

class B : public A

{. . .

public: void fun() {}

};

class C : public B

{. . .

public:

. . . // в объявлении класса С отсутствует описание функции fun()

};

main()

81

{ A a,*p=&a;

}

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

class A

{. . .

public: virtual void fun() {}

};

class B : public A

{. . .

public: void fun() {}

};

class C : public B

{. . .

public: void fun() {}

};

int main()

{A a,*p=&a; B b;

C c;

}

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

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

class A

{ public :

82

virtual void f()

{return; } void fn()

{f(); } // вызов функции f

};

class B : public A

{ public: void f()

{return; } void fn()

{f(); } // вызов функции f

};

int main()

{A a,*pa=&a; B b,*pb=&b;

pa->fn(); // вызов виртуальной функции f класса А через A::fn() pa = &b;

pa->fn(); // вызов виртуальной функции f класса В через A::fn()

pb->fn(); // вызов виртуальной функции f класса В через B::fn()

}

Винструкции pa->fn() выполняется вызов функции fn() базового класса А, так как указатель pa – указатель на базовый класс и компилятор выполняет вызов функции базового класса. Далее из функции fn() выполняется вызов вначале виртуальной функции f() класса А, так как указатель pa инициализирован адресом объекта класса А. Затем, после инициализации pa адресом объекта класса В выполняется вызов виртуальной функции f() класса В из функции fn() класса А. Далее, используя указатель pb, инициализированный также адресом объекта класса В, вызывается функция f() класса В через функцию fn() класса В.

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

#include <iostream> using namespace std;

class Base { public:

Base()

{ cout << " конструктор базового класса"<<endl; f1();

}

~Base()

{ cout << " деструктор базового класса"<<endl;

83

f2();

}

virtual void f1() { cout << " функция f1 базового класса"<<endl; } virtual void f2() { cout << " функция f2 базового класса "<<endl; } void f3(){ cout<<" функция f3 базового класса "<<endl;

f1();

}

};

class Derived : public Base

{public:

Derived()

{cout<<"конструктор производного класса "<<endl; } ~Derived()

{cout<<"деструктор производного класса "<<endl; }

virtual void f1() { cout << " функция f1 производного класса"<<endl; } virtual void f2() { cout << " функция f2 производного класса"<<endl; }

};

int main()

{ cout << "создание обекта"<<endl;

Derived *pd = new Derived(); pd->f3();

cout << "разрушение объекта"<<endl; delete pd;

}

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

создание обекта" конструктор базового класса функция f1 базового класса

конструктор производного класса функция f3 базового класса функция f1 производного класса разрушение объекта деструктор производного класса деструктор базового класса функция f2 базового класса

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

Аналогично в деструкторе вызывается функция базового класса, потому как объект производного класса был уже уничтожен (был вызван его деструк-

84

тор).

Перечислим основные свойства и правила использования виртуальных функций:

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

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

-виртуальные функции можно объявить только в классах (class) и струк-

турах (struct);

-виртуальными функциями могут быть только нестатические функции (без спецификатора static), так как характеристика virtual унаследуется. Функция порожденного класса автоматически становится virtual;

-виртуальные функции можно объявить со спецификатором friend для другого класса;

-виртуальными функциями могут быть только неглобальные функции (т.е. компоненты класса);

-если виртуальная функция, объявленная в базовом классе со спецификатором virtual, переопределена в производном без спецификатора virtual, то она при этом остается виртуальной независимо от уровня наследования. То есть механизм виртуализации функций наследуется;

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

-при использовании полного имени при вызове некоторой виртуальной функции (например grup ::see();) виртуальный механизм не применяется.

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

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

virtual прототип функции = 0;

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

85

base a;

base *p= new base;

компилятор выдаст сообщение об ошибке. В то же время вполне можно использовать инструкции вида

rect b;

base *p=&b; base &p=b;

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

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

class base

{компоненты-данные public:

virtual ~base() = 0;

компоненты-функции

}

base ::~base()

{реализация деструктора}

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

Для иерархии типа полезно иметь базовый абстрактный класс. Он содержит общие свойства порожденных объектов и используется для объявления указателей, которые могут обращаться к объектам классов, порожденным от базового. Рассмотрим это на примере программы экологического моделирования. В примере мир будет иметь различные формы взаимодействия жизни с использованием абстрактного базового класса living. Его интерфейс унаследован различными формами жизни. Создадим fox (лис) – хищника, rabbit (кролик) – жертву и grass – (траву).

#include <iostream> using namespace std; #include <conio.h>

//моделирование хищник − жертва с использованием

//иерархии классов

void living::sums(world w,int sm[])

{int i,j; sm[EMPTY]=sm[GRASS]=sm[RABBIT]=sm[FOX]=0; int i1=-1,i2=1,j1=-1,j2=1;

for(i=i1;i<=i2;++i)

for(j=j1;j<=j2;++j) sm[w[row+i][col+j]->who()]++;

}

В базовом классе living объявлены две чисто виртуальные функции − who() и next() и одна обычная функция sums(). Моделирование имеет правила для решения о том, кто продолжает жить в следующем цикле. Они основаны на соседствующих популяциях в некотором квадрате. Глубина иерархии наследования – один уровень.

// текущий класс − только хищники class fox:public living

{ protected:

int age; // используется для принятия решения о смерти лиса public:

87

return(new empty(row,col));

}

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

else

return(new rabbit(row,col,age+1)); // кролик постарел

else return (new empty(row,col));// иначе пусто

}

Массив world представляет собой контейнер для жизненных форм. Он должен иметь в собственности объекты living, чтобы распределять новые и удалять старые.

// world полностью пуст void init(world w)

89

{ int i,j; for(i=0;i<N;++i)

for(j=0;j<N;++j) w[i][j]=new empty(i,j);

}

// генерация исходной модели мира void gener(world w)

{int i,j; for(i=0;i<N;++i)

for(j=0;j<N;++j)

{if(i%2==0 && j%3==0) w[i][j]=new fox(i,j);

else if(i%3==0 && j%2==0) w[i][j]=new rabbit(i,j); else if(i%5==0) w[i][j]=new grass(i,j);

else w[i][j]=new empty(i,j);

}

}

// вывод содержимого модели мира на экран void pr_state(world w)

{ int i,j; for(i=0;i<N;++i)

{cout<<endl;

for(j=0;j<N;++j)

w[i][j]->print();

}

cout << endl;

}

//новый world w_new рассчитывается из старого world w_old void update(world w_new, world w_old)

{ int i,j; for(i=0;i<N;++i)

for(j=0;j<N;++j) w_new[i][j]=w_old[i][j]->next(w_old);

}

//очистка мира

void dele(world w) { int i,j;

for(i=1;i<N-1;++i) for(j=1;j<N-1;++j) delete(w[i][j]);

}

90