12. Obiecte Pascal (tipul Object) - cs.ubbcluj.roper/Fp -_-/Fp_14.pdf · Obiecte Pascal Vom...

12. 12. ObiecteObiecte Pascal (Pascal (tipultipul Object) Object) ProgramareProgramare OrientatOrientatăă ObiectObiect

C_C_1515 / 18.01.20/ 18.01.201313

ProgramareaProgramarea OrientatăOrientată ObiectObiect (OopOop) permite obţinerea unor programe

structurate, modulare şi abstracte, bazându-se pe următoarele concepte:

ÎÎncapsulareancapsularea :unificarea atributelor (câmpurilor) cu operaţiile (metodele) într-

un tot unitar numit obiect (tipul Object);

MoMoşştenireatenirea :proprietatea de a păstra câmpurile şi metodele definite pentru un

strămoş, prin tranzitivitate, dând posibilitatea de a construi o ierarhie de obiecte

descendente plecând de la un obiect de bază;

PolimorfismulPolimorfismul :numele unei acţiuni (al unei metode), poate fi reutilizat într-o

ierarhie, pentru a redefini operaţia corespunzătoare obiectului definit.

ObiecteObiecte PascalPascal

Vom înţelege prin (tipul) Obiect (Object) o structură de date cu număr fix de componente care pot fi:

Câmpuri:care definesc caracteristicile obiectului (aflate într-un domeniu de definiţie), declarate ca şi la tipul înregistrare (Record);

Metode:prin care se definesc acţiunile (operaţiile), declarate prin antete de subprograme (funcţii şi proceduri);

Declararea (definirea) unui obiect se face astfel:Type <Nume_ObiectNume_Obiect> = ObjectObject

{<{<Lista_CâmpuriLista_Câmpuri> : <> : <Tip_CâmpuriTip_Câmpuri>; }>; }{<{<Antet_FuncAntet_Funcţţieie>|<>|<Antet_ProceduAntet_Procedurără>;}>;}

End;End;

Exemplu:Type Punct = ObjectObject

x,yx,y : Real; : Real; { { CoordCoord. . x,yx,y ale ale punctuluipunctului }}Procedure Cit;Procedure Cit; { Cit. { Cit. coordcoord. . punctuluipunctului }}Function Function Dist(P:Punct):RealDist(P:Punct):Real; ; { Dist. { Dist. pânăpână la pct. P }la pct. P }

End;End;

Observaţie. Metodele au acces direct la componentele (câmpurile) obiectului, decinu mai este necesară parametrizarea lor.


Definirea metodelor se realizează ulterior (ca şi la directiva Forward) prcizând numeleobiectului, punct şi numele metodei al cărei bloc urmează să fie declarat:

Procedure <Nume_Obiect> . <Nume_Metodă> [(<Lista_par_formali>)];...

End;respectiv

Function <Nume_Obiect> . <Nume_Metodă> [(<Lista_par_formali>):<Tip_f>];...

End;

Exemplu:Procedure Procedure Punct.CitPunct.Cit;;Begin Begin

Write (' Write (' x,yx,y : '); : '); ReadlnReadln ((x,yx,y) ) End;End;Function Function Punct.DistPunct.Dist;; { ({ (P:Punct):RealP:Punct):Real; ; Dist. Dist. pânăpână la pct. Pla pct. P }}Begin Begin

Dist := Dist := Sqrt(Sqr(xSqrt(Sqr(x--P.x)+Sqr(yP.x)+Sqr(y--P.yP.y)) )) End;End;

Observaţie. Lista parametrilor formali şi tipul funcţiei pot fi omise, deoarece ele au fost deja definite în antetul de delarare a metodei din cadrul obiectului.


Declaraţiile instanţelor de tip obiect sunt asemănătoare cu declaraţiile de variabile respectiv de constante.

Exemplu:ConstConst O : O : PunctPunct = (x:0; y:0); = (x:0; y:0); VarVar A,B : A,B : PunctPunct;;P : Array[1..10] Of P : Array[1..10] Of PunctPunct;;

Referirea câmpurilor şi a metodelor se efectuează (ca şi la variabilele de tip Record) fie utilizând caracterul ‘.’, fie instrucţiunea With :

• Accesul la câmpuri: ... <Nume_Instanţă> . <Nume_Câmp> ...... With <Nume_Instanţă> Do ...<Nume_Câmp>...

• Apelul metodelor: ... <Nume_Instanţă> . <Nume_Metodă>[(<Lpa>)] ...... With <Nume_Instanţă> Do ...< Nume_Metodă>[(<Lpa>)]...unde <Lpa> ::= <Lista_parametrilor_actuali>

Exemplu:BeginBegin ... ... A.CitA.Cit; ; { { CitesteCiteste A(x,yA(x,y) }) }

With B Do Cit; With B Do Cit; { { CitesteCiteste B(x,yB(x,y) }) }Writeln('AOWriteln('AO=',A.Dist(O):4:2); =',A.Dist(O):4:2); { { TipăreTipăreşştete AO }AO }With B Do With B Do Writeln('BOWriteln('BO=',Dist(O):4:2); =',Dist(O):4:2); { { TipăreTipăreşştete BO } ...BO } ...

End.End.


Un obiect poate conţine (agregaagrega) alt obiect (vezi în exemplul următor):Program Program AgregareAgregare;;Type Type PunctPunct = = Object Object x, y : Real; x, y : Real; { { AgregatAgregat }}

Procedure Init(x0,y0:Real);Procedure Init(x0,y0:Real);Procedure Print;Procedure Print;

End;End;CercCerc = = Object Object CentruCentru : : PunctPunct; ; { { AgregantAgregant }}

RazaRaza : Real;: Real;Procedure Procedure Init(C:PunctInit(C:Punct; ; r:Realr:Real););Procedure Print;Procedure Print;

End;End;Procedure Procedure Punct.InitPunct.Init; Begin x:=x0; y:=y0 ; Begin x:=x0; y:=y0 End;End;Procedure Procedure Punct.PrintPunct.Print; Begin Write(' x = ',x:5:2,' y = ',y:5:2) End;; Begin Write(' x = ',x:5:2,' y = ',y:5:2) End;Procedure Procedure Cerc.InitCerc.Init; Begin ; Begin CentruCentru:=C; :=C; RazaRaza:=r End;:=r End;Procedure Procedure Cerc.PrintCerc.Print; Begin ; Begin Centru.PrintCentru.Print; Write(' r = ',Raza:5:2) End;; Write(' r = ',Raza:5:2) End;VarVar O : O : PunctPunct; C : ; C : CercCerc;;BeginBegin

O.InitO.Init (3,4); (3,4); C.InitC.Init (O,5);(O,5);O.PrintO.Print; ; C.PrintC.Print; ; ReadlnReadln

End.End.


Unui obiect i se poate asociaasocia alt obiect printr-un pointer sau o referinţă la acesta:Program Program AsociereAsociere;;Type Type FacultateFacultate = Object= Object { { AsociatAsociat }}

DenumireDenumire,,AdresaAdresa : String[20]; : String[20]; Procedure Init (Procedure Init (Den,Adr:StringDen,Adr:String););Procedure Print;Procedure Print;

End;End;StudentStudent = Object= Object { { AsociantAsociant }}

Nume_PrenNume_Pren : String[20]; : String[20]; FacultaFaculta :^:^FacultateFacultate;;Procedure Init (Procedure Init (Nume:StringNume:String; ; Pf:PointerPf:Pointer););Procedure Print;Procedure Print;

End;End;Procedure Procedure Facultate.InitFacultate.Init; Begin ; Begin DenumireDenumire:=Den; :=Den; AdresaAdresa:=:=AdrAdr End;End;Procedure Procedure Facultate.PrintFacultate.Print; Begin ; Begin Writeln(Denumire,',',AdresaWriteln(Denumire,',',Adresa) End;) End;Procedure Procedure Student.InitStudent.Init; Begin ; Begin Nume_PrenNume_Pren:=:=NumeNume; ; FacultaFaculta:=Pf End;:=Pf End;Procedure Procedure Student.PrintStudent.Print; Begin ; Begin Writeln(Nume_PrenWriteln(Nume_Pren); ); Faculta^.PrintFaculta^.Print End;End;VarVar Pf :^Pf :^FacultateFacultate; s : Student;; s : Student;BeginBegin

New(PfNew(Pf); ); Pf^.Init('FacPf^.Init('Fac. de . de Mate_Info','Cluj_NapocaMate_Info','Cluj_Napoca'); '); Pf^.PrintPf^.Print;;s.Init('Ionescus.Init('Ionescu Marcel',PfMarcel',Pf); ); s.Prints.Print; ; ReadlnReadln

End.End.


Există două metode speciale şi anume Constructor (folosit pentru alocarea

obiectelor dinamice şi pentru iniţializarea metodelor virtuale) şi Destructor

(utilizat la eliberarea obiectelor dinamice).

O clasa poate conţine mai mulţi constructori şi (chiar şi) mai mulţi destructori.

Constructorul poate fi apelat explicit, sau pentru obiectele alocate dinamic chiar ca

parametru în procedura New :

NewNew((Adr_refAdr_ref,,ConstrConstr((……));));

Alocarea cu New se poate face şi astfel:

AdrAdr:=:=NewNew((Tip_refTip_ref,,ConstrConstr((……));));

Dealocarea se poate face fie explicit, fie prin procedura Dispose:

DisposeDispose((Adr_refAdr_ref,,DestrDestr((……));));

ObiecteObiecte PascalPascalProgramul anterior îl vom modifica astfel:Program Program Constructor_DestructorConstructor_Destructor;;Type Type Ref_FacRef_Fac=^=^FacultateFacultate;;

FacultateFacultate = Object= ObjectDenumireDenumire,,AdresaAdresa : String[20];: String[20];ConstructorConstructor InitInit ((Den,Adr:StringDen,Adr:String););Procedure Print;Procedure Print;DestructorDestructor LiberLiber;;

End;End;Student = ObjectStudent = Object

Nume_PrenNume_Pren : String[20];: String[20];FacultaFaculta : : PointerPointer;;ConstructorConstructor InitInit ((Nume:StringNume:String; ; Pf:PointerPf:Pointer););Procedure Print;Procedure Print;

End;End;ConstructorConstructor Facultate.Facultate.InitInit; Begin ; Begin DenumireDenumire:=Den; :=Den; AdresaAdresa:=:=AdrAdr End;End;Procedure Procedure Facultate.PrintFacultate.Print; Begin ; Begin Writeln(Denumire,',',AdresaWriteln(Denumire,',',Adresa) End;) End;DestructorDestructor Facultate.Facultate.LiberLiber; Begin ; Begin Writeln(Writeln('Facultate'Facultate StearsaStearsa'') End;) End;ConstructorConstructor Student.Student.InitInit; Begin ; Begin Nume_PrenNume_Pren:=:=NumeNume; ; FacultaFaculta:=Pf End;:=Pf End;Procedure Procedure Student.PrintStudent.Print; Begin ; Begin Writeln(Nume_PrenWriteln(Nume_Pren););

Ref_Fac(Faculta)^.PrintRef_Fac(Faculta)^.Print End;End;VarVar Pf :Pf :Ref_FacRef_Fac; s : Student; ; s : Student; BeginBegin

NewNew(Pf,(Pf,InitInit('Fac('Fac. de . de Mate_Info','Cluj_NapocaMate_Info','Cluj_Napoca')); ')); Pf^.PrintPf^.Print;;s.s.InitInit('Ionescu('Ionescu Marcel',PfMarcel',Pf); ); s.Prints.Print;;DisposeDispose(Pf,(Pf,LiberLiber); ); ReadlnReadln

End.End.


Despre metode virtuale vom discuta mai târziu (noţiunea de legare târzie o maiamânăm).

Într-un modul (Unit Pascal) putem utiliza directivele standard Public(componentele obiectului sunt vizibile şi accesibile) şi Private (componentelesunt innacesibile din program) pentru a putea modifica protecţia câmpurilor şi a metodelor. Uzual, câmpurile sunt Private iar metodele sunt de tip Public. Aceasta realizează o încapsulare a datelor, deci accesul nu mai este permis decâtprin intermediul operaţiilor definite prim metode.

Un exemplu de program care utilizează un astfel de modul este următorul: Program Program Public_PrivatePublic_Private;;Uses Uses StudentiStudenti;;VarVar Pf :Pf :Ref_FacRef_Fac; s : Student;; s : Student;BeginBegin

New(Pf,Init('FacNew(Pf,Init('Fac. de . de Mate_Info','Cluj_NapocaMate_Info','Cluj_Napoca')); ')); Pf^.PrintPf^.Print;;s.Init('Ionescus.Init('Ionescu Marcel',PfMarcel',Pf); ); s.Prints.Print;;Dispose(Pf,LiberDispose(Pf,Liber); ); Readln

End.End.

ObiecteObiecte PascalPascalModulul corespunzător este redat în continuare: Unit Unit StudentiStudenti;;InterfaceInterface

Type Ref_Fac=^Facultate;Facultate = Object

PrivateDenumire,Adresa : String[20];

PublicConstructor Init (Den,Adr:String);Procedure Print;Destructor Liber;

End;Student = Object

PrivateNume_Pren : String[20];Faculta : Pointer;

PublicConstructor Init (Nume:String; Pf:Pointer);Procedure Print;

End;ImplementationImplementationConstructor Facultate.Init; Begin Denumire:=Den; Adresa:=Adr End;Procedure Facultate.Print; Begin Writeln(Denumire,',',Adresa) End;Destructor Facultate.Liber; Begin Writeln('Facultate Stearsa') End;Constructor Student.Init; Begin Nume_Pren:=Nume; Faculta:=Pf End;Procedure Student.Print; Begin Writeln(Nume_Pren); Ref_Fac(Faculta)^.Print End;

End.End.


Relaţia de derivare este cea mai puternică relaţie dintre clase. Plecând de la o clasă de bază putem obţine noi clase derivate păstrând componentele claseide bază şi adăugând noi componente (câmpuri şi metode). Metodele se pot redefini conform necesităţilor noii clase.

De exemplu având clasa Student, putem construi clasele Student_Bursier, Student_Căminist, etc. adăugând noi atribute cum ar fi Bursa, respectivCăminul, redefinid anumite operaţii şi eventual adăugând altele noi.

Un obiect (descendent) poate să moştenească de la un alt obiect (strămoş) câmpurile şi metodele acestuia printr-o declaraţie de forma:

Type <Descendent > =Type <Descendent > = Object Object ((StrămoStrămoşş)){{<<Noi_CâmpuriNoi_Câmpuri> : <> : <Tip_CâmpuriTip_Câmpuri>; >; }}{{<<Antet_FuncAntet_Funcţţieie>|<>|<Antet_ProceduAntet_Procedurără>;>;}}

End;End;Tipul descendent păstrează componentele strămoşului, fiind necesară doardefinirea noilor componente (noi câmpuri sau noi metode). Acest nou tip obiectpoate la rândul sau să fie strămoş (tip definitor) pentru alt tip obiect (moştenireafiind tranzitivă, adică toate componentele strămoşului vor fi retransmise), dândposibilitatea formării unei ierarhii.

ObiecteObiecte PascalPascalExemplu:

......Type Type CercCerc = Object= Object ((PunctPunct) ) {{CentrulCentrul cerculuicercului ((x,yx,y) se ) se momoşşteneteneşştete de la de la PunctPunct}}

r : Real; r : Real; { { RazaRaza cerculuicercului }}......

Function Function Aria:RealAria:Real; ; { { Aria Aria }}Function Function Lung:RealLung:Real; ; { { LungimeaLungimea }}

......End;End;

VarVar ... ... C:CercC:Cerc; ... ; ... P:PunctP:Punct;;BeginBegin ......

With C Do ... x ... y ... With C Do ... x ... y ... Dist(PDist(P) ... ) ... ......

End.End.

În exemplul de mai sus x şi y reprezintă coordonatele centrului cercului C, iarDist(P) distanţa de la centrul acestuia până la punctul P, acestea fiind moştenitede la Punct. Acest exemplu nu este poate cel mai nimerit, deoarece “Cerculeste un (fel de) Punct cu o rază” nu este foarte convingător! Cu toate acestea, mulţi programatori preferă relaţia de derivare, fiind mai puternică, chiar dacă s-ar potrivi mai bine din punct de vedere didactic altă relaţie pentru aceste douăclase (de exemplu agregare: “Cercul are un Punct şi o rază”).

ObiecteObiecte PascalPascalÎn cadrul unei ierarhii compatibilitatea este valabilă doar de jos în sus, adicăunuiunui strămostrămoşş i se i se poatepoate atribuiatribui un descendentun descendent ((sursasursa trebuietrebuie săsă acopereacoperedestinadestinaţţiaia).).

Exemplu:VarVar ... C,C1,C2:Cerc; ... ... C,C1,C2:Cerc; ... P:PunctP:Punct;;BeginBegin ......

P:=C;P:=C; { P := { P := CentrulCentrul cerculuicercului (C) }(C) }... C1.Dist(C2) ... ... C1.Dist(C2) ... { { DistanDistanţţaa dintredintre centrelecentrele cercurilorcercurilor C1 C1 şşii C2 }C2 }......

End.End.

Se poate observa în exemplul de mai sus că un cerc moşteneşte metoda pentrude citire, dar aceasta permite doar citirea coordonatelor centrului cercului. Desigur că dorim să putem citi şi raza acestuia. Mai mult, dorim să utilizămacelaşi nume şi pentru a citi un cerc (P.Cit - să citească coordonatele punctuluiP, iar C.Cit să citescă pe lângă coordonatele centrului şi raza cercului C). Înaceste condiţii, vom fi nevoiţi să redefinim metoda Cit. De asemenea, metodaC.Dist(P) dorim să calculeze distanţa de la punctul P la cercul C egală cu distanţa de la P la centrul cercului minus raza acestuia. Aşa cum se poate vedeaîn exemplul următor vom apela la conceptul de polimorfism, care permite uneimetode să reacţioneze diferit în funcţie de obiectul asupra căruia acţionează.

ObiecteObiecte PascalPascalProgram Program PolimorfismPolimorfism; ; Type Type PunctPunct = Object x, y : Real;= Object x, y : Real;

Procedure Cit;Procedure Cit;Function Function Dist(P:Punct):RealDist(P:Punct):Real; ;

End;End;Procedure Procedure Punct.CitPunct.Cit;; Begin Write (' Begin Write (' x,yx,y : '); : '); ReadlnReadln ((x,yx,y) ) End;End;Function Function Punct.DistPunct.Dist;; Begin Dist:=Begin Dist:=Sqrt(Sqr(xSqrt(Sqr(x--P.x)+Sqr(yP.x)+Sqr(y--P.yP.y)) End;)) End;

Type Type CercCerc = Object (= Object (PunctPunct) r : Real;) r : Real;Procedure Cit;Procedure Cit;Function Function Dist(P:Punct):RealDist(P:Punct):Real; ;

End;End;Procedure Procedure Cerc.CitCerc.Cit; Begin ; Begin Punct.CitPunct.Cit; Write (' r : '); ; Write (' r : '); ReadlnReadln (r) End;(r) End;Function Function Cerc.DistCerc.Dist; Begin Dist:=; Begin Dist:=Punct.Dist(P)Punct.Dist(P)--rr End;End;

VarVar A, M : A, M : PunctPunct; C : ; C : CercCerc;;BeginBegin

Write('CWrite('C:'); :'); C.CitC.Cit; A:=C;; A:=C;Write('MWrite('M:'); :'); M.CitM.Cit;;With A Do With A Do WritelnWriteln ('Dist. punct:',Dist(M):6:2);('Dist. punct:',Dist(M):6:2);With C Do With C Do WritelnWriteln ('Dist. ('Dist. cerccerc :',Dist(M):6:2);:',Dist(M):6:2);

WritelnWriteln ('MC:',M.Dist(C):4:2);('MC:',M.Dist(C):4:2); {Dist. de la M la {Dist. de la M la centrulcentrul cerculuicercului C }C }WritelnWriteln ('CM=',C.Dist(M):4:2)('CM=',C.Dist(M):4:2) { Dist. de la M la { Dist. de la M la cerculcercul C }C }

End.End.


În programul de mai jos, am definit metoda PeFig care decide dacă un punct P este sau nu pe o figură geometrică (Punct sau Cerc). Aceasta se poate rezolva, verificând dacă distanţa de la punct la figura dată este nulă. Cercul moşteneştede la punct această metodă, aşa cum se poate vedea în continuare.

Program Pr_Fct_NeVirtuala; Type Punct = Object x, y : Real;

Procedure Cit;Function Dist(P:Punct):Real; { Ne Virtuală}Function PeFig(P:Punct):Boolean;

End;Cerc = Object (Punct) r : Real;

Procedure Cit;Function Dist(P:Punct):Real; { Ne Virtuală}

End;Procedure Punct.Cit; Begin Write (' x,y : '); Readln (x,y) End;Function Punct.Dist; Begin Dist:=Sqrt(Sqr(x-P.x)+Sqr(y-P.y)) End;Function Punct.PeFig; Begin PeFig:=Dist(P)=0 End;Procedure Cerc.Cit; Begin Punct.Cit; Write (' r : '); Readln(r) End;Function Cerc.Dist; Begin Dist:=Punct.Dist(P)-r End;

Rezultatele referitoare la poziţia relativă a punctului M faţă de cercul C sunteronate deoarece metoda PeFig apelează metoda Punct.Dist în loc de Cerc.Dist, aşa cum am dori (vezi tabelul următor):

ObiecteObiecte PascalPascalVarVar M : M : PunctPunct; C : ; C : CercCerc;;Begin Begin Write (' M : '); Write (' M : '); M.CitM.Cit; Write (' C : '); ; Write (' C : '); C.CitC.Cit;;If If CC..PeFigPeFig(M(M)) Then Then WritelnWriteln(' M (' M esteeste pepe cerccerc ')') { { Cerc.DistCerc.Dist. . ?? }}

Else Else WritelnWriteln(' M nu (' M nu esteeste pepe cerccerc ');');If If M.PeFig(CM.PeFig(C)) Then Then WritelnWriteln(' M (' M esteeste in in centrucentru ')') { { Punct.DistPunct.Dist..!! }}

Else Else WritelnWriteln(' M nu (' M nu esteeste in in centrucentru ');'); ReadlnEnd.End.

M nu este pe cercM nu este in centru

M este pe cercM este in centru

Rezultate

M : x,y : 3 4 C : x,y : 0 0 r : 5

M : x,y : 3 4C : x,y : 3 4r : 3

DateExemplul 2Exemplul 1Contra Exemple

Programul corectat este următorul:

Program Program Pr_Met_VirtualaPr_Met_Virtuala; ; Type Type PunctPunct = Object x, y : Real;= Object x, y : Real;

Constructor Constructor Cit;Cit;Function Function Dist(P:Punct):RealDist(P:Punct):Real; ; VirtualVirtual;; {!}{!}Function Function PeFigPeFig(P:Punct):Boolean(P:Punct):Boolean;;

End;End;

ObiecteObiecte PascalPascalPentru ca Ob.PeFig(P) să determine distanţa de punctul P la cercul Ob (dacă Ob este cerc), respectiv distanţa de la punctul Ob la punctul P (dacă Ob este punct) vom corecta programul anterior prin declararea funcţiei Dist ca funcţie virtuală, ceea ce permite determinarea metodei (care se aplică unui obiect) doar în fazade execuţie a programului, nu la compilare, pe baza unei tabele de metodevirtuale, VMT, creată printr-o metodă de tip Constructor. Deci, mai trebuie sădeclarăm metoda Cit ca metodă de tip Constructor .Mai subliniem faptul că la redefinirea metodelor virtuale, antetul şi tipul funcţieitrebuie să coincidă, iar dacă un strămoş conţine o metodă virtuală, atunci toatemetodele omonime ale descendenţilor trebuie să fie virtuale. De asemenea maiprecizăm că un constructor nu poate fi virtual.

CercCerc = Object (= Object (PunctPunct) r : Real;) r : Real;Constructor Constructor Cit;Cit;Function Function Dist(P:Punct):RealDist(P:Punct):Real; ; VirtualVirtual; ; {!}{!}

End;End;Constructor Constructor Punct.CitPunct.Cit; Begin Write ('; Begin Write ('x,yx,y:'); :'); Readln(x,yReadln(x,y)) End;End;Function Function Punct.DistPunct.Dist; Begin Dist:=; Begin Dist:=Sqrt(Sqr(xSqrt(Sqr(x--P.x)+Sqr(yP.x)+Sqr(y--P.yP.y)))) End;End;Function Function Punct.Punct.PeFigPeFig; Begin ; Begin PeFigPeFig:=:=Dist(PDist(P)=0)=0 End;End;Constructor Constructor Cerc.CitCerc.Cit; Begin ; Begin Punct.CitPunct.Cit; ; Write('rWrite('r:'); :'); Readln(rReadln(r)) End;End;Function Function Cerc.DistCerc.Dist; Begin Dist:=; Begin Dist:=Punct.Dist(P)Punct.Dist(P)--rr End;End;VarVar M : M : PunctPunct; C : ; C : CercCerc;;BeginBeginWrite('MWrite('M:'); :'); M.CitM.Cit; ; Write('CWrite('C:'); :'); C.CitC.Cit;;If If CC..PeFigPeFig(M(M)) Then Then WritelnWriteln(' M (' M esteeste pepe cerccerc ')') { { CercCerc..DistDist }}

Else Else WritelnWriteln(' M nu (' M nu esteeste pepe cerccerc ');');If If MM..PeFigPeFig(C(C)) Then Then WritelnWriteln(' M (' M esteeste in in centrucentru ')') { { PunctPunct..DistDist }}

Else Else WritelnWriteln(' M nu (' M nu esteeste in in centrucentru '); '); Readln

End.End.


Următorul program citeste o listă de obiecte formată din cercuri şi discuri, apoise va calcula preţul pentru fiecare obiect în funcţie de tipul lui astfel:

• pentru cerc în funcţie de lungime iar• pentru disc în funcţie de arie.

Program Program Lista_PolimorficaLista_Polimorfica;;

Type Type Ob_bOb_b = Object = Object r:Realr:Real;;Constructor Constructor Cit(Mes:StringCit(Mes:String););Function Function Pret:RealPret:Real; Virtual;; Virtual;

End;End;CercCerc = Object (= Object (Ob_bOb_b ))

Constructor Cit;Constructor Cit;Function Function Pret:RealPret:Real; Virtual;; Virtual;

End;End;Disc = Object (Disc = Object (Ob_bOb_b ))

Constructor Cit;Constructor Cit;Function Function Pret:RealPret:Real; Virtual;; Virtual;

End;End;


Constructor Constructor Ob_bOb_b .Cit; Begin .Cit; Begin Write(MesWrite(Mes); ); Readln(rReadln(r) ) End;End;Function Function Ob_bOb_b ..PretPret; Begin ; Begin PretPret:=0 :=0 End;End;Constructor Constructor Cerc.CitCerc.Cit; Begin ; Begin Ob_b.Cit('RcOb_b.Cit('Rc:') :') End;End;Function Function Cerc.PretCerc.Pret; Begin ; Begin PretPret:=2*Pi*r :=2*Pi*r End;End;Constructor Constructor Disc.CitDisc.Cit; Begin ; Begin Ob_b.Cit('RdOb_b.Cit('Rd:') :') End;End;Function Function Disc.PretDisc.Pret; Begin ; Begin PretPret:=Pi*r*r :=Pi*r*r End;End;VarVar O:ArrayO:Array [1..10] Of ^[1..10] Of ^Ob_bOb_b; ; i,n:Bytei,n:Byte; ;

Pc:^CercPc:^Cerc; ; Pd:^DiscPd:^Disc;;BeginBegin

Write('nWrite('n:'); :'); Readln(nReadln(n); Randomize;); Randomize;For i:=1 To n DoFor i:=1 To n Do

If If Odd(Random(iOdd(Random(i))))Then Begin Then Begin New(PcNew(Pc); ); Pc^.CitPc^.Cit; ; O[iO[i]:=Pc]:=Pc EndEndElse Begin Else Begin New(PdNew(Pd); ); Pd^.CitPd^.Cit; ; O[iO[i]:=Pd]:=Pd End;End;

For i:=1 To n DoFor i:=1 To n Dowith with O[iO[i]^]^ DoDo

Writeln(i:3,Writeln(i:3,PretPret:7:2); :7:2); Readln

End.End.


Acelaşi program poate fi modificat utilizând tipul pointer pentru a memoraadresele obiectelor, situaţie în care va fi nevoie de conversia pointer referinţăla obiect din clasa de bază. De asemenea, apelul constructorului se poate face direct la alocare aşa cum se poate vedea în cele ce urmează.

……TypeType Ob_bOb_b = Object = Object …… End;End;

CercCerc = Object (= Object (Ob_bOb_b ) ) …… End;End;Disc = Object (Disc = Object (Ob_bOb_b ) ) …… End;End;

……Type Type RObROb=^=^Ob_bOb_b;;VarVar O:ArrayO:Array [1..10] Of [1..10] Of PointerPointer; ; i,n:Bytei,n:Byte; ; Pc:^CercPc:^Cerc; ; Pd:^DiscPd:^Disc;;BeginBegin

Write('nWrite('n:'); :'); Readln(nReadln(n); Randomize;); Randomize;For i:=1 To n Do If For i:=1 To n Do If Odd(Random(iOdd(Random(i))))

Then Begin Then Begin New(Pc,CitNew(Pc,Cit);); O[iO[i]:=Pc End]:=Pc EndElse Begin Else Begin New(Pd,CitNew(Pd,Cit);); O[iO[i]:=Pd End;]:=Pd End;

For i:=1 To n DoFor i:=1 To n DoWith With RObROb(O[i(O[i])])^̂ DoDo

Writeln(i:3,Pret:7:2)Writeln(i:3,Pret:7:2); ; ReadlnEnd.End.


Conversia explicită pointer Rob se face automat la apelul unei proceduri saufuncţii prin parametru actual parametru formal, aşa cum se poate vedea încontinuare realizat acest lucru prin procedura Print.

……Type Type RObROb=^=^Ob_bOb_b;;

Procedure Procedure PrintPrint((RefRef::RobRob););BeginBegin

With With Ref^Ref^ Do Writeln(Do Writeln(PretPret:7:2):7:2)End;End;

VarVar O:ArrayO:Array [1..10] Of [1..10] Of PointerPointer; ; i,n:Bytei,n:Byte; ;

Pc:^CercPc:^Cerc; ; Pd:^DiscPd:^Disc;;

BeginBegin……

For i:=1 To n Do For i:=1 To n Do PrintPrint((O[iO[i]]););ReadlnReadln

End.End.



Dacă se doreşte prelucrarea fiecărui obiect din listă de către mai multesubprograme atunci acestea se pot pune într-un şir pentru ca mai apoi să fie apelatfiecare subprogram ( For j:=1 To m). În exemplul de mai jos se va apela proceduraPrintj pentru fiecare obiect Oi. Evident că era posibilă şi scrierea unei proceduriavând ca parametru formal unul de tip Procedura (variantă propusă ca temă).…… {$F+}{$F+}Type Type RObROb=^=^Ob_bOb_b;;

ProceduraProcedura = Procedure (= Procedure (Ref:RobRef:Rob););Procedure Procedure Pret_ROLPret_ROL(Ref:Rob(Ref:Rob); Begin With Ref^ Do Write(Pret/10:9:3) End;); Begin With Ref^ Do Write(Pret/10:9:3) End;Procedure Procedure Pret_EURPret_EUR(Ref:Rob(Ref:Rob); Begin With Ref^ Do Write(Pret/40:9:3) End;); Begin With Ref^ Do Write(Pret/40:9:3) End;Procedure Procedure Pret_USDPret_USD(Ref:Rob(Ref:Rob); Begin With Ref^ Do Write(Pret/30:9:3) End;); Begin With Ref^ Do Write(Pret/30:9:3) End;Const Const PrintPrint:Array[1..3] Of :Array[1..3] Of ProceduraProcedura=(=(Pret_ROL,Pret_EUR,Pret_USDPret_ROL,Pret_EUR,Pret_USD););VarVar OO:Array:Array [1..10] Of Pointer; [1..10] Of Pointer; i,j,n:Bytei,j,n:Byte; ; Pc:^CercPc:^Cerc; ; Pd:^DiscPd:^Disc;;BeginBegin

……For For ii:=1 To n Do Begin:=1 To n Do Begin

For For jj:=1 To 3 Do :=1 To 3 Do Print[j]Print[j]((O[iO[i]]); ); WritelnWriteln End;End;ReadlnReadln

End.End.


Supraîncărcarea (overloading), prin redefinirea unor funcţii sau metode, permitealegerea la compilare-link_editare a funcţiei sau a metodei dorite prinsemnătura acesteia, fără a mai putea alege la execuţie.

Polimorfismul permite ca la execuţie să se decidă ce metodă să fie apelată, oferindo facilitate a metodelor din clase aflate în relaţie de derivare. Prin polimorfismse execută acţiuni diferite prin mesaje cu semnături identice asupra obiectelor de tip diferit (obiecte din clase diferite răspund diferit la acelaşi mesaj).

Două obiecte sunt compatibile dacă aparţin aceleaşi clase (evident) dar şi douăvariabile de tip

- pointer la clasa de bază, respectiv pointer la clasa derivată, - referinţă (pointer constant) la clasa de bază, respectiv referinţă la clasa derivată.

Metodele unei clase pot fi:- Clasice – metode legate static, la compilare-link_editare fiind fixată adresa de

apel a metodei, fără posibilitatea de a o schimba la rularea aplicaţiei,- Polimorifice – metode legate dinamic, care permit întârzierea deciziei referitoare

la adresa de apel a metodei, până la execuţie.


Legarea unei metode (binding), înţelegând prin aceasta conexiunea logică dintre o entitate şi o proprietate a acesteia (corespondenţa dintre un mesaj trimis unuiobiect, adică ordinul de apel, şi metoda care se execută ca răspuns la acesta) poate fi:

- Timpurie (statică–early-binding)– compilatorul şi editorul de legături vor fixaadresa metodei care se execută, fără ca aceasta să mai poată fi modificată peparcursul execuţiei;

- Târzie (dinamică–late-binding)– compilatorul va construi un tablou de adreseale metodelor posibile de apel, iar determinarea adresei metodei dorite se vaefectua doar la execuţie. În funcţie valoarea pointerului spre clasa de bază, care poate conţine şi adresa unui obiect al clasei derivate, se va alege metodacorespunzătoare.

Implicit, o metodă este legată static (early, la compilare), iar dacă se doreşte o legare dinamică (late, la execuţie) se va declara virtuală (prin scriereacuvântului virtualvirtual după antetul metodei). O metodă virtuală a unei clase de bază, poate fi moştenită într-o clasă derivată sau poate fi redefinită (înlocuită -overriding).

O metodă se declară virtuală în clasa de bază. Nu se poate declara virtuală doarîntr-o clasă derivată.


În exemplul următor construim o listă de studenti care pot fi bursieri sau căminişti. Acestia primesc de la părinţi o anumită suma, vor cheltui pe distracţii, dacă este cazul, primesc bursă sau plătesc căminul. Din suma rămasa daujumătate la prieteni şi 10% pentru preotecţia mediului.

Vom obţine din clasa Student două clase derivate: Bursier şi Căminist :

StudentStudent

BursierBursier CăministCăminist

Program Studenti; Type Ps=^Student;

Pb=^Bursier; Pc=^Caminist;StudentStudent = Object

Nume : String[30];Par,Che : LongInt;Constructor Init (Ns:String; p,d:LongInt);Constructor Copy (s:Student);Procedure Tips; Virtual;Function Ramasi:LongInt; Virtual;Function Prieten:LongInt;Destructor Eliber; Virtual;Destructor Liber; Virtual;

End;

BursierBursier = Object (StudentStudent)Bursa : LongInt;Constructor Init(s:Student; b:LongInt);Procedure Tips; Virtual;Function Ramasi:LongInt; Virtual;Destructor Eliber; Virtual;Destructor Liber; Virtual;

End;

CaministCaminist= Object(Student)Camin : LongInt;Constructor Init(s:Student; c:LongInt);Procedure Tips; Virtual;Function Ramasi:LongInt; Virtual;Destructor Eliber; Virtual;Destructor Liber; Virtual;

End;


Constructor Student.Init; Begin Nume:=Ns; Par:=p; Self.Che:=d {!} End;Constructor Student.Copy; Begin Self:=s End;Procedure Student.Tips; Begin Writeln(Nume, Par:10,Che:10) End;Function Student.Ramasi; Begin Ramasi :=Par-Che End;Function Student.Prieten; Begin Prieten:=Ramasi Div 2 End;Destructor Student.Eliber; Begin Writeln(' St. e liber ',Nume); End;Destructor Student.Liber; Begin Writeln(' St. Liber ',Nume); End;Constructor Bursier.Init; Begin Copy(s); Bursa:=b End;Procedure Bursier.Tips; Begin Student.Tips; Writeln(Bursa:12,'+B') End;Function Bursier.Ramasi; Begin Ramasi := Par-Che+Bursa End;Destructor Bursier.Eliber; Begin Writeln(' +B. e liber ',Nume); End;Destructor Bursier.Liber; Begin Writeln(' +B. Liber ',Nume); End;Constructor Caminist.Init; Begin Copy(s); Camin:=c End;Procedure Caminist.Tips; Begin Student.Tips; Writeln(Camin:12,'-C') End;Function Caminist.Ramasi;Begin Ramasi := Par-Che-Camin End;Destructor Caminist.Eliber; Begin Writeln(' -C. e liber ',Nume); End;Destructor Caminist.Liber; Begin Writeln(' -C. Liber ',Nume); End;


Function Protectie(s:Ps):LongInt; Begin Protectie := s^.Ramasi Div 10 End;Var s:Student; St:Array[1..10] Of Ps; i:LongInt; n:Byte;Begin Randomize; n:=5+Random(6);

For i:=1 To n Do Begins.Init('S'+Chr(i+48),500000*Random(n)+100000,20000*(n-i)+100000);Case Random(99) Mod 3 Of

0: St[i]:=New(Ps,Copy(s) ); { Simplu }1: St[i]:=New(Pb,Init(s,10000*i)); { + Bursa }2: St[i]:=New(Pc,Init(s,20000*i)); { - Camin }

End End;For i:=1 To n Do With St[i]^ Do Begin Tips;

Writeln(Ramasi:12,Prieten:10,Protectie(St[i]):10)End; Readln;For i:=1 To n Do

If TypeOf(St[i]^)=TypeOf(Student ) Then Writeln ('St') ElseIf TypeOf(St[i]^)=TypeOf(Bursier ) Then Writeln ('+B') ElseIf TypeOf(St[i]^)=TypeOf(Caminist) Then Writeln ('-C'); Readln;

For i:=1 To n DoIf Odd(i) Then Dispose (St[i],Eliber) Else Dispose (St[i],Liber); Readln

End.

Se observă că prin Self se poate referi obiectul curent, iar cu TypeOf se determinătipul. MoMoşştenireatenirea multiplămultiplă nefiind posibilă, îîncăncă, nu putem obţine o clasăcorespunzătoare unui Student_Bursier_Căminist decât prin derivarea unui Bursierîn Bursier_Căminist, sau din Caminist putem obţine Căminist_Bursier.


Program Program Clasa_AbstractaClasa_Abstracta;;Type Type AnimalAnimal = Object= Object

VarstaVarsta: Byte;: Byte;Constructor Constructor Nasc(v:ByteNasc(v:Byte););Function Function Varsta_MedieVarsta_Medie: Byte;: Byte; Virtual;Virtual;Function Function TanarTanar: Boolean; : Boolean; Virtual;Virtual;

End;End;UrsUrs = = Object(AnimalObject(Animal))

Function Function Varsta_MedieVarsta_Medie: Byte;: Byte; Virtual;Virtual;End;End;

LupLup = = Object(AnimalObject(Animal))Function Function Varsta_MedieVarsta_Medie: Byte;: Byte; Virtual;Virtual;

End;End;

Există numeroase situaţii când într-o ierarhie avem nevoie de o clasă abstractă încare vom defini unele trăsături comune fără a avea nici o instantă din clasarespectivă. Ea poate conţine mai multe metode pure (nule) care vor fi redefiniteîntr-o clasă derivată, clasă care devine concretă (şi poate fi instanţiată doar dacătoate metodele pure au fost definite. În exemplul de mai jos, clasa Animal esteabstractă, iar clasele Urs şi Lup sunt concrete.


Function Function Animal.TanarAnimal.Tanar; Begin ; Begin TanarTanar:=:=VarstaVarsta<<Varsta_MedieVarsta_Medie End;End;Function Function Animal.Varsta_MedieAnimal.Varsta_Medie; Begin ; Begin {Varsta_Medie:=0} End;End;Constructor Constructor Animal.NascAnimal.Nasc; Begin ; Begin VarstaVarsta:=v End;:=v End;Function Function Urs.Varsta_MedieUrs.Varsta_Medie; Begin ; Begin Varsta_MedieVarsta_Medie:=100 End;:=100 End;Function Function Lup.Varsta_MedieLup.Varsta_Medie; Begin ; Begin Varsta_MedieVarsta_Medie:= 50 End;:= 50 End;VarVar u:Ursu:Urs; ; l:Lupl:Lup;;BeginBegin

With u Do Begin With u Do Begin Nasc(75); Nasc(75); If If TanarTanar Then Then Writeln('UrsWriteln('Urs TanarTanar ',',VarstaVarsta) {) {}}

Else Else Writeln('UrsWriteln('Urs BatranBatran ',',VarstaVarsta))End;End;

With l Do Begin With l Do Begin Nasc(75); Nasc(75); If If TanarTanar Then Then Writeln('LupWriteln('Lup TanarTanar ',',VarstaVarsta))

Else Else Writeln('LupWriteln('Lup BatranBatran ',',VarstaVarsta) {) {}}End;End; Readln;

End.End.


În concluzie, referitor la Programarea orientată obiect (OOP) :

OOP este o metodă de implementare în care:a) ObiecteleObiectele sunt elementele de bază, b) Orice obiect este o instanţă a unei claseclase, c) Clasele sunt legate (asociate) unele cu altele prin momoşşteniretenire.

Un limbaj este orientat obiect dacă:a) Utilizează obiecteobiecte, b) Obligă obiectele să aparţină unei claseclase, c) Permite momoşştenireatenirea.

Limbajul Pascal oferă noţiunea de clasă, prin care se pot forma ierarhii, deci putem vorbi de o programare orientată obiect (OOP).


OOPOOP înseamnă realizarea unor programe alcătuite dintr-o mulţime de obiecteobiecte care interacţionează pentru a rezolva problema propusă, şipermite reutilizarea elementelor descrise (a interfeţei şi a codului).

Un obiectobiect are o starestare şi un comportamentcomportament (operaţii descrise în interfaţaobiectului) aceste două componente fiind definite prin dateledatele membrumembru(variabilevariabile de de instaninstanţţăă) şi respectiv prin funcfuncţţiileiile membrumembru (metodemetode).

OOP utilizează ormătoarele concepteconcepte: clasa- implementarea unui TAD, obiectul- instanţa unei clase, metoda- mesajul prin care se asigură interfaţa (operaţiile).


OOP are următoarele caracteristicicaracteristici (proprietăproprietăţţii) de bază: încapsularea- gruparea datelor şi a operaţiilor definite pentru acestea,

precum şi protecţia acestor date (ele neputând fi accesate decât prinfuncţiile membru).

moştenirea- păstrarea elementelor (date şi funcţii ale) unei clase (de bază), cu definirea de noi elemente construind o nouă clasă (derivată), formând în felul acesta ierarhii de clase. Moştenirea poate fi şi multiplădacă o clasă moşteneşte mai multe clase.

polimorfism- redefinirea (supraîncărcarea) operaţiilor (funcţiilor). Într-o ierarhie pot fi mai multe funcţii cu acelaşi nume, deci va fi efectuatăoperaţia corespunzătoare obiectului care o apelează. Determinareaoperaţiei se poate face la compilare (legare statică) sau la execuţie(legare dinamică, prin funcţii vituale).

Observaţii referitoare la metodele virtuale: ClaseleClasele care conţin metodemetode virtualevirtuale trebuie să conţină cel puţin un constructor

care nu poate fi virtualvirtual şi trebuie apelat înaintea oricărei metodemetode virtualevirtuale (pentruorice instaninstanţţăă).

O O metodămetodă virtualăvirtuală redefinită trebuie să fie şi ea virtualăvirtuală şi să aibă acelaşi antetantet.

TemeTeme::

a) a) FiindFiind date date ninişştete ((oricâteoricâte) ) figurifiguri geometricegeometrice ((cerccerc, , pătratpătrat, , dreptunghidreptunghi, , sausau triunghitriunghi) ) săsă se se desenezedeseneze şşii săsă se se afiafişşezeeze pentrupentrufiecarefiecare aria aria şşii perimetrulperimetrul..

b) Un b) Un muncitormuncitor plăteplăteşştete 10% din 10% din salarsalar pentrupentru asigurareasigurare, , iariarsalariulsalariul se se calculeazăcalculează astfelastfel: : numărulnumărul_de_ore_lucrate_de_ore_lucrate * 50.000 lei* 50.000 lei

. . .. . . C_15C_15 / / 18.01.201318.01.2013 oraora 14:0014:00 SalaSala N. N. IorgaIorga (2/I)(2/I)SuccesSucces !!

c) c) FiindFiind date date maimai multemulte produseproduse, , săsă se se precizezeprecizeze pentrupentru fiecarefiecaredacădacă esteeste scumpscump sausau expiratexpirat (se (se vorvor alegealege treitrei tipuritipuri care care săsă diferedifereprinprin prepreţţ mediumediu şşii termentermen de de garangaranţţieie).).

12. Obiecte Pascal (tipul Object) - cs.ubbcluj.roper/Fp -_-/Fp_14.pdf · Obiecte Pascal Vom...

Documents

Transcript of 12. Obiecte Pascal (tipul Object) - cs.ubbcluj.roper/Fp -_-/Fp_14.pdf · Obiecte Pascal Vom...