7.

OBIECTE N PASCAL



Problema 1. Scriei un unit-ul corespunztor clasei Ccomplexe (vezi
capitolul 10 din cartea Programarea calculatoarelor. Tehnica programrii n
limbajul Pascal). Atributele clasei sunt private, ele putnd fi accesate exclusiv prin
intermediul funciilor de tip accesoriu get_x i get_y.

unit complex;

interface

type
ccomplexe=object
function get_r:real;
function get_im:real;
procedure init(r,i:real);
procedure conjugat(var b:ccomplexe);
function modul:real;
procedure suma(b:ccomplexe;var c:ccomplexe);
procedure dif(b:ccomplexe;var c:ccomplexe);
procedure produs(b:ccomplexe;var c:ccomplexe);
procedure raport(b:ccomplexe;var c:ccomplexe;
var p:boolean);
private
p_reala,p_imaginara:real;
procedure minus(var b:ccomplexe);
function zero:boolean;
end;

implementation

procedure ccomplexe.conjugat(var b:ccomplexe);
begin
b.p_reala:=p_reala;
b.p_imaginara:=-p_imaginara;
end;
function ccomplexe.get_r:real;
begin
get_r:=p_reala;
end;
function ccomplexe.get_im:real;
begin
get_im:=p_imaginara;
Programarea calculatoarelor. Aplicaii
end;

procedure ccomplexe.init(r,i:real);
begin
p_reala:=r;
p_imaginara:=i;
end;

function ccomplexe.modul:real;
begin
modul:=sqrt(p_reala*p_reala+p_imaginara*p_imaginara);
end;

procedure ccomplexe.suma(b:ccomplexe;var c:ccomplexe);
begin
c.p_reala:=b.p_reala+p_reala;
c.p_imaginara:=b.p_imaginara+p_imaginara;
end;

procedure ccomplexe.minus(var b:ccomplexe);
begin
b.p_reala:=-p_reala;
b.p_imaginara:=-p_imaginara;
end;

procedure ccomplexe.dif(b:ccomplexe;var c:ccomplexe);
var
d:ccomplexe;
begin
b.minus(d);
suma(d,c);
end;

procedure ccomplexe.produs(b:ccomplexe;var c:ccomplexe);
begin
c.p_reala:=b.p_reala*p_reala-b.p_imaginara*p_imaginara;
c.p_imaginara:=b.p_reala*p_imaginara+b.p_imaginara*p_reala;
end;

function ccomplexe.zero:boolean;
begin
zero:=(p_reala=0)and(p_imaginara=0);
end;

procedure ccomplexe.raport(b:ccomplexe;var c:ccomplexe;
var p:boolean);
var
d:ccomplexe;
r:real;
begin
if not b.zero then
begin
r:=b.modul;
b.conjugat(d);
produs(d,c);
c.p_reala:=c.p_reala/sqr(r);
c.p_imaginara:=c.p_imaginara/sqr(r);
p:=true
end
else p:=false;
end;
end.
Obiecte n Pascal

Problema 2. Utiliznd unitatea descris n problema 1, s se construiasc o
clas vectc, cu atributele:
1. referin la un vector de numere complexe cu maxim 50 componente;
2. dimensiunea vectorului a crui adres este memorat n primul atribut
i metodele publice
1. constructor;
2. destructor;
3. o procedur de tip accesoriu;
4. o procedur pentru sortarea vectorului cresctor dup modulul fiecrui
element.

unit op_vect;
interface
uses complex;
type
vect_c=array[1..50]of ccomplexe;
vectc=object
constructor initv;
procedure sort_module;
destructor delv;
procedure getv;
private
pv:^vect_c;
dim:byte;
end;

implementation
constructor vectc.initv;
var
i:byte;r,im:real;
begin
writeln('Dimensiunea:');
readln(dim);
getmem(pv,dim*sizeof(ccomplexe));
for i:=1 to dim do
begin
write('RE(v[',i,'])=');
readln(r);
write('IM(v[',i,'])=');
readln(im);
pv^[i].init(r,im);
end;
end;

destructor vectc.delv;
begin
freemem(pv,dim*sizeof(ccomplexe));
end;

procedure vectc.getv;
var
i:byte;
begin
writeln('vectorul:');
for i:=1 to dim do
writeln(pv^[i].get_r:7:2,'+i* ',pv^[i].get_im:7:2);
end;
Programarea calculatoarelor. Aplicaii

procedure vectc.sort_module;
var
i,j:byte;
a:ccomplexe;
begin
for i:=1 to dim-1 do
for j:=i+1 to dim do
if pv^[i].modul>pv^[j].modul then
begin
a:=pv^[i];
pv^[i]:=pv^[j];
pv^[j]:=a;
end;
end;
end.

Problema 3. Implementai o structur de stiv utiliznd programarea
orientat obiect.
Vor fi utilizate clasele TipNod i TipStiva, astfel:
Clasa TipNod definete structura unui obiect de tip nod i funcionalitatea
minim a obiectelor. Atributele (private) sunt referine: una spre un alt nod, iar
cealalt spre informaia ataat nodului.
Constructorul InitNod i preia informaia de la consol i iniializeaz
spaiul pentru legtura nodului curent cu valoarea nil.
Procedura LegNod primete o referin la nodul precedent i leag de el
nodul curent.
Funcia Det_leg este de tip accesoriu i returneaz cmpul de legtur al
nodului curent.
Procedura ScrieInf scrie la consol informaia din nodul curent.
Clasa TipStiva este un cod general, aplicabil pentru orice obiect TipNod. Este
suficient s se schimbe calsa TipNod pentru a obine o structur nou de tip coad.
Procedura constructor InitStiva stabilete valorea pointer-ului de nceput al
structurii pentru stiva vid.
Procedura Pop nsereaz un nou obiect n stiv. la spatele cozii, utiliznd
procedura LegNod, metod a clasei TipNod. Procedura aloc spaiu pentru nod i l
iniializeaz. De remarcat, n acest sens, modul de utilizare a funciei New.
Procedura Push elimin primul nod al stivei. Din motive care in de
posibilitatea de a asigura testarea, nainte de a terge nodul se afieaz informaia pe
care o conine. Afiarea informaiei este realizat prin intermediul funciei accesoriu
ScrieInf, membru al clasei TipNod.
Dac, dup executarea unor operaii individuale de eliminare a nodurilor, se
dorete eliberarea restului stivei, se poate utiliza destructorul DelStiva. Se observ c
un destructor poate avea coninutul pe care l dorete programatorul.
Procedura ScrieStiva permite afiarea vectorului de informaii asociat stivei.

1. Clasa TipNod

unit nod;
Obiecte n Pascal
interface
type
PtNod=^TipNod;
TipNod=object
Constructor InitNod;
Procedure LegNod(Urm:PtNod);
function Det_leg:PtNod;
Procedure ScrieInf;
private
info:real;
leg:PtNod;
end;

implementation

Constructor TipNod.InitNod;
begin
readln(info);
leg:=nil;
end;
Procedure TipNod.LegNod;
begin
leg:=Urm;
end;

Function TipNod.Det_leg;
begin
Det_leg:=leg;
end;

Procedure TipNod.ScrieInf;
begin
writeln(info);
end;
end.

2. Clasa TipStiva

unit stiva;
interface
uses nod;
type
PtStiva=^TipStiva;
TipStiva=object
Constructor InitStiva;
Procedure Pop;
Procedure Push;
Procedure ScrieStiva;
Destructor DelStiva;
private
Head:PtNod;
end;

implementation

Constructor TipStiva.InitStiva;
begin
Head:=nil;
end;

Procedure TipStiva.Pop;
Programarea calculatoarelor. Aplicaii
var
Ptr:PtNod;
begin
Ptr:=new(PtNod,InitNod);
Ptr^.LegNod(Head);
Head:=Ptr;
end;

Procedure TipStiva.Push;
var
Ptr:PtNod;
begin
if Head<>nil then
begin
Head^.ScrieInf;
Ptr:=Head;
Head:=Head^.Det_leg;
Dispose(Ptr);
end;
end;

Procedure TipStiva.ScrieStiva;
var
Ptr:PtNod;
begin
Ptr:=Head;
if Head=nil then
writeln('Stiva vida!');
while Ptr<>nil do
begin
Ptr^.ScrieInf;
Ptr:=Ptr^.Det_leg;
end;
end;

Destructor TipStiva.DelStiva;
begin
while Head<>nil do
Push;
end;

end.

3. Exemplu de test

program test;
uses stiva;
var
s:PtStiva;
r:real;
i:byte;
begin
writeln('Construim stiva cu 3 elemente:');
s:=new(PtStiva,InitStiva);
for i:=1 to 3 do
begin
s^.Pop;
s^.ScrieStiva;
end;
writeln('Golim Stiva:');
for i:=1 to 3 do
Obiecte n Pascal
begin
write('Elementul extras: ');
s^.Push;
writeln('Stiva este:');
s^.ScrieStiva;
readln;
end;
dispose(s,DelStiva);
end.

Problema 4. Exemplu de ierarhie
Pe baza analizei efectuate n capitolul 10 din Programarea calculatoarelor I.
Tehnica programrii n limbajul Pascal, se poate deduce o ierarhie care poate fi
reprezentat prin arborele din figura 10.11 (vezi capitolul 10 din cartea Programarea
calculatoarelor. Tehnica programrii n limbajul Pascal ), n care metodele au fost
notate cu majuscule. Se pun n eviden trei clase abstracte i patru clase concrete
(pentru care se pot face instanieri).
Clasa Figura introduce caracteristicile comune i generale pentru toate
tipurile de figuri considerate. Aici, (x,y) sunt coordonatele de identificare a figurilor
(nceput de linie, col stnga sus, centru), Culoare definete culoarea de desen, iar
cmpul boolean EsteVizibil arat dac figura este desenat sau nu pe ecran.
Clasa Contur stabilete caracteristicile liniei de contur al figurii, iar clasa
Suprafaa se refer la modul de umplere pentru figurile nchise. La acestea,
constructorul INITDEFAULT asigur obiectelor claselor derivate o iniializare
corect, cu valori implicite: linie continu subire i umplere cu culoare de fond.
Clasele concrete sunt Punct, Linie, Dreptunghi i Cerc. La acestea, constructorii
proprii se definesc cu apel la constructorul clasei printe, metodele virtuale ale
strmoilor sunt redefinite corespunztor, iar aria figurilor se exprim, ca unitate de
masur, in pixeli ptrai.
Avnd n vedere caracterul didactic al exemplului, pentru simplificarea
metodelor, se presupune c figurile sunt disjuncte pe spaiul de desenare. Se evit
astfel complicaiile de refacere a imaginilor suprapuse i figurile pot fi afiate i
ascunse n orice ordine. Pentru a permite desenarea conturului i/sau umplerea
figurilor i n cazul cnd linia utilizat nu este continu, s-a aplicat tehnica de
redesenare, cu haurare a interiorului. Ascunderea unei figuri se realizeaz fie prin
redesenare i umplere cu culoarea de fond, fie prin ncadrarea ntr-un vizor care se
terge cu aceast culoare.
Intrarea n regimul grafic i nchiderea acestuia trebuie gestionate de unitatea
de program apelatoare, prin intermediul variabilei globale InGrafic. Variabila este
setat implicit la valoarea False, ceea ce va determina deschiderea regimului grafic n
unitatea UFigura, la prima solicitare de afiare a unei figuri. Dac unitatea apelatoare
a deschis regimul grafic, atunci aceasta trebuie s atribuie variabilei InGrafic
valoarea True.
Programul de testare TFigura a unitii de program PFigura utilizeaz
obiecte statice i o referina la clasa originar. Se verific, prin apel, funcionarea
corect a constructorilor, a procedurilor de schimbare de proprieti, de desenare i
Programarea calculatoarelor. Aplicaii
ascundere. n finalul programului, se testeaz funcia de calcul al ariei pentru cerc i
dreptunghi, utiliznd legarea dinamic.
Modelul rezolvrii (netestat ca program) este prezentat n continuare.

Program TFigura;
Uses Ufigura,CRT,Graph;
VAR
pf:PFigura;
lin:Linie;
drp:Dreptunghi;
crc:Cerc;
a,b:Integer;
ar:Real;
arstring:String[10];
Begin
{ Linie continua, de culoare implicita, care se
afiseaza, ascunde si se reafiseaza }
lin.INIT(80,10,150,10);
lin.AFISEAZA; Delay(2000);
lin.ASCUNDE; Delay(1000);
lin.AFISEAZA;

{ Cerc cu contur continuu, de culoare rosie }
a:=250; b:=250;
crc.INIT(a,b,100);
crc.SCHIMBACULOARE(Red);
crc.SCHIMBACONTUR(SolidLn,3);
crc.SCHIMBAUMPLERE(1,White);
crc.AFISEAZA;Delay(2000);
crc.ASCUNDE; Delay(3000);
crc.AFISEAZA;

{ Dreptunghi cu contur linie intrerupta, culoare rosie si
umplut cu albastru }
drp.INIT(80,20,70,80);
drp.SCHIMBACONTUR(DashedLn,3);
drp.SCHIMBAUMPLERE(1,Blue);
drp.AFISEAZA; Delay(2000);
drp.ASCUNDE; Delay(3000);
drp.AFISEAZA;

{ Polimorfism in determinarea ariei cercului si
dreptunghiului}
pf:=Addr(crc);
ar:=pf^.ARIE;
str(ar:10:2,arstring);
OutTextXY(a,b+120,'Arie cerc='+arstring);
pf:=Addr(drp);
ar:=pf^.ARIE;
str(ar:10:2,arstring);
OutTextXY(160,60,'Arie dreptunghi='+arstring);
readln;
CloseGraph;
End.

Unit Ufigura;
INTERFACE
Uses Graph;
CONST
InGrafic:Boolean=False;
TYPE
Obiecte n Pascal
{----------Clasa Figura-------------------------------}
PFigura=^Figura;
Figura=OBJECT
x,y:Integer;
EsteVizibil:Boolean;
Culoare:Word;
Constructor INIT(x0,y0:Integer);
Procedure AFISEAZA; VIRTUAL;
Procedure ASCUNDE; VIRTUAL;
Function ARIE:Real; VIRTUAL;
Procedure SCHIMBACULOARE(Cul:Word);
END;

{----------Clasa Punct-------------------------------}
PPunct=^Punct;
Punct=OBJECT(Figura)
Procedure AFISEAZA; VIRTUAL;
Procedure ASCUNDE; VIRTUAL;
END;

{----------Clasa Contur------------------------------}
PContur=^Contur;
Contur=OBJECT(Figura)
TipLinie:Word;
Grosime:Word;
Constructor INITDEFAULT(x0,y0:Integer);
Procedure SCHIMBACONTUR(TipL,GrosL:Word);
END;

{---------Clasa Linie--------------------------------}
PLinie=^Linie;
Linie=OBJECT(Contur)
XSfirsit,YSfirsit:Integer;
Constructor INIT(x0,y0,x1,y1:Integer);
Procedure AFISEAZA; VIRTUAL;
Procedure ASCUNDE; VIRTUAL;
END;

{---------Clasa Suprafata----------------------------}
PSuprafata=^Suprafata;
Suprafata=OBJECT(Contur)
TipHasura:Word;
CuloareUmplere:Word;
Constructor INITDEFAULT(x0,y0:Integer);
Procedure SCHIMBAUMPLERE(TipH,TipC:Word);
END;

{---------Clasa Dreptunghi---------------------------}
PDreptunghi=^Dreptunghi;
Dreptunghi=OBJECT(Suprafata)
Latime,Inaltime:Integer;
Constructor INIT(x0,y0,Lat,Inalt:Integer);
Procedure AFISEAZA; VIRTUAL;
Procedure ASCUNDE; VIRTUAL;
Function ARIE:Real; VIRTUAL;
END;

{------Clasa Cerc------------------------------------}
PCerc=^Cerc;
Cerc=OBJECT(Suprafata)
Raza:Word;
Constructor INIT(x0,y0,R:Integer);
Procedure AFISEAZA; VIRTUAL;
Programarea calculatoarelor. Aplicaii
Procedure ASCUNDE; VIRTUAL;
Function ARIE:Real; VIRTUAL;
END;

IMPLEMENTATION
Procedure INTRAINGRAFIC;
VAR
err,mode,submode:Integer;
Begin
mode:=DETECT;
InitGraph(mode,submode,'c:\bpcopy\bp\bgi');
err:=GraphResult;
If (err=GrOk)then
InGrafic:=True
else begin
WriteLn('* Eroare * ',GraphErrorMsg(err));
Halt(1);
end;
End;

{------Implementare Clasa Figura---------------------}
Constructor Figura.INIT;
Begin
x:=x0;
y:=y0;
EsteVizibil:=False;
Culoare:=White;
End;

Procedure Figura.AFISEAZA;
Begin
End;

Procedure Figura.ASCUNDE;
Begin
End;

Function Figura.ARIE;
Begin
ARIE:=0;
End;

Procedure Figura.SCHIMBACULOARE;
Begin
Culoare:=Cul;
End;

{------Implementare Clasa Punct----------------------}
Procedure Punct.AFISEAZA;
Begin
If Not InGrafic then
INTRAINGRAFIC;
PutPixel(x,y,Culoare);
EsteVizibil:=True;
End;

Procedure Punct.ASCUNDE;
Begin
If EsteVizibil then
begin
PutPixel(x,y,GetBkColor);
EsteVizibil:=False;
end;
Obiecte n Pascal
End;

{------Implementare Clasa Contur---------------------}
Constructor Contur.INITDEFAULT;
Begin
Figura.INIT(x0,y0);
TipLinie:=SolidLn;
Grosime:=1;
End;

Procedure Contur.SCHIMBACONTUR;
Begin
TipLinie:=TipL;
Grosime:=GrosL;
End;

{------Implementare Clasa Linie----------------------}
Constructor Linie.INIT;
Begin
Figura.INIT(x0,y0);
XSfirsit:=x1;
YSfirsit:=y1;
End;

Procedure Linie.AFISEAZA;
Begin
If Not InGrafic then
INTRAINGRAFIC;
SetLineStyle(TipLinie,0,Grosime);
SetColor(Culoare);
Line(x,y,XSfirsit,YSfirsit);
EsteVizibil:=True;
End;

Procedure Linie.ASCUNDE;
Begin
If EsteVizibil then
begin
SetLineStyle(TipLinie,0,Grosime);
SetColor(GetBkColor);
Line(x,y,XSfirsit,YSfirsit);
EsteVizibil:=False;
end;
End;

{------Implementare Clasa Suprafata------------------}
Constructor Suprafata.INITDEFAULT;
Begin
Contur.INITDEFAULT(x0,y0);
TipHasura:=EmptyFill;
CuloareUmplere:=Black;
End;

Procedure Suprafata.SCHIMBAUMPLERE;
Begin
TipHasura:=TipH;
CuloareUmplere:=TipC;
End;

{------Implementare Clasa Dreptunghi-----------------}
Constructor Dreptunghi.INIT;
Begin
Suprafata.INITDEFAULT(x0,y0);
Programarea calculatoarelor. Aplicaii
Latime:=Lat;
Inaltime:=Inalt;
End;

Procedure Dreptunghi.AFISEAZA;
Begin
If Not InGrafic then
INTRAINGRAFIC;
SetFillStyle(TipHasura,CuloareUmplere);
SetLineStyle(TipLinie,0,Grosime);
SetColor(Culoare);
Bar(x,y,x+Latime,y+Inaltime);
Rectangle(x,y,x+Latime,y+Inaltime);
EsteVizibil:=True;
End;

Procedure Dreptunghi.ASCUNDE;
Begin
If EsteVizibil then
begin
SetViewport(x-1,y-1,x+Latime+1,y+Inaltime+1,ClipOn);
ClearViewport;
SetViewport(0,0,GetMaxX,GetMaxY,ClipOn);
EsteVizibil:=True;
end;
End;

Function Dreptunghi.ARIE;
Begin
ARIE:=Latime*Inaltime;
End;

{------Implementare Clasa Cerc-----------------------}
Constructor Cerc.INIT;
Begin
Suprafata.INITDEFAULT(x0,y0);
Raza:=R;
End;

Procedure Cerc.ASCUNDE;
Begin
If EsteVizibil then
begin
SetLineStyle(TipLinie,0,Grosime);
SetColor(GetBkColor);
SetFillStyle(SolidFill,GetBkColor);
PieSlice(x,y,0,360,Raza+1);
EsteVizibil:=False;
end;
End;

Procedure Cerc.AFISEAZA;
Begin
If Not InGrafic then INTRAINGRAFIC;
SetLineStyle(TipLinie,0,Grosime);
SetColor(Culoare);
SetFillStyle(TipHasura,CuloareUmplere);
PieSlice(x,y,0,360,Raza);
Circle(x,y,Raza);
EsteVizibil:=True;
End;
Function Cerc.ARIE;
Begin
Obiecte n Pascal
ARIE:=PI*Raza*Raza;
End;
END.

Exerciii

1. Scriei un unit Pascal pentru implementarea unei clase vector, n care s fie
cuprinse operaiile uzuale asupra vectorilor de numere reale (sortare, cutare,
interclasare).
2. Scriei un unit Pascal pentru implementarea unei clase matrice, n care s
fie cuprinse operaiile uzuale asupra matricelor de numere reale (calculul transpusei
unei matrice, suma i produsul a dou matrice, calculul determinantului i inversei
unei matrice, verificarea faptului c matricea este ptratic, verificarea proprietii de
simetrie a unei matrice).
3. Scriei un unit Pascal pentru lucrul cu obiecte dinamice n cazul clasei
vector.
4. Scriei un unit Pascal pentru lucrul cu obiecte dinamice n cazul clasei
matrice.
5. Utiliznd clasa Ccomplexe, scriei un unit Pascal pentru implementarea
unei clase matrice de numere complexe, cu operaiile de adunare, nmulire i ridicare
la putere a unei matrice. Atributul de caracterizare a matricei este dinamic.
6. Scriei un unit pentru implementarea orientat obiect a structurii de coad.
7. Scriei un unit Pascal pentru implementarea orientat obiect a structurii de
list. Operaiile elementare sunt: parcurgerea, cutarea unei element, inserarea i
extragerea unui element n/din poziia p.