MINISTERUL EDUCAŢIEI, CULTURII ȘI CERCETĂRII AL

REPUBLICII MOLDOVA
UNIVERSITATEA TEHNICĂ A MOLDOVEI
FACULTATEA CALCULATOARE, INFORMATICĂ ŞI
MICROELECTRONICĂ
DEPARTAMENTUL INFORMATICĂ ȘI INGINERIA
SISTEMELOR

RAPORT
pentru lucrarea de laborator nr.4
la disciplina: Programare Orientată pe Obiecte
cu tema: Moștenirea și Compoziția

A elaborat: A verificat:
st. gr. IA-171, Lector superior,
Bodorin Adrian Plotnic Constantin

CHIŞINĂU 2018
 Scopul lucrării:

 studierea moştenirii, avantajele şi dezavantajele;

 studierea compoziţiei;
 studierea regulilor de definire a moştenirii şi compoziţiei;
 studierea formelor de moştenire;
 studierea iniţializatorilor;
 principiul de substituţie;
 moştenirea şi compoziţia – ce să alegem.

Varianta:5
а) De creat clasa lichid, care conţine informaţie despre denumire (pointer la cîmp), densitate.
Determinaţi constructorii, destructorii, operatorii fluxului de intrare. Creaţi a clasă derivată –
băuturi alcoolice, care conţin tărie. Determinaţi funcţiile predestinate densităţii şi tăriei.
b) De creat clasa buton, care conţine un text anumit. Determinaţi constructorii şi metodele de
acces. Creaţi clasa fereastra, care conţine un buton şi coordonatele ferestrei. Definiţi
constructorii şi destructorii. Definiţi clasa derivată fereastra cu buton şi cu un mesaj. Definiţi
constructorii, destructorii şi operatorii fluxului de ieşire.

Codul – sursă:
#include<iostream>

#include<cstring>

#include<cstdlib>

using namespace std;

class lichid{

protected:

char *name; //Numele

float g;//Densitate

public:

lichid (){/*Constructor pentru initializarea datelor*/

name = new char[20];

 g = 0;

lichid(char *name,float g){/*Constructor cu parametri pentru

initializarea datelor*/

strcpy(this->name,name);

this->g = g;

void in(){/*Functie de introducere a datelor*/

cout<<"\t >Introdu numele: ";

cin>>name;

cout<<"\t >Introdu densitatea: ";

cin>>g;

void out(){/*Functie de afisare a datelor*/

cout<<"\t* Nume: "<<name<<endl<<"\t* Densitatea: "<<g;

cout<<"\n\t*****************************************************"<<endl;

~lichid(){//Destructor

};

class alcool: public lichid{

protected:

float tarie;

public:

alcool(){

void in(){

cout<<"\t >Introdu cpacitate de tarie: ";

 cin>>tarie;

lichid ::in() ;

void out(){

cout<<"\n\t*****************************************************"<<endl;

cout<<"\t* Taria : "<<tarie<<endl;

lichid :: out();

};

class fereastra{

protected:

int X, Y;

char *mesaj;

public:

fereastra (){/*Constructor pentru initializarea datelor*/

X = 0;

Y = 0;

mesaj = new char[100];

fereastra(int x, int y,char *m){/*Constructor cu parametri pentru

initializarea datelor*/

this -> X = x;

this -> Y = y;

strcpy(this->mesaj,m);

void in(){/*Functie de introducere a datelor*/

cout<<"\t >Introdu coordonatele X: ";

cin>>X;
 cout<<"\t >Introdu coordonatele Y: ";

cin>>Y;

cout<<"\t >Introdu mesajul: ";

cin>>mesaj;

void out(){/*Functie de afisare a datelor*/

cout<<"\t* X = "<<X<<endl;

cout<<"\t* Y = "<<X<<endl;

cout<<"\t* Mesajul: "<<mesaj;

cout<<"\n\t*****************************************************"<<endl;

~fereastra(){//Destructor

};

class buton: public fereastra{

protected:

char *nume;

public:

buton(){

nume = new char [20];

void in(){

cout<<"\t >Introdu numele butonului: ";

cin>>nume;

fereastra ::in() ;

void out(){
cout<<"\n\t*****************************************************"<<endl;

cout<<"\t* Numele : "<<nume<<endl;

fereastra :: out();

};

int main(){

int n, f, t, m;

while (1){

t = 1;

system("cls");

cout <<"\t+------------------------+"<<endl;

cout <<"\t|\t Meniu \t |"<<endl;

cout <<"\t|\t |"<<endl;

cout <<"\t|\t1.Sarcina a\t |"<<endl;

cout <<"\t|\t2.Sarcina b\t |"<<endl;

cout <<"\t|\t0.Esire\t\t |"<<endl;

cout <<"\t+------------------------+"<<endl;

cout <<"\n\t Sarcina: ";

cin>>n;

switch (n){

case 1 : {

alcool *O;

cout<<"\n\t* Cite bauturi doriti sa introduceti?"<<endl<<"\t>

";

cin>>n;

O = new alcool[n];

for (int i = 0; i < n;i++){

cout <<
"\n\t*****************************************************"<<endl;

cout << "\t* Bautura "<<i + 1<<endl;

 O[i].in();

cout <<
"\n\t*****************************************************"<<endl;

for (int i = 0; i < n;i++){

O[i].out();

cout<<"\n\t* Tasteaza '1' pentru a continua sau '0' pentru

iesire : "; cin>>f;

if (f)

break;

else

return EXIT_SUCCESS;

case 2 :{

buton *O;

cout<<"\n\t* Cite butoane doriti sa introduceti?"<<endl<<"\t>

";

cin>>n;

O = new buton[n];

for (int i = 0; i < n;i++){

cout <<
"\n\t*****************************************************"<<endl;

cout << "\t* Butonul "<<i + 1<<endl;

O[i].in();

cout <<
"\n\t*****************************************************"<<endl;

for (int i = 0; i < n;i++){

O[i].out();

cout<<"\n\t* Tasteaza '1' pentru a continua sau '0' pentru

iesire : "; cin>>f;

if (f)
 break;

else

return EXIT_SUCCESS;

case 0 : {

return EXIT_SUCCESS;

default :{

cout<<"\n\t* Optiune introdusa incorect !"<<endl;

cout<<"\n\t* Tasteaza '1' pentru a continua sau '0' pentru

iesire : "; cin>>f;

if (f)

break;

else

return EXIT_SUCCESS;

}
Concluzie:
În urma efectuării acestei lucrări de laborator, am studiat
moștenirea, avantajele și dezavantajele ei, regulile de definire a
moștenirii și compoziției, formele de moștenire, inițializatorii și
principiul de substituție. Astfel, am observat că moștenirea are unele
avantaje, precum micşorarea cantităţii codului şi folosirea lui repetată,
micşorarea cantităţii erorilor şi a preţului de cost, o interfaţă unică şi
substituţia, dar și mărirea vitezei de prelucrare.
Pe parcursul realizării lucrării de laborator, am observat că dacă în
clasa de bază și în derivată doi membri (câmp de dată sau metodă) se
numesc la fel, atunci, dacă în clasa derivată se va dori să se facă referire
la membrii clasei de bază, se va folosi operatorul rezoluție precedat de
numele clasei derivate. Astfel, referirea va fi în modul implicit la
membrii clasei derivate.
În concluzie, moștenirea este acea proprietate a claselor prin care o
clasă nouă construită poate prelua datele și metodele unei clase mai
vechi.