| CATEGORII DOCUMENTE |
Dupa cum s-a precizat, daca intr-o clasa se declara si se descrie o functie constructor, atunci cand se ceeaza o instanta obiect a acelei clase, functia constructor se executa automat determinand initializarea diversilor membri ai clasei respective. De asemenea, la declararea unei instante obiect se aloca memoria necesara acesteia. In mod asemanator, limbajul C++ permite definirea unei functii destructor care se va executa automat cand se distrugea instanta obiect a unei clase. In mod uzual, functia destructor se executa automat in urmatoarele doua situatii: in cazul in care in program se intalneste operatorul delete in vederea eliberarii memoriei anterior alocata instantei obiect sau in cazul terminarii efective a programului. Mai jos, sunt date prototipurile generale ale unei functii constructor si functiei destructor asociata.
// declararea prototipului functiei constructor
nume_functie_constructor (parametrii_formali_ai_functiei_constructor);
// declararea prototipului functiei destructor
~nume_functie_constructor (void);
Observatii:
- functia destructor trebuie sa aiba acelasi nume ca functia constructor asociata, preccedat in mod definitoriu de caracterul tilda(~);
- functia destructor nu accepta parametri formali si, ca si functia constructor, nu poate returna nicio valoare;
- utilitatea evidenta a functiilor destructor se face imperios simtita, mai ales, atunci cand clasele aloca memorie dinamica unor date membre, cum ar fi matricele, structurile si alte tipuri complexe de date. Prin functiile destructor se poate elibera memoria alocata pe parcursul executarii programului, unor date membre;
- prin functiile destructor se pot efectua multe din operatiile specifice listelor simplu si dublu inlantuite, cum arfi: stergerea sau adaugarea, unuor elemente in lizta;
- functiile destructor nu trebuie apelate si executate inaintea incheierii ciclului de existenta a instantei obiect respective, ci numai cand se asigura faptul ca instanta obiect urmeaza efectiv sa fie distrusa.
Se considera o echpa de muncitori (max=20) cu structura: cod matricol (intre 1000 si 9999), nume, prenume, salariu brut, somaj, CAS (Contributia pentru Asigurari Sociale), CASS (Contributia pentru Asigurari Sociale de Sanatate), baza de impozitare, impozitul pe salariu, retineri si rest de plata. Prin intermediul unei clase, in care a fost definita o functie constructor careia i se transmit parametri efectivi: cod matricol, nume, prenume, salariu brut si retinerile, sa se calculeze: contributia de somaj, CAS, CASS, baza de impozitare, impozitul, si restul de plata pentru toti muncitorii din echipa, condusi de seful de achipa aflat in capul listei, pentru seful de sectie si inginerul sef. Concomitent cu functia constructor adecvata, se va defini si functia destructor asociata, care, la terminarea programului, sa afiseze mesajele cu privire la distrugerea instantelor declarate in functia principala main().
#include<iostream.h>
#include<iomanip.h>
#define nmax 20
int i;
// declararea structurii unui angajat
struct tipangajat
// declararea procentelor de somaj, CAS si CASS
double psomaj=1;
double pcas=9.5;
double pcass=6.5;
// declararea clasei salarii
class salarii
// descrierea functiei destructor
~salarii (void)
if(tm=='a')
if(tm=='s')
};
// declararea vectorului cu structurile angajatilor
struct tipangajat statplata[nmax];
char tm;
// descrierea functiei de calcul al salariilor
void calculeaza_statplata(int n)
};
// descrierea functiei de afisare stat de plata
void afiseaza_statplata(int n)
};
void main(void)
while ((n<1)||(n>nmax));
// citirea datelor unui angajat
for(i=0;i<n;i++)
cout<<'n==================================';
// creearea instantei angajat a clasei salarii
salarii angajat(p,n,'m');
cout<<'n stat de plata muncitori';
cout<<'n==================================';
// apelarea functiei ptr calcularea salariilor angajatilor
angajat.calculeaza_statplata(n);
// afisarea salariilor angajatilor
angajat.afiseaza_statplata(n);
cout<<'n ==================================';
cout<<'n cod matricol sef sectie (1000-9999):';
cin>>psefsectie[0].matricol;
cout<<'n nume sef sectie:';
cin>>psefsectie[0].nume;
cout<<'n prenume sef sectie:';
cin>>psefsectie[0].prenume;
cout<<'n salariu brut sef sectie :';
cin>>psefsectie[0].brut;
cout<<'n retineri sef sectie:';
cin>>psefsectie[0].retineri;
cout<<'n ===================================';
// creearea instantei sefsectie a clasei salarii
salarii sefsectie(psefsectie,1,'a');
cout<<'n stat de plata sef de sectie ';
cout<<'n==================================';
// apelarea functiei ptr calcularea salariului sefului de sectie
sefsectie.calculeaza_statplata(1);
// afisarea salariului sefului de sectie
sefsectie.afiseaza_statplata(1);
cout<<'n ===================================';
cout<<'n cod matricol ing. sef (1000-9999):';
cin>>pingsef[0].matricol;
cout<<'n nume ing. sef:';
cin>>pingsef[0].nume;
cout<<'n prenume ing. sef:';
cin>>pingsef[0].prenume;
cout<<'n salariu brut ing. sef :';
cin>>pingsef[0].brut;
cout<<'n retineri ing. sef:';
cin>>pingsef[0].retineri;
cout<<'n ===================================';
// creearea instantei ingsef a clasei salarii
salarii ingsef(pingsef,1,'s');
cout<<'n stat de plata inginer sef ';
cout<<'n==================================';
// apelarea functiei ptr calcularea salariului ing sef
ingsef.calculeaza_statplata(1);
// afisarea salariului ing sef
ingsef.afiseaza_statplata(1);
cout<<'n ===================================';
cout<<'n continuati salarizarea?(d/n):';
cin>>r;
// la terminarea programului, prin functia destructor definita
// se distrug instantele creeate cu mesajele predeclarate
}
In urma executarii programului de mai sus, s-au obtinut rezultatele urmatoare, punandu-se in evidenta declararea, descrierea si utilizarea functiei destructor pentru distrugerea instantelor create in functia main(), cu afisarea mesajelor de rigoare, transmiterea si utilizarea structurilor, ca parametri formali in functia constructor.
numarul de angajati (1<=n<=20):2
cod matricol 0 (1000-9999):100
nume :pop
prenume :ion
salariu brut :3000
retineri :1000
cod matricol 1 (1000-9999):200
nume :stanescu
prenume :stefan
salariu brut :2000
retineri :850
====================================================
stat de plata muncitori
====================================================
matricol:100
nume:pop
prenume:ion
salariu brut:3000.00
somaj:30.00
CAS:285.00
CASS:195.00
impozit:398.40
retineri:1000.00
rest plata:1091.60
matricol:200
nume:stanescu
prenume:stefan
salariu brut:2000.00
somaj:20.00
CAS:190.00
CASS:130.00
impozit:265.60
retineri:850.00
rest plata:544.40
====================================================
cod matricol sef sectie (1000-9999):300
nume sef sectie:popescu
prenume sef sectie:sandu
salariu brut sef sectie :4000
retineri sef sectie:1200
====================================================
stat de plata sef de sectie
====================================================
matricol:300
nume:popescu
prenume:sandu
salariu brut:4000.00
somaj:40.00
CAS:380.00
CASS:260.00
impozit:531.20
retineri:1200.00
rest plata:1588.80
========================================
cod matricol ing. sef (1000-9999):500
nume ing. sef:stabu
prenume ing. sef:spiridon
salariu brut ing. sef :5000
retineri ing. sef:2000
========================================
stat de plata inginer sef
========================================
matricol:500
nume:stabu
prenume:spiridon
salariu brut:5000.00
somaj:50.00
CAS:475.00
CASS:325.00
impozit:664.00
retineri:2000.00
rest plata:1486.00
========================================
continuati salarizarea?(d/n):n
s-a distrus instanta inginerului sef stabu spiridon
s-a distrus instanta sefului de sectie popescu sandu
s-a distrus instanta muncitorilor cu seful de achipa pop ion
Functiile destructor sunt utilizate si pentru distrugerea instantelor obiectelor care gestioneaza diverse stive de date, ocazie cu care se si elibereaza memoria alocata unei stive, prin functia constructor.
Se considera o stiva de containere cu caracteristicile:cod container, un numar cuprins intre 1 si 99, continut, un camp alfanumeric de 20 caractere, data ambalarii (zi, luna si an) si greutatea in kg. Sa se simuleze activitatile de stivuire si de incarcare intr-un mijloc de transport a containerelor din stiva prin intermediul unei clase stivuire_incarcare, care contine: o functie constructor utilizata pentru initializarea stivei (alocarea spatiului de memorie adecvat), o functie destructor necesata distrugerii instantelor obiectelor folosite, o functie de depunere container in stiva si o functie de extragere container din stiva.
#include<iostream.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
#define nmax 6
int nrob=2;
struct tipdata
struct tipstiva
class stivuire_incarcare
// descrierea functiei constructor care aloca spatiul pentru stiva
stivuire_incarcare::stivuire_incarcare(void)
// descrierea functie destructor
stivuire_incarcare::~stivuire_incarcare (void)
// descrierea functiei depune_in_stiva()
int stivuire_incarcare::depune_in_stiva(struct tipstiva *ptrstructura)
*ptrcontainer=*ptrstructura;
*stivuire_incarcare::varfstiva=*ptrcontainer;
cout<<'n varf stiva ='<<stivuire_incarcare::varfstiva;
cout<<'n cod container ='<<stivuire_incarcare::varfstiva->cc;
stivuire_incarcare::varfstiva++;;
return 1;
/* descrierea functiei de extragere din stiva */
int stivuire_incarcare::extrage_din_stiva(struct tipstiva *ptrstructura)
stivuire_incarcare::varfstiva--;
*ptrstructura=*stivuire_incarcare::varfstiva;
ptrstructura=stivuire_incarcare::varfstiva;
return 1;
void main(void)
do
while((n<1)||(n>nmax));
while(!terminat)
else
cout<<'n depasirea capacitatii de depozitare';
break;
case 's':
if(k>=1)
if(k%2)
else
k--;
}
else
cout<<'n nu mai sunt containere depozitate';
break;
case 't':
terminat=1;
break;
default:
cout<<'n operatie gresit selectata';
}
}
Rezultatele executiei programului de mai sus, sunt afisate in continuare, punandu-se in evidenta urmatoarele: initializarea si alocarea memoriei pentru o stiva de structuri, depunerea adreselor structurilor intr-o stiva si a structurilor aferente la adresle specificate in stiva, extragerea adreselor structurilor din stiva si a structurilor corespunzatoare de la aceste adrese precum si distrugerea instantelor celor doua obiecte create in program dupa terminarea folosirii acestora.
initializarea stivei de containere
initializarea stivei de containere
numarul maxim de containere, n(1<=n<=6)=4
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:a
cod container:100
continut container:ciment
ziua ambalarii:11
luna ambalarii:11
anul ambalarii:2005
greutate container:150
varf stiva =0x00790610
cod container =100
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:a
cod container:200
continut container:var
ziua ambalarii:21
luna ambalarii:11
anul ambalarii:2005
greutate container:400
varf stiva =0x007904F0
cod container =200
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:a
cod container:300
continut container:suruburi
ziua ambalarii:11
luna ambalarii:10
anul ambalarii:2005
greutate container:125
varf stiva =0x00790638
cod container =300
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:a
cod container:400
continut container:saibe
ziua ambalarii:07
luna ambalarii:09
anul ambalarii:2005
greutate container:175
varf stiva =0x00790518
cod container =400
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:r
operatie gresit selectata
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:d
operatie gresit selectata
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:a
depasirea capacitatii de depozitare
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:s
s-a extras containerul obiectului 2:
===================================:
cod container :400
continut container :saibe
data containerului :07/09/2005
greutate container :175
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:s
s-a extras containerul obiectului 1:
=======================================:
cod container :300
continut container :suruburi
data containerului :11/10/2005
greutate container :125
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:s
s-a extras containerul obiectului 2:
===================================:
cod container :200
continut container :var
data containerului :21/i1/2005
greutate container :400
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:s
s-a extras containerul obiectului 1:
=======================================:
cod container :100
continut container :ciment
data containerului :11/11/2005
greutate container :150
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
Alegeti operatia dorita:s
nu mai sunt containere depozitate
a - asezare container in stiva
s - scoatere container din stiva
t - terminare program
s-a distrus instanta obiect2
s-a distrus instanta obiect1
2. Proprietati ale claselor : Incapsularea, mostenirea si polimorfismul in Programarea Orientata pe Obiecte (POO)
Incapsularea nu reprezinta altceva decat proprietatea claselor de obiecte de a grupa sub aceeasi structura datele si metodele aplicabile asupra datelor. In sensul programarii orientata pe obiecte, incapsularea defineste, de asemenea, modalitatea in care diversele obiecte si restul programului se pot referi la datele specifice obiectelor. Dupa cum s-a precizat clasele din C++ permit separarea datelor in date private si date publice. Programele utilizatorilor pot accesa si utiliza datele unui obiect, declarate private, numai prin utilizarea unor metode definite public. Separarea datelor in sectiuni de date publice si private datermina protejarea datelor fata de utilizarea lor eronata in programe. Incapsularea, desi nu am precizat-o distinct, este prezenta in toate exemplele anterioare.
2. 2. Mostenirea este o proprietate prin care o clasa de obiecte poate fi obtinuta din derivarea unei clase sau a mai multor clase anterior definite. O clasa derivata poate constitui, la randul ei, clasa de baza pentru derivarea altor clase. Cand se defineste o clasa se incepe cu caracteristicile ei generale. Definirea unei alte clase prin derivarea clasei de baza presupunea definirea caracteristicilor specifice acesteia in raport cu cea de baza. Daca am defini clasa de baza Cai aceasta ar trebui sa contina caracteristicile comune ale tuturor raselor de cai : nume, origine, inaltime, greutate si culoare. Urmatorul nivel de declarare a tipului de clase de cai poate fi mai detaliat. De exemplu, clasa CaiCuPete si clasa CaiFaraPete, ar trebui sa mosteneasca toate caracteristicile comune care au fost definite la clasa de baza Cai alaturi de caracteristicile specifice claselor derivate cum ar fi : la clasa CaiCuPete :lungimea parului, culoarea petelor, cal de cursa iar la clasa CaiFaraPete : lungimea parului, tip de utilizare (de tractiune, de curse, etc). Nivelurile de derivare ale claselor pot creste ca un arbore genealogic.
fulger
Structura arborescenta a mostenirii clasei Cai
Structura arborescenta a claselor derivate
Conceptul de mostenire este deosebit de important in programarea obiectuala. Posibilitatea de a crea o arborescenta de clase, de la cea mai generala la cea mai specifica, permite un control mai bun al programelor, permitand, totodata, lisibilitatea facila a programelor de catre utilizatorii textelor sursa sau dezvoltatorii de programme. Mostenirea si proprietatile acesteia reprezinta adevarata forta in programarea obiectuala in C++.
2. 2. 1. Clasele de baza si derivate
Clasa de baza
Clasa derivata
 |
Detalierea unui exemplu simplu de mostenire
Sa se citeasca de la tastatura informatiile specifice cartilor dintr-o librarie: denumire carte, numele autorului, prenumele autorului, numarul de pagini si pretul. Prin intermediul unei clase de baza numita carte, care precizeaza proprietatea, titlul cartii si o clasa derivata numita FisaLibrarie care precizeaza celelalte date despre o carte, proprietatile (numele autorului, prenumele autor, editura, numarul de pagini si pretul) si metodele de prelucrare (initializarea si afisarea datelor cartilor din librarie), sa se afiseze cartile din librarie cu toate proprietatile lor.
// definirea clasei carte
#include<iostream.h>
#include<string.h>
#include<stdio.h>
// definirea clasei de baza carte
class carte
void afisaza_nume()
;
private:
char nume[40];
};
// definirea clasei derivate FisaLibrarie
class FisaLibrarie: public carte
;
void afisaza_Libraria()
;
private:
char autor1[40];
char autor2[40];
char editura[40];
int nrpag;
double pret;
};
void main()
}
Rezultatele executiei programului anterior sunt redate mai jos, care precizeaza modul cum se obtine o clasa derivata dintr-o clasa de baza, punandu-se in evidenta proprietatea de baza a unei clase derivate de a mosteni datele si metodele clasei de baza.
denumirea cartii:Visual Basic 6. Baze de date
numele autorului:Winemiller
prenumele autorului:Eric
editura:Teora
nr. pagini:895
pret:59
Lista cartilor din librarie:
====================================
Titlul cartii:Visual Basic 6. Baze de date
numele autorului: Winemiller
prenumele autorului: Eric
editura: Teora
nr de pagini: 895
pretul cartii: 59
====================================
continuati?(d/n):d
denumirea cartii:JAWA in 21 days
numele autorului:Lemay
prenumele autorului:Laura
nr. pagini:527
pret:49
Lista cartilor din librarie:
====================================
Titlul cartii:JAWA in 21 days
numele autorului: Lemay
prenumele autorului: Laura
editura: The Macmillan Information SuperLibrary
nr de pagini: 527
pretul cartii: 49
====================================
continuati?(d/n):n
In programul de mai sus, din clasa de baza carte, s-a obtinut clasa FisaLibrarie care, prin intermediul liniei de definire class FisaLibrarie: public carte, informeaza compilatorul ca este o clasa derivata din clasa de baza carte. Restul din declaratia clasei derivate este asemanator cu cele invatate la descrierea claselor, cu exceptia functiei constructor care contine o apelare a functiei constructor a clasei de baza carte :
FisaLibrarie(char *nume, char *aut1, char *aut2, char *ed, int *np, double *p):carte(nume)
;
Dupa cum se observa, atunci cand programul creaza o noua instanta a clasei derivate FisaLibrarie si apeleaza functia constructor , FisaLibrarie, mai intai va apela functia constructor a clasei de baza carte(nume) dupa care va apela si executa corpul propriei functii constructor. Neprecizarea functiei constructor a clasei de baza, in declararea functiei constructor a clasei derivate, va antrena un mesaj de eroare, chiar in timpul compilarii.
Clasele derivate pot accesa membrii protejati (declarati protected) ai claselor de baza. Cand se creaza o clasa trebuie sa se precizeze care membri vor fi publici, privati sau protejati si sa se tina seama ca orice clasa derivata din aceasta sa o poata utiliza. Daca o clasa nu va fi utilizata niciodata ca o clasa de baza pentru alte clase derivate se vor utiliza membri privati in locul celor protejati, iar daca clasa va fi utilizata, ulterior, ca o clasa de baza, atunci utilizarea membrilor protejati devine imperioasa in economisirea timpilor de programare
Sa se citeasca de la tastatura informatiile specifice cartilor dintr-o librarie: denumire carte, numele autorului, prenumele autorului, numarul de pagini si pretul, prin intermediul unei clase de baza numita carte, care precizeaza proprietatea, titlul cartii, ca membru public, numarul de pagini si pretul ca membri protejati si o clasa derivata numita FisaLibrarie care precizeaza celelalte date despre o carte, proprietatile : numele autorului, prenumele autor, editura ca membri privati si metodele de prelucrare (initializarea si afisarea datelor cartilor din librarie)
// definirea clasei carte
#include<iostream.h>
#include<string.h>
// definirea clasei de baza carte
class carte
void afisaza_nume()
;
protected :
int nrpag ;
float pret ;
void afisaza_nrpag(void)
void afisaza_pret(void)
private:
char nume[40];
};
// definirea clasei derivate FisaLibrarie
class FisaLibrarie: public carte
;
void afisaza_Libraria()
;
private:
char autor1[40];
char autor2[40];
char editura[40];
void main()
}
Rezultatele acestui program se obtin in aceeasi maniera ca in programul anterior, cu deosebirea ca se folosesc, in clasa derivata, membri de tip protected.
In programul de mai sus, clasa carte declara ca membri protejati numarul de pagini (nrpag), pretul cartii (pret) si functiile afisaza_nrpag si afisaza_pret fapt ce permite accesarea acestora din clasa derivata FisaLibrarie : citirea datelor nrpag si pret si apelarea pentru executie a functiilor afisaza_nrpag si afisaza_pret.
Mosteniri publice, private si protejate
Mostenirea publica. Declararea publica a unei clase de baza intr-o clasa derivata
O clasa derivata dintr-o clasa de baza poate fi facuta printr-o derivare publica, caz in care clasa derivata poate avea acces direct la membri clasei de baza, acest lucru incalcand regulile incapsularii, lucru care trebuie evitat in programarea obiectuala. Derivarea privata permite transformarea tuturor membrilor clasei de baza in membri privati.
Problema 5
Sa se deriveze de tip public o clasa de baza pentru a se avea acces, din clasa derivata, la toti membri clasei de baza. In clasa de baza se vor declara pubice datele: a,b si data si functia constructor care citeste efectiv valorile a si b. In clasa derivata de tip public se va descrie functia constructor care afiseaza suma si produsul numerelor a si b iar in functia principala main() prin intermediul unui obiect al clasei derivate se va atribui datei publice data din clasa de baza suma patratelor celor doua numere a si b, afisandu-se datele a, b si data precum si diferenta si catul datelor a si b.
#include <iostream.h>
class ClasaDeBaza
;
int data,a,b;
};
class ClasaDerivata:public ClasaDeBaza
;
};
void main(void)
}
Constructorul clasei de baza
dati nr intregi a,b=50 25
Constructorul clasei derivate
(50)+(25)=75
(50)*(25)=1250
(50)-(25)=25
(50)/(25)=2
data=(50)*(50)+(25)*(25)=3125
continuati?(d/n):d
Constructorul clasei de baza
dati nr intregi a,b=-90 45
Constructorul clasei derivate
(-90)+(45)=-45
(-90)*(45)=-4050
(-90)-(45)=-135
(-90)/(45)=-2
data=(-90)*(-90)+(45)*(45)=10125
continuati?(d/n):d
Constructorul clasei de baza
dati nr intregi a,b=-120 -30
Constructorul clasei derivate
(-120)+(-30)=-150
(-120)*(-30)=3600
(-120)-(-30)=-90
(-120)/(-30)=4
data=(-120)*(-120)+(-30)*(-30)=15300
continuati?(d/n):n
Daca clasa derivata, ar mosteni clasa de baza in mod privat, atunci apelarea membrilor publici ai clasei de baza ar declansa, in timpul compilarii erori specifice. Pentru edificare, in programul de mai sus, se poate schimba linia de definire a clasei derivate class ClasaDerivata:public ClasaDeBaza cu class ClasaDerivata: private ClasaDeBaza, urmarindu-se erorile de compilare semnalate.
2. 2. 3. Mostenirea protejata. Declararea protejata a unei clase de baza intr-o clasa derivata
Pentru a preveni accesul altor parti ale programului la anumiti membri ai clasei de baza, dar permitand claselor mostenitoare accesul la membri disponibili ai clasei de baza, acestia se pot declara de tip protected. De asemenea exista posibilitatea mostenirii unei intregi clase de baza ca protected, acest lucru permitand clasei derivate sa utilizeze toti membri publici si protejati ai clasei de baza ca membri protejati ai sai.
Sa se deriveze de tip protected o clasa de baza pentru a se avea acces, din clasa derivata, la toti membri clasei de baza. In clasa de baza se vor declara protected datele x si y, functia de setare a variabilelor x si y, setarexy() si functia de afisare a variabilelor setate x si y, afisarexy(). In clasa derivata de tip protected se vor declara privat variabilele va, vb si sumaxy, public functia de calcul a sumei x+y, calculsuma(), dupa ce s-a apelat functia setarexy() pentru atribuirea valorilor va si vb citite in functia de calcul, si functia afisaza_x_y_sumaxy() care apeleaza pentru afisare functia publica afisazaxy() din clasa de baza, iar in functia principala main(), prin intermediul unui obiect al clasei derivate se vor apela functiile calculsuma() si afisaza_x_y_sumaxy() prin intermediul uni obiect al clasei derivate, adecvat definit.
#include <iostream.h>
class ClasaDeBaza
void afisazaxy()
};
class ClasaDerivata:protected ClasaDeBaza
void afisaza_x_y_sumaxy()
};
void main(void)
Rezultatele afisate de program pun in evidenta cum o clasa derivata de tip protected dintr-o clasa de baza, utilizeaza prin mostenire membrii clasei de baza
apelarea in main() a functiei calculsuma()
citirea valorilor va si vb in clasa derivata
si apelarea functiei setarexy()
va, vb=78 98
atribuirea valorilor a si b,
citite in clasa derivata, variabilelor x si y
apelarea in main() a functiei afisaza_x_y_sumaxy()
afisarea valorilor x si y si a sumei lor in clasa
derivata prin functia afisazaxy()
afisarea valorilor x si y, atribuite prin functia setarexxy()
x=78 y=98
(78)+(98)=176
continuati?(d/n):
apelarea in main() a functiei calculsuma()
citirea valorilor va si vb in clasa derivata
si apelarea functiei setarexy()
va, vb=-98 45
atribuirea valorilor a si b,
citite in clasa derivata, variabilelor x si y
apelarea in main() a functiei afisaza_x_y_sumaxy()
afisarea valorilor x si y si a sumei lor in clasa
derivata prin functia afisazaxy()
afisarea valorilor x si y, atribuite prin functia setarexxy()
x=-98 y=45
(-98)+(45)=-53
continuati?(d/n):d
apelarea in main() a functiei calculsuma()
citirea valorilor va si vb in clasa derivata
si apelarea functiei setarexy()
va, vb=-35 -77
atribuirea valorilor a si b,
citite in clasa derivata, variabilelor x si y
apelarea in main() a functiei afisaza_x_y_sumaxy()
afisarea valorilor x si y si a sumei lor in clasa
derivata prin functia afisazaxy()
afisarea valorilor x si y, atribuite prin functia setarexxy()
x=-35 y=-77
continuati?(d/n):n
Dupa cum se constata, in programul de mai sus, clasa ClasaDerivata, in derivarea clasei de baza, foloseste cuvantul cheie protected. Acest lucru determina transformarea tuturor membrilor clasei ClasaDeBaza in membri privati, in contextul clasei ClasaDerivata. In aceste conditii orice incercare a programului de a accesa un membru privat, cum ar fi setarexy() sau afisazaxy(), ar conduce la erori de compilare deoarece acesti membri sunt incapsulati si protejati in cadrul clasei ClasaDerivata. Din aceste motive singurele obiecte ce pot accesa functiile mostenite de la clasa de baza sunt functii de interfata sau clase care se deriveaza din clasa ClasaDerivata.
Probleme propuse
1.Sa se realizeze o ierarhie de clase care
descrie multimea elementelor din plan intalnite in geometrie. Se considera clasa
de baza CPunct , din ea se deriveaza clasa CDreapta , clasa CCerc
, clasa CDreptunghi , clasa CPatrat .Pentru clasele CCerc,CDreptunghi
si CPatrat sa se implementeze o functie de calcul a ariei si o functie pentru
calculul perimetrului.
2.Sa se construiasca o ierarhie de clase care descrie rasele de caini.Se
considera clasa de baza Caine , din ea se deriveaza clasa CaineCuPete , clasa
CaineFaraPete . Despre un caine se cunosc : numele, inaltime, greutate, varsta,
culoare.Despre cainii cu pete se stie si numarul de pete. Sa se defineasca
pentru fiecare clasa o functie de citire a datelor, respectiv una de afisare.
3.Sa se construiasca o ierarhie de clase
care sa simuleze functionarea unei retele de calculatoare. Reteaua admite maxim
10 utilizatori si furnizeaza protectie prin parola si functii pentru conectare
si deconectare. Reteaua este gestionata de un administrator.Pentru fiecare
utilizator se cunoaste parola si numele. Administratorul este la randul sau tot
un utilizator care are anumite facilitati in plus : poate vizualiza toti
utilizatorii retelei, poate deconecta unul sau mai multi utilizatori , poate
schimba setul de comenzi functionale.
Sa se realizeze clasa CRetea care va avea un nume, un numar de maxim 11
utilizatori din care unul singur poate fi administrator.
4.Sa se realizeze o ierarhie de clase care descrie habitatul animalelor dintr-o
rezervatie naturala. In rezervatie pot fi intalnite urmatoarele animale
:iepuri,ursi,caprioare,vulpi si lei.Unele dintre animale sunt ierbivore,alte carnivore
sau chiar ierbivore si carnivore.Ierarhia de clase va avea clasa de baza
CAnimal, clasa abstracta, din care se vor deriva doua clase : CAnimalIerbivor
si CAnimalCarnivor. Pentru fiecare tip de animal vom avea o clasa
corespunzatoare care se va extinde din una din clase de mai sus, sau din
ambele, corespunzator modului de hranire a animalului.
Despre un animal se cunosc urmatoarele informatii comune : nume, data
aducerii,greutate,hrana preferata, cantitate pe zi. In plus despre iepure se
cunoaste suprafata minima pe care poate trai;despre vulpe - temperatura maxima
de trai, tip (polara, indigena); despre leu - temperatura minima suportata,
tara de provenienta;despre urs - perioada de hibernare; despre caprioara -
numarul de pui. Sa se construiasca o clasa CRezervatie care va contine o
multime de animale.Sa se populeze rezervatia.
5.Se prezinta in continuare descrierea unei ierarhii de clase:
Clasele sociale din istorie pot fi caracterizate prin urmatoarele elemente
definitorii:
- sclav = nume, nume stapin
- stapin = nume, numar de sclavi
- iobag = nume, nume stapin, venit anual
- feudal = nume, suprafata de pamint detinuta, titlu
- proletar = nume, salariu lunar
- capitalist = nume, numar de fabrici detinute
O 'carte de istorie' poate fi considerata ca o 'lista' de
astfel de categorii/persoane.Fiecare clasa sociala are propriul
'salut'. Sa se afiseze saluturile tuturor persoanelor dintr-o
'carte de istorie' de la un moment dat.
Pentru aceasta ierarhie se cere:
1. Sa se implementeze aceasta ierarhie folosind tehnica OOP a claselor
abstracte (care inglobeaza tot ceea ce este comun intr-o ierahie) si tehnica
metodelor virtuale: toate functiile care se pot modifica pe nivelele
'inferioare' ale ierarhiei sint virtuale.
2. Fiecarei clase sa i se ofere constructori, destructori si functii specifice,
corespunzatoare.
3. Prelucrarea obiectelor din aceasta ierarhie in mod uniform se poate face
prin tehnica 'listelor eterogene': intr-o structura tip lista
(tablou, lista simplu/dublu inlantuita, arbore,) se pastreaza pointeri la
obiectul abstract cel mai 'inalt' din ierarhie si prin regulile de
compatibilitate dintre clase in acei pointeri se pot 'agata' orice
fel de obiecte din ierarhie. Sa se implementeze aceasta tehnica pentru ierarhia
anterioara folosind un tablou (sau matrice) de pointeri;
4. Se vor oferi functii pentru citirea datelor caracteristice obiectelor si
introducerea lor in 'lista', pentru parcurgerea listei si
'raportarea' specifica a prezentei in lista pentru fiecare obiect in
parte.
|
Politica de confidentialitate | Termeni si conditii de utilizare |
Vizualizari: 1480
Importanta: 
Termeni si conditii de utilizare | Contact
© SCRIGROUP 2024 . All rights reserved
