Functii Vituale Suprascriere Polimorfism

7/25/2019 Functii Vituale Suprascriere Polimorfism

1/43

1

#include using namespace std;

class Baza{protected: int atr1;

public: Baza(int i):atr1(i){} void afsare(){cout


2/43

"e#area $ Bindin#

! conectarea unui apel de 4unctie cu 4unctia in sine (adresa 4unctiei)5

.6ista doua tipuri de legare:

7 statia/ti%purie(la compilare)

7 dina%ia/tarzie(in momentul e6ecutie)

"e#are statia/ti%purie (earl& bindin#)

- se realizeaza la compilare$ inainte de rularea aplicatiei

- de catre compilator si editorul de legaturi (lin8er)

- in li%ba'ul 9 toate apelurile de 4unctii presupun realizareaunei legaturi statice

4unctie(); se 4ace legatura intre apel si implementarea


3/43

7 in plus$ in avem 4unctii membre:

1 - 4unctiile membre ale unei clase primesc adresa obiectului care4ace apelul:

tip2date ob;

ob4unctie();

7 in 4unctie de tipul obiectului de la acea adresa 7 compilatorul sieditorul de legaturi stabilesc daca:

7 4unctie() e membra a clasei tip2date (e declarata)

7 este implementata

7 daca e implementata$ se 4ace legarea statica si se poate apela

acea 4unctie

7 daca 4unctia era declarata ca membra a clasei$ dar nu e

implementata


4/43

!-in cazul apelului prin intermediul pointerilor :

tip2date2baza &ob!ne tip2date;

ob->4unctie();

se intampla acelasi lucru:

- compilatorul si editorul de legaturi stabileasc daca 4unctiainvocata de un pointer este de tipul acelui pointer(adica daca

aceasta poate f apelata)- mai e6act$ compilatorul 4oloseste tipul stati al pointerului

(tipul de care a 4ost declarata variabila) pentru a determina dacainvocarea 4unctiei membre este legala

- este fresc$ ca$ in cazul in care pointerul poate sa 4oloseasca acea

4unctie$ orice obiect derivat adresat de acel pointer sa o poatautiliza la randul sau

tip2date2derivat d;

ob!?d;

ob7>4unctie(); tipul pointerului este


5/43

0n programul anterior:

Baza &bp!ne Baza();

bp=new Derivata(1,1);//B: spune% a bp aretipul stati: Baza si tipul dina%i:

Derivata

bp->afsare();

//se apeleaza Baza::afsare()

- legatura intre numele 4unctiei si corpul ei se 4ace in mod static (in

4unctie de tipul static al lui bp)

- in acest caz se apeleaza 4unctia afsare() din clasa Baza5

d l 4 i d f bi l


6/43

D. daa vre% sa apelam 4unctia de afsare pentru obiectul catre care

pointeaza bp

!> trebuie sa 4acem o conversie e6plicita a pointerului bp din (Baza&) in

("erivata&):

((Derivata*)bp)->afsare();

ast4el incat legatura sa se 4aca pentru tipul de date al obiectului catre

care pointeaza bp5

7 aceasta solutie nu e robusta

7 trebuie mereu sa ne punem problema catre ce tip de obiect pointeaza

pointerul de tip clasa de baza si sa 4acem conversii e6plicite pentru a

apela 4unctia dorita

7 solutia e predispusa erorilor lo#ie


7/43

"e#are dina%ia/tarzie

7 le#area se 0ae dupa o%pilare, la rulare

- in 0untie de tipul dina%i al pointerului (tipul obietului

atre are se pointeaza)

- se poate realiza doar in ontetul apelului de 0untii prin

inter%ediul pointerilor

*entru a 4olosi un ast4el de mecanism$ o%pilatorul trebuie sa fe

in0or%at ca e6ista posibilitatea ca$ in momentul rularii$ sa se

doreasca apelarea unei 4unctii de tipul dinamic al obiectului5

"eoarece nu se cunoaste inca tipul obiectului catre care se va pointa

de7a lungul e6ecutie programului$ o%pilatorul si lin+erul nu

trebuie sa i%ple%enteze le#atura statia


8/43

0n e6emplul anterior bp pointa initial catre un obiect de tip Baza si apoi

catre un obiect de tip "erivata5

rebuie sa se astepte pana in %o%entul rularii ca sa se a2e are e

tipul dina%i al pointerului si sa 4oloseasca 4unctia

corespunzatoare5

*entru aceasta este nevoie de un semnal introdus in cod 7 >0untii

virtuale5

"e#area dina%ia poate f i%ple%entata doar in azul

li%ba'elor o%pilate3

#i l d i t


9/43

C

#include using namespace std;class Baza{protected: int atr1;

public: Baza(int i):atr1(i){}

virtualvoid afsare() { cout


10/43

5untii virtuale si suprainararea/suprasriereae este o 0untie virtuala4

7 4unctiile virtuale sunt cea mai importanta caracteristica a limbaului3@@ (pdpv al *EE)

- 4unctiiile virtuale permit claselor derivate sa inlocuiascaimplementarea metodelor din clasa de baza 9

suprasriere/suprainarare/override

uprasrierea/suprainararea 0untiilor*resupune ca intr7o ierar6iede clase sa avem:

1 0untii u aelasi nu%e, se%natura si tip returnat in lasa debaza si derivate

5 dar u i%ple%entari speife lasei din care 4ac parte (ganditi7vala afsare() din Baza si "erivata )

F5 4unctii declarate ca virtuale

Daa 1,!,7 =>0untii suprainarate

"aca 1 si 9 4unctii redefnite


11/43

8n azul 0untiilor virtuale:

7 compilatorul se asigura ca i%ple%entarea 6e%ata este cea pentru

tipul dina%i al obiectului care 4ace apelul5

B: 3and avem un pointer de tipul clasei de baza care adreseaza un

obiect$ obiectul poate f de tipul clasei de baza sau derivate5

(9:Baza& care pointeaza initial catre un obiect de tip Baza si apoi catre

un obiect de tip "erivata5)

-e poate vorbi de doua tipuri in cazul pointerului bd:

- stati7 tipul pointerului (Baza&$ in acest caz)

- dina%i 7 tipul obiectului catre care pointeaza (intai Baza apoi"erivata)5

3ompilatorul nu are cum sa prevada catre cine pointeaza bp de7a lungul

implementarii 7 asa ca nu stie (pana in momentul rularii) care 4unctie de


12/43

8nsaeste in4ormat sa nu implementeze o legatura timpurie intre apelul

afsare() si corpul 4unctiei de afsare din Baza$ ci sa astepte pana in

momentul rularii prin cuvantul c%eie virtual pus in 4ata 4unctiei

afsare()5

+st4el$ prin le#area dina%ia sau tarzie (late$dnamic binding)$ la

e6ecutiei se va decide care e tipul dinamic al pointerului si se va 4ace

legarea cu implementarea din clasa precizata de tipul dinamic5

"e#area dina%ia se poate 0ae doar 0olosind 0untii

virtuale si pointeri

2222222222222222222222222222222222222222222222222222222222222222222222222

B: 0ntr7o ierar%ie de clase este normal ca obiectele rezultate (de tip

baza si derivate) sa aiba comportamente similare (nu identice)$ iarcomportamentele sa fe specializate in 4unctie de tipul clasei5

.6: 0ntr7o clasa derivata vrem sa afsam toate atributele acelei clase$ nu

doar cele mostenite din clasa de baza$ dar 4unctia se va numi tot

afsare$ va ascunde implementarea din clasa de baza$ si va avea uncom ortament un ic di4erit5


13/43

bservatii:

15 5untiile %e%bre nevirtuale sunt tratate stati 9 in momentul

compilarii : in 4unctie de tipul static al pointerului se vor apela metodele

specifce acelui tip static de date5

5 5untiile %e%bre virtuale sunt tratate dina%i9 in momentul

rularii : in 4unctie de tipul dinamic al obiectului se 4ace legatura apel

4unctie7corp 4unctie5

bservati a aeasta presupune elusiv apelul prin

inter%ediul pointerilor

3ele F elemente necesare implementarii acestui comportament:

- adresarea obietelor (de tip baza sau derivate) prin pointeri

de tip lasa de baza

- apelul de 0untii virtuale


14/43

"e#area dina%ia $ be6ind t6e urtains

"upa cum am spus in 3H 7 marea parte a ImunciiJ cand vine vorba de

derivare este 4acuta de compilator$ acelasi lucru se intampla si canddeclaram o 4unctie membra a unei clase 9 ca virtuala5

3uvantul c%eie virtual in4ormeaza compilatorul sa nu realizeze olegatura statica5

0n sc%imb$ trebuie sa puna in actiune toate mecanismele necesarerealizarii de legaturi dinamice5

*entru aceasta compilatorul creaza un tabel numit


15/43

9:Baza &&vector!ne Baza&'F; Baza &vector 'F;vector'M!ne Baza(1); vector'1!ne "erivata($); vector'!ne Baza(F);

vtable Baza

vector

vtable "erivata

4or (int i!M;i


16/43

bservatii in e priveste di%ensiunea tipurilor de date are au0untii virtuale si viteza de apel a 0untiilor virtuale

15*entru e6emplele anterioare testam di%ensiunea obietelor:

7 in cazul in care nu a% 0untia de afsare delarata virtuala:

Baza b; "erivata d; cout


17/43

bservatii privind rearea


18/43

3e se intampla daca avem urmatoarea ierar%ie declasesi avem un vector:9: Baza &&vector!ne Baza&'F;vector'M!ne Baza(1);

vector'1!ne "erivata1(1$);vector'! ne "erivata($F$N);

4or (int i!M;icit2val();

=class Baza= %as no member named =cit2val=// s-a trun6eat


19/43

e#uli derivate:

15 Qu pot avea constructori virtuali5

De e4

*K este initializat in constructor5 3onstructorul$ daca era 4unctie virtuala$

trebuia sa aiba adresa accesibila prin *K$ dar *K inca nu e initializat5

(*ot ma6im sa 4ac niste 4unctii virtuale care sa mimeze comportamentul

unui constructor virtual5)

5 La apelul unei 4unctii virtuale$ in constructor se apeleaza versiunea

locala a 4unctiei5

Gecanismul asociat virtual nu 4unctioneaza in constructor pentru ca:a5 rolul onstrutorului e de a rea obietul5

b5 in constructor$ obietul poate f partial 0or%at; e6: se stie care e

obiectul de baza$ nu si ce clase urmeaza sa fe derivate5


20/43

c5 initializarea


21/43

- *entru e6emplul de pana acum$ in care nu implementam niciun

destructor$ se generau automat destructori pentru toate clasele din

ierar%ie5- "eci se va apela de F ori destructorul pentru tipul de date static al

elementelor vector'i$ adica se apeleaza de F ori destructorul de tip

Baza

D.: noi trebuie sa eliberam spatiu pentru obiecte de tip "erivata1 si

"erivata5

- *entru a se putea 4ace acest lucru$ in clasa Baza trebuie sa declaram

destructorul ca find 4unctie virtuala:

virtual HBaza()A

- ast4el toti destructorii claselor derivate vor avea comportament de

4unctii virtuale$ c%iar daca sunt generati automat de compilator5


22/43

oli%orfs% si 0untii virtuale

- IpoliJ 9 mai multe; Imor4J 94orma

oli%orfs%ulse poate realiza prin:

- supradefnirea 0untiilor 7 4unctii cu acelasi nume$ dar

semnaturi di4erite 7 care se comporta di4erit in 4unctie de conte6t

9 in 4unctie de modul in care sunt apelate;polimorfsm ad hoc

- suprainararea 0untiilor 9 4unctii virtuale: acelasi obiect

poate sa aiba comportamente di4erite la apelul unei metode$ in

4unctie de tipul lui dinamic

E clasa in care se declara o metoda virtuala$ sau care e derivatadin alta clasa care contine o metoda virtuala se numeste lasa


23/43

Daa sunt asa de i%portante, de e nu 0olosi% elusiv 0untii

virtuale4 De e nu realizeaza deat le#aturi dina%ie4

- pentru ca legarea dinamica nu este la 4el de efcienta ca legarea

statica (asa ca o 4olosim cand e nevoie)

33@@ este un limba preocupat de efcienta

in Aava toate legaturile apel 4unctie 7 corp 4unctie sunt realizate

dinamic (nu sunt vizibili pointerii si 4unctiile virtuale)

Daa nu sunt la 0el de efiente - and 0olosi% 0untii virtuale4

"e fecare data cand vrem ca in clasa derivata sa

modifcamadaptamsuprascriem comportamentul unei 4unctii dea

implementate in clasa de baza5


24/43

and este i%portant aest %eanis%4

15 Sunctiile virtuale sunt 4olosite pentru a implementa polimorfsmulin momentul rularii ( Kun time *olmorp%ismI)5

5 ,n alt avanta al 4unctiilor virtuale este ca permit realizarea deliste neo%o#ene de obiecte

F5 "ezvoltarea de biblioteci in spiritul *EE5

! "iste neo%o#ene:

ipul static al obiectelor din lista este tipul de baza$ dar obiectelestocate pot f de orice tip derivat sau baza5

Eperatiile e4ectuate pe lista pot f 4acute 4ara testarea tipuluiobiectului$ deoarece e6ista garantia ca metodele apelate sunt celede tipul dinamic al obiectelor5

B %


25/43

Baza5%#pragma once#include using namespace std;

class Baza{protected:

int atr1;public:

Baza(); Baza(int );

void set2atr1(int ); virtualvoid afsare();

virtualTBaza(){};};Baza5cpp#include Baza5%

Baza::Baza() { }

Baza::Baza(int i):atr1(i) { }

void Baza::set2atr1(int i) { atr1!i; }

void Baza::afsare() { cout


26/43

"erivata5%#pragma once#include Baza5%class "erivata: public Baza{

protected: int atr;public:

"erivata(); "erivata(int $ int ); void set2atr(int ); void afsare(); afsare din "erivata e virtuala

};destructorul generat automat e virtual

"erivata5cpp#include "erivata5% "erivata::"erivata() { }

"erivata::"erivata(int a1$ int a):Baza(a1)$atr(a) { }

void "erivata::set2atr(int n) { atr ! n; }

void "erivata::afsare() { Baza::afsare(); cout


27/43

#include "erivata5%

int main(int argc$ c%ar &argv'){ int n;

cout>tip; i4 (tip!!M){ cout>a1; cin>>a; vec'i!ne "erivata(a1$a);

} else i77;


28/43

4or (int i!M;i


29/43

F5 -a consideram urmatorul scenariu:-. trebuie implementata o ierar6ie de lase-. sa consideram varianta in care$ pentru fecare clasa se defneste o

4unctie membra .fsare() nevirtuala5

+ceasta implementare are un dezavanta maor din punct devedere al dezvoltarii ulterioare a aplicatiilor: intrea#a ierar6iede lase trebuie reo%pilatadaca se %ai adau#a o noualasa u o 0untie %e%bra .fsare (care se doreste virtuala)$si aceasta indi4erent daca implementarile sunt in fsiere sursadi4erite sau nu5

+cesta este un dezavanta maor$ pe de7o parte datorita e4ortuluide compilare$ dar si din ratiuni de mar8eting5

-a presupunem ca un producator so4tare vrea sa implementezeierar%ia de clase discutata mai sus si sa o vanda5

3umparatorul utilizatorul doreste ca pe baza claselor dinbiblioteca$ sa7si dezvolte propriile aplicatii$ pastrand insa 4unctia+fsare in implementarea lor5 -i mai mult doreste ca 4unctia de+fsare sa fe virtuala (ceea ce inseamna ca ar trebui sa modifce

%eaderul clasei de baza din ierar%ie si sa recompileze toate clasele)5


30/43

De e este insa neesara reo%pilarea tuturor

i%ple%entarilor (a tuturor laselor)4

.6plicatia provine de la modurile standard in care compilatorul poate

distinge intre 4unctii cu acelasi nume (pana acum am vazut F asemeneamoduri):

7 4unctiile di4era prin lista de argumente

7 se 4oloseste operatorul de rezolutie ::$ prin care se distinge intre

4unctii redefnite in clasele derivate- se 4ace distinctie dupa tipul obiectului pentru care a 4ost apelata

4unctia5

oate aceste distinctii (rezolutii) se 4ac insa la compilare$ legare

timpurie (statica)5

0n clipa in care declaram 4unctia de afsare virtuala$ trebuie compilate

inca o data toate clasele$ iar %eanis%ul de le#are statia este

inlouit peste tot pe unde apare 0untia .fsare u el de le#are

dina%ia


31/43

0n mod normal$ utilizatorului trebuie sa i se 4urnizeze niste fsiere

5% (cu defnitiile claselor) si niste fsiere 5ob $ 5o sau 5lib (cu

implementarile gata compilate)$ pe baza carora sa dezvolte noi

tipuri de date$ sa deriveze noi clase din cele e6istente dea 5

*rin legarea tarziedinamica (late sau dnamic binding)$ adica prin

intermediul 4unctiilor membre virtuale se poate rezolva problema

4urnizarii surselor5

E 4unctie virtuala +fsare ascunsa intr7o clasa de baza B

precompilata nu este legata la obiectele din clasa B ca o 4unctie

membra obisnuita5

*utem crea o clasa " derivata din B si suprascrie o 4unctie +fsarepentru clasa "5

"aca se compileaza modulul nou de program si se lin87editeaza cu

modulul 5E5EBA sau 5L0B anterior dezvoltat$ apelurile 4unctiei

+fsare se vor 4ace corect$ fe pentru obiectele din clasa B$ feentru cele din clasa "5


32/43

"aca se doreste dezvoltarea in continuare a acestei ierar%ii$ nu mai estenevoie sa recompilez mereu codul pentru clasele Baza si "erivata$ atatatimp cat nu modifc implementarea sau %eaderele$ ci trebuie doar sainclud %eaderele si modulele obiect in noul proiect5

Daa apliatia avea di%ensiuni %ult %ai %ari, se salva %ultti%p $ a0erent reo%pilarii

*roect 7> *roect Eptions 7> *arameters 7> +dd Librar or


33/43

*roect > *roect Eptions > *arameters > +dd Librar orEbect

#i l d tdlib


34/43

#include #include using namespace std;#include "erivata5%

class "erivata2dupa2cumparare:public "erivata{ int atrF;public:

"erivata2dupa2cumparare(int i$ int $ int 8):"erivata(i$)$atrF(8) {}

void afsare() { "erivata::afsare(); cout


35/43

Reguli generale:

15 -e recomanda sa se declare ca virtuale$ 4unctiile care$ in

derivari ulterioare Q, isi sc%imba semnifcatia (acelasi

nume$ semnatura$ tip returnat)$ ci doar li se modifca

adapteaza implementarea comportamentul (in 4unctie de noul

tip de date)5

5 "aca o clasa are macar o 4unctie virtuala$ destructorul

trebuie declarat virtual5


36/43

.6emplu amplu; este reluata aplicatia din materialul anteriorcomp2deriv:

+dresa c%ar &str int nr

*ersoana +dresa adr c%ar& nume

+ngaat +dresa adr c%ar& nume

mostenite double salariu

agregare %as a

derivare is a

reau sa pot sa creez un vector care sa contina si persoane si angaati(lista neomogena) si sa pot sa 4ac afsarea tuturor atributelor obiectelor4ara sa imi pun probleme legate de tip5

l +d {


37/43

class +dresa { private: c%ar& str; int nr;

public:

+dresa();+dresa(c%ar&$ int);+dresa(const +dresa?);

+dresa? operator!(const +dresa ?); 4riend ostream? operator


38/43

class +ngaat:publi ersoana { private:

double salariu;public: +ngaat();

+ngaat(const +dresa ?$ c%ar&$double);+ngaat(c%ar& $ int $ c%ar& $ double );

+ngaat(const +ngaat ? ); +ngaat? operator!(const +ngaat ? ); void afsare();e virtuala};

int main()


39/43

int main(){

int n; cin>>n;

c%ar &num!ne c%ar'M;

c%ar &str!ne c%ar'M; int nr; double sal;

bool &t!ne bool'n; 7nu mai e nevoie de un vector in care memorezdaca persoana e angaata sau nu

ersoana *&evidenta!ne ersoana*'n;un vector in care vreau sa stoc%ez atat obiecte de tip *ersoana& cat si+ngaat&

4or (int i!M;i


40/43

{coutnum;

coutstr; coutnr;

evidentaFiG=new ersoana(str,nr,nu%); }

}cout


41/43

#include using namespace std;#include

class Sig2geom{ protected: c%ar &nume; public: Sig2geom(){nume!ne c%ar'strlen(IE SiguraI);})@1; strcp(nume$ IESiguraI);}

Sig2geom(const c%ar&n){nume!ne c%ar'strlen(n)@1;strcp(nume$n);}

Sig2geom(const Sig2geom ?n){ &t%is!n; }

Sig2geom? operator!(const Sig2geom ?n){ nume!ne

c%ar'strlen(n5nume)@1; strcp(nume$n5nume);

return &t%is;}

void afsare(){ cout


42/43

class *atrat:public Sig2geom{ double lat; public: *atrat(c%ar&n$double i):5i#C#eo%(n) { lat!i; }

*atrat(const *atrat? i):5i#C#eo%(i) { lat!i5lat; }

*atrat? operator!(const *atrat? i) { (5i#C#eo%?)(*t6is)=i;lat!i5lat; return &t%is; }

double arie() A return lat*lat; //pot sa o 0a private4

};

class 3erc:public Sig2geom{ double raza; public:

3erc(c%ar&n$double i):5i#C#eo%(n) { raza!i; }

3erc(const 3erc? i):5i#C#eo%(i) { raza!i5raza; }

3erc? operator!(const 3erc? i) { (5i#C#eo%?)(*t6is)=i;raza!i5raza; return &t%is; }

int main()


43/43

int main() { Sig2geom && v!ne Sig2geom&'F; v'M!ne Sig2geom(punct); v'1!ne *atrat(patrat 1$);

v'!ne 3erc(cerc 1$F);

4or (int i!M;iafsare(); //dar afsare nu e virtuala@ //- nu, dar apeleaza o 0untie virtuala si este

%ostenita de // toate lasele derivate3 Lu osuprasriu pentru a 0ae // %ereu aelasi luru;doar aria se aluleaza alt0el

cout

Functii Vituale Suprascriere Polimorfism

Documents

Transcript of Functii Vituale Suprascriere Polimorfism