Віртуальні конструктори та диструктори.Клонування.

П-д:

class array_stack

{char *V;

array_stack (int size);

{ V=new char [size];}

~array_stack ()

{ delete V;}};

Приклад віртуального деструктора:

Class emploee{…}

Class manager:public emploee {..} //уфігурни дужках може бути наприклад int level;i nt*Listofsub.

Void f()

{emploee *p=new manager;

delete p; //size of (*p)}

class emploee

{public:virtual ~emploee(){};}

Це був приклад з порожнім деструктором.

Void manager::~manager()

{delete Listofsub;}

Приклад віртуального конструктора:

Class A{…}

Class B: public A{…};

A*p;

А

p

B

Маємо покажчик,але не знаємо на об”єкт якого типу-в цьому полягає віртуальність.

Постановка задачі для віртуал.конструкторів.Е-покажчик на якийсь об”кт,не відомо на який,треба створити екзкмпляр такого самого типу.Конструктор така ф-ція,що брати адресу чи застосовувати до нього операцію & компілятор не дозволяє.

Приклад:

Class A

{public: A();

virtual A*New obj ();};

class B: public A

{public: B();

virtual B*Newobj()

{return NewB};};

A*p;

P=New B;

A*g=p->Newobj();

B*pb;

… …

pa=pb;

Клонування:

Це створення ідентичної копії,для цього можна використовувати віртиальніконструктори.

Приклад:

Е-екземпляр якогось типу,треба не зная покажчика створити екземпляр цього ж самого типу та скопіювати його.

Схема:

Class C: public B

{public: C();

virtual C*Newobj()

{return New(c);}

virtual C*clone();

private:

void copi(B*);

A*pa=NewC(p1,p2,…,pn);

.......

A*pc=pa->clone(); //не знаємо тип ра}

Приклад клонування бынарного дерева

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

Class BinTree

{BinTree *left ,* right;

public: BinTree ();

BinTree (BinTree*l, BinTree*r);

Void copy(BinTree*t);virtual

BinTree ();

Typedef int Tinfo;

Class BinTreeInfo: public BinTree

{Tinfo*info;

public: BinTree Info();

BinTree Info (BinTree Info*l;

BinTree Info*r;

Tinfo*int);}

Void copy (BinTree *t);

Virtual BinTree Info*clone();};

Використання:

BinTree * BinTree::clone()

{ BinTree*tmp; //Тимчасовий

tmp=New BinTree;

//tmp->left=left; //не скопіювали

 

 

Ефективний доступ до членів класу.Дружні ф-ії та дружні класи.

Якщо тіло ф-ії оголошується в тілі класа то така ф-ія називається вбудованною.Від звичайного описання ф-ії вбудована відрізняється тим що в головній програмі:

- компілятор має більшу змогу оптимізації;

-вбудована ф-ія не

використовує стек;

Замість вбудованої ф-ії вставляється її тіло при копмпіляції,тому що при потребі відкомппілювати головну програму повинно бути тіло вбудованної ф-ії. Прототип вбудованної ф-ії - inline.Описання ф-ії можно не вносити в описання класу,але треба додати специфікатор inline.

П-д:

Void main ()

{g(par1,par2,…parN);}

Порядок обчислення параметрів справа наліво перед викликом ф-ії. Ф-ії члени класу та не члени класу.

П-д: class complex

{ public:

complex operator +(complex b);};//не дружня ф-ія

Розглянемо використання:

Void f()

{ complex a,b,c;

….

c=a+b;//ok!

c=a+2;//треба конструктор який 2 перетворює в class complex

c=2+a;//треба змінювати тип першого операнда

В останньому прикладі треба зробити так:

Class complex

{ float Re,Im;

public:

complex operator +=

(complex b);

{ Re+=b.Re;

Im+=b.Im;

return *this;}};

Якщо всеж нам потрібно виконати:

2+complex треба використати не члени класу.

Complex operator + (complex a, complex b);

Complex operator + (complex, double);

Complex operator +

(double, complex);

Дружні ф-ії та дружні класи.

Дружня ф-ія -це така ф-ія,яка оголошується в оголошенні класу з0 описувачем friend

П-д:class C

{ public:

…..

friend void f();}

friend вказує на те що ф-ія має доступ до всіх полів класу на рівні з ф-ми-членами класу.

Дружні ф-ії потрібні для того щоб дозволити доступ іншим ф-ям(не зовсім

Довільний доступ)до полів класу.Якщо хтось змінить тіло дружньої ф-ії то треба перекомпілювати всі модулі які використовують члени класу.П-д:

class Vector

{ int *V;

int size;

public:

Vector (…) //конструктор

Int elem(int i);

Class matrix

{Vector *m;

int size2;

public:

int elem(int x,int y);

void f()

{ matrix M;

Vector V,V2;

…..

V2=M*V;

Дружні ф-ії має сенс описувати для зручносту доступу.Дружня ф-ія може бути дружня для декількох класів.Може

Бути декілька дружніх ф-ій для одного класу.Навіть можна для одного класу оголосити дружнім інший клас.

 

Множинне наслідування.

Приведення показчиків при множинному наслідуванні.

С

¯ ¯

А В

¯ ¯

L L

Неявні перетворення:

С*pc = newC;

L*pl;

pl=pc; //err! так як не зрозуміло до якого класу перетворювати

pl=(A*)pc; // ok!

Pl=(L*)(A*)pc; // ok!

Явні перетворення:

//"manageremployer"

// pm=(manager *)pl;

pc=pl; // err!

a=(C*)pl; //err!через неоднозначність

pc=(C*)(B*)pl; //ok!

Усунення неоднозначності при визові ф-ій базового класу при множинному наслідуванні:

info{L,A,B,C}::f();

info*C::f()

{info*pi1=A::f();

info*pi2=B::f();

return merge(pi1,pi2);}

//info-інформація що повертає ф-ія,merge- злиття інформації

class employer

{ public: void f();}

class manager:public

employer

{public: vod f();}

void manager::f()

{ employer:: f();

….};

Приклад змінної ієрархії:

class foreman:: public

employer

{ public: void f();};

class manager:public

foreman

{ public: void f();};

class foreman:public

employer

{ typedef employer

inherited;

public:

void f ()

{interited:: f();

……}};

class manager:public foreman

{ typedef employer

inherited;

public:

void f ()

{interited:: f();

……}};

interited введений для того щоб коли додасться ще один клас можна було змінити лише foreman

 

Віртуальні базові класи.

V

­ ­

V A B

­ ­ ­

D¾C

Virtual -фактичний

class A:public virtual V;

class A:public virtual V;

class A:public virtual V;

Віртуальні базові класи потрібні для того щоб можна було спільну інформацію для класів А і В розділяти не використовуючи

virtual.Це можна зробити так:

class A

{ friend class V;};

class V

{ friend class A;};

Або використати глобальні змінні.

Завдяки віртуальності можна добитися того щоб базовий клас входив один раз

 

Перевантаження функцій.

Для будь-якого типу Т,типи Т, constT,T& мають одну і ту саму мн-ну ініціалізуючих значень.

Int i; void f (int i);

Const int i; void f(int &i); int f i –винекне помилка або не мож-ливість відрізнити.

Для будь-якого типу Т,типи Т&,const T&,volatile T& є різними.У ланцюжку наслідува-ння класів одне і те саме ім’я ф. в різних кл. не перевантажуєть-ся,а перекривається.

Class X1

{void f(int f);}

classX9:public X8

{void f(double);}

void q(X9*p)

{p->f(2);}