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

Модель имеет odd и even мир. Их смена является основой для расчета последующего цикла.

int main()

{getch();

cout<<i+2<<" цикл жизни модели"<<endl; if(i%2)

{ update(even,odd); pr_state(even); dele(odd);

}

else

{ update(odd,even); pr_state(odd); dele(even);

}

}

return 0;

}

4.4. Виртуальные деструкторы

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

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

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

#include <iostream>

91

#include <iomanip> using namespace std; #include <string.h>

Shape(char *fig) : s(0)

{cout << "конструктор класса Shape (фигура "<< fig <<')'<< endl;} virtual ~Shape()

{cout << "деструктор класса Shape" << endl;}

void virtual print() {cout<<s<<endl;} void virtual area()=0;

};

class Circle : public Shape // производный класс «круг»

{ int r; public:

Circle(char *name,int r): Shape(name)

{cout << "конструктор класса Circle "<<endl; this->r=r;

}

~Circle()

{ cout << "деструктор класса Circle " << endl;} void area();

};

class Bar : public Shape // производный класс «прямоугольник»

{ int n,m; public:

Bar(char *name,int n,int m): Shape(name)

{ cout << "конструктор класса Bar "<<endl; this->n=n;

this->m=m;

}

~Bar()

{ cout << "деструктор класса Bar " << endl;} void area();

};

void Circle::area()

{s=r*r*3.14; cout<<"Площадь круга = "; this->print();

92

}

void Bar::area()

{s=n*m;

cout<<"Площадь прямоугольника = "; this->print();

}

int main()

{Shape *fg1,*fg2; fg1=new Circle("Круг",2);

fg2=new Bar("Прямоугольник",3,4);

fg1->area(); fg2->area(); delete fg1; delete fg2; return 0;

}

Результат работы программы: конструктор класса Shape (фигура Circle) конструктор класса Circle

конструктор класса Shape (фигура Bar) конструктор класса Bar

площадь круга =12.56 площадь прямоугольника =12 деструктор класса Circle деструктор класса Shape деструктор класса Bar деструктор класса Shape

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

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

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

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

class имя_произв_класса : имя_базового_кл 1,…,имя_базового_кл N { содержимое класса

93

};

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

Конструкторы базовых классов при создании объекта производного класса вызываются в том порядке, в котором они указаны в списке при объявлении производного класса.

При применении множественного наследования возможно возникновение нескольких конфликтных ситуаций. Первая − конфликт имен методов или атрибутов нескольких базовых классов:

class A

{public: void fun(){} };

class B

{public: void fun(){} };

class C : public A, public B

{ };

int main()

{ C *c=new C;

c->fun(); // error C::f' is ambiguous return 0;

}

При таком вызове функции fun() компилятор не может определить, к какой из двух функций классов A и B выполняется обращение. Неоднозначность можно устранить, явно указав, какому из базовых классов принадлежит вызываемая функция:

c->A:: fun(); или c->B::fun();

Вторая проблема возникает при многократном включении некоторого базового класса:

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

A(char *NAZ) {strcmp(naz,NAZ);}

~A() {cout << "деструктор класса А" << endl;} void a_prnt() {cout << naz << endl;}

{ protected: long tn; int nom;

public:

B1(char *NAZ,long TN,int NOM): A(NAZ),tn(TN),nom(NOM) {};

~B1() {cout << "деструктор класса В1" << endl;} void b1_prnt()

{ A::a_prnt();

cout << " таб. N " << tn <<" подразделение = " << nom <<endl;

}

B2(char *NAZ,double ZP): A(NAZ),zp(ZP) {};

~B2(){cout << "деструктор класса В2" << endl;} void b2_prnt()

{A::a_prnt();

cout << " зар/плата = " << zp << endl;

}

};

class C : public B1, public B2 // производный класс ( III уровня) { char *fam;

public:

C(char *FAM,char *NAZ,long TN,int NOM,double ZP) : B1(NAZ,TN,NOM), B2(NAZ,ZP)

{fam = new char[strlen(FAM)+1] strcpy(fam,FAM);

};

~C() {cout << "деструктор класса С" << endl;} void c_prnt()

{B1::b1_prnt(); B2::b2_prnt();

cout << " фамилия " << fam<<endl;

}

};

int main()

{ C cc("Иванов","мастра",1234,2,555.6),*pt=&cc;

// cc.a_prnt(); ошибка 'C::a_prnt' is ambiguous // pt->a_prnt();

cc.b1_prnt();

95

pt->b1_prnt(); cc.b2_prnt(); pt->b2_prnt(); cc.c_prnt(); pt->c_prnt(); return 0;

}

В приведенном примере производный класс С имеет по цепочке два одинаковых базовых класса А (A<-B1<-C и A<-B2<-C), для каждого базового класса А строится свой объект (рис. 3, 4). Таким образом, вызов функции

cc.a_prnt(); pt->a_prnt();

некорректен, так как неизвестно, какую из двух функций (какого из двух классов А) требуется вызвать.

C

Рис. 3. Структура объекта

Рис. 4. Иерархия классов

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

Если базовый класс (в приведенном выше примере это класс А) является виртуальным, то будет построен единственный объект этого класса (см. рис. 2).

A() {cout<<"Конструктор1 класса A"<<endl;}

A(int AA) : aa(AA) {cout<<"Конструктор2 класса A"<<endl;} ~A() {cout<<"Деструктор класса A"<<endl;}

};

class B : virtual public A // производный класс (первый базовый для D) { char bb;

public:

B() {cout<<"Конструктор1 класса B"<<endl;}

B(int AA,char BB): A(AA), bb(BB)

{cout<<"Конструктор2 класса B"<<endl;}

96

~B() {cout<<"Деструктор класса B"<<endl;}

};

class C : virtual public A // производный класс (второй базовый для D) { float cc;

public:

C() {cout<<"Конструктор1 класса C"<<endl;}

C(int AA,float CC) : A(AA), cc(CC)

{cout<<"Конструктор2 класса C"<<endl;} ~C() {cout<<"Деструктор класса C"<<endl;}

};

class D : public C,public B // производный класс (II уровня)

{ int dd; public:

D() {cout<<"Конструктор 1 класса D"<<endl;}

D(int AA,char BB,float CC,int DD) : A(AA), B(AA,BB), C(AA,CC), dd(DD)

{cout<<"Конструктор 2 класса D"<<endl;} ~D() {cout<<"Деструктор класса D"<<endl;}

Деструктор класса C

Деструктор класса A

Виртуальный базовый класс всегда инициализируется только один раз. В примере при создании объектов d и dd конструктор класса А вызывается из конструктора класса D первым и только один раз, затем − конструкторы клас-

97

сов B и C, в том порядке, в котором они описаны в строке наследования классов:

class D : public B, public C .

Водно и то же время класс может иметь виртуальный и невиртуальный базовые классы, например:

class A{ … };

class B1: virtual public A{ … }; class B2: virtual public A{ … }; class B3: public A{ … };

class C: public B1, public B2, public B3 { … };

Вэтом случае класс С имеет два подобъекта класса А, один наследуемый через классы В1 и В2 (общий для этих классов) и второй через класс В3

(рис. 5, 6).

Рис. 5. Структура объекта при виртуальном наследовании Рис. 6. Иерархия классов при

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

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

{naz=new char[strlen(NAZ)+1]; strcpy(naz,NAZ);

}

~A()

{delete naz;

cout << "деструктор класса А" << endl;

}

void a_prnt(){cout <<"марка а/м "<< naz << endl;}

};

class B1 : virtual public A // производный класс (1 базовый II уровня)

{ protected:

B1(char *NAZ,char *CV,int KOL): A(NAZ),kol(KOL)

{cv=new char[strlen(CV)+1]; strcpy(cv,CV);

}

~B1()

{delete cv; ;

cout << "деструктор класса В1" << endl;

}

void b1_prnt()

{A::a_prnt();

cout << "цвет а/м" << cv <<" кол-во дверей " << kol <<endl;

}

};

class B2 : virtual public A // производный класс (2 базовый II уровня)

B2(char *NAZ,int POW,double RS): A(NAZ),pow(POW),rs(RS) {};

~B2(){cout << "деструктор класса В2" << endl;} void b2_prnt()

{A::a_prnt();

cout <<"мощность двигателя "<<pow<<" расход топлива "<<rs; cout<<endl;

}

};

class C : public B1,public B2 //производный класс (2 Базовый II уровня)

{ char *mag; // название магазина

public: C(char *NAZ,char *CV,int KOL,int POW,double RS,char *MAG): B1(NAZ,CV,KOL),B2(NAZ,POW,RS),A(NAZ)

{mag =new char[strlen(MAG)]; strcpy(mag,MAG);

}

~C()

{delete mag;

cout << "деструктор класса С" << endl;

}

void c_prnt()

{A::a_prnt(); B1::b1_prnt(); B2::b2_prnt();

cout << " название магазина" << mag <<endl;

}

99

};

void main()

{C cc("BMW","красный",100,4,8.5,"магазин 1"),*pt=&cc; cc.a_prnt();

pt->a_prnt(); cc.b1_prnt(); pt->b1_prnt(); cc.b2_prnt(); pt->b2_prnt(); cc.c_prnt();

pt->c_prnt();

}

Вопросы и упражнения для закрепления материала

1.Модификаторы доступа и наследования. Как изменяются атрибуты элементов класса при наследовании?

2.Что такое виртуальная функция?

3.Какие функции не могут быть виртуальными?

4.Чем виртуальные функции отличаются от перегружаемых?

5.В чем состоит различие раннего и позднего связывания?

6.Что такое абстрактный класс и чем может быть вызвана необходимость построений абстрактного класса?

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

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

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

10.Возникнут ли ошибки при компиляции данной программы, если нет, то что она выведет на экран:

#include <iostream> using namespace std;

100