Sunteți pe pagina 1din 12

Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

RAPORT
Lucrarea de laborator nr.3

A efectuat:
st. gr. MAI_211M Gorea Filip

Chişinău -2021
Tema: Moştenirea şi compoziţia.

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ştenire şi compoziţie

Abstractizarea – Este posibilitatea ca un program să separe unele aspecte ale


informației pe care o manipulează, adică posibilitatea de a se concentra asupra esențialului.
Fiecare obiect în sistem are rolul unui “actor” abstract, care poate executa acțiuni, își poate
modifica și comunica starea și poate comunica cu alte obiecte din sistem fără a dezvălui cum
au fost implementate acele facilitați. Procesele, funcțiile sau metodele pot fi de asemenea
abstracte, și în acest caz sunt necesare o varietate de tehnici pentru a extinde abstractizarea:
Încapsularea – numită și ascunderea de informații: Asigură faptul că obiectele nu pot
schimba starea internă a altor obiecte în mod direct (ci doar prin metode puse la dispoziție de
obiectul respectiv); doar metodele proprii ale obiectului pot accesa starea acestuia. Fiecare tip
de obiect expune o interfață pentru celelalte obiecte care specifică modul cum acele obiecte
pot interacționa cu el.
Polimorfismul – Este abilitatea de a procesa obiectele în mod diferit, în funcție de
tipul sau de clasa lor. Mai exact, este abilitatea de a redefini metode pentru clasele derivate.
De exemplu pentru o clasă Figura putem defini o metodă arie. Dacă Cerc, Dreptunghi, etc.
vor extinde clasa Figura, acestea pot redefini metoda arie.
Moștenirea – Organizează și facilitează polimorfismul și încapsularea, permițând
definirea și crearea unor clase specializate plecând de la clase (generale) deja definite -
acestea pot împărtăși (și extinde) comportamentul lor, fără a fi nevoie de a-l redefini. Aceasta
se face de obicei prin gruparea obiectelor în clase și prin definirea de clase ca extinderi ale
unor clase existente. Conceptul de moștenire permite construirea unor clase noi, care
păstrează caracteristicile și comportarea, deci datele și funcțiile membru, de la una sau mai
multe clase definite anterior, numite clase de bază, fiind posibilă redefinirea sau adăugarea
unor date și funcții noi. Se utilizează ideea: ”Anumite obiecte sunt similare, dar în același
timp diferite”. O clasă moștenitoare a uneia sau mai multor clase de bază se numește clasă
derivată. Esența moștenirii constă în posibilitatea refolosirii lucrurilor care funcționează.

Varianta 8
а) Să se creeze ierarhia de clase bloc de studiu - clasa de bază abstractă şi instituţie preşcolară,
instituţie şcolară medie şi instituţie de învăţămînt superior – clase derivate. Să se supraîncarce
fluxul de ieşire şi fluxul de intrare, să se definească constructorul de copiere, operatorul de
atribuire prin funcţiile corespunzătoare ale clasei de bază.
b) Să se creeze clasa motor, care are o firmă producătoare, tip şi putere. Determinaţi funcţiile de
setare, de schimbare a parametrilor motoarelor. Creaţi o ierarhie a claselor: corabie – clasa de
bază şi vapor pentru pasageri – derivată. Corabia are un motor, capacitate de încărcare, măsurător
de apă, denumire, portul unde este înscris. Pentru setarea cîmpurilor textuale, utilizaţi operatorul
new.
Codul programului a):
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string.h>
#include <bits/stdc++.h>
using namespace std;

/*Să se supraîncarce fluxul de ieşire şi fluxul de intrare, să se definească


constructorul de copiere, operatorul de atribuire prin funcţiile corespunzătoare ale
clasei de bază.*/

class blocStudiu { //bloc de studiu (FCIM)


protected:
char *BS;

public:
blocStudiu() {
this->BS = new char[100];
}

blocStudiu(const blocStudiu &BS) {


strcpy(this->BS, BS.BS);
}

friend istream &operator>>(istream &in, blocStudiu &bs) {


cout << "Introdu Bloc de Studiu ";
in >> bs.BS;
return (in);
}

friend ostream &operator<<(ostream &out, blocStudiu &bs) {


return out << "Bloc de Studiu: " << bs.BS << endl;
}
};

class institutiePrescolara : public blocStudiu{ //instituţie preşcolară (Gradinita)


public:
char *IP;

institutiePrescolara() {
this->IP = new char[100];
}

institutiePrescolara(const institutiePrescolara &IP) {


strcpy(this->IP, IP.IP);
}

friend istream &operator>>(istream &in, institutiePrescolara &ip) {


cout << "Introdu Institutie Prescolara: ";
in >> ip.IP;
return (in);
}

friend ostream &operator<<(ostream &out, institutiePrescolara &ip) {


return out << "Institutia Prescolara: " << ip.IP << endl;
}
};

class instScolMed : public institutiePrescolara { //instituţie şcolară medie (Liceu)


public:
char *ISM;

instScolMed() {
ISM = new char[100];
}

instScolMed(const instScolMed &ism) {


strcpy(this->ISM, ism.ISM);
}

friend istream &operator>>(istream &in, instScolMed &ism) {


cout << "Introdu Institutie Scolara Medie: ";
in >> ism.ISM;
return (in);
}

friend ostream &operator<<(ostream &out, instScolMed &ism) {


return out << "Institutie Scolara Medie: " << ism.ISM << endl;
}
};
class instinvSup : public blocStudiu { //instituţie de învăţămînt superior (Licenta,
Masterat) derivate
public:
char *IIS;

instinvSup() {
IIS = new char[100];
}

instinvSup(const instinvSup &iis) {


strcpy(this->IIS, iis.IIS);
}

friend istream &operator>>(istream &in, instinvSup &iis) {


cout << "Introdu Institutie de Invatamant Superior: ";
in >> iis.IIS;
return (in);
}

friend ostream &operator<<(ostream &out, instinvSup &iis) {


return out << "Institutie de Invatamant Superior: " << iis.IIS << endl;
}
};

int main() {
int n;
blocStudiu *bs1;
institutiePrescolara *ip1;
instScolMed *ism1;
instinvSup *iis1;

cout << "Cate Date Doriti Sa Introduceti: ";


cin >> n;
bs1 = new blocStudiu[n + 1];
ip1 = new institutiePrescolara[n + 1];
ism1 = new instScolMed[n + 1];
iis1 = new instinvSup[n + 1];

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


cout << "(" << i + 1 << ") Date" << endl;
cin >> bs1[i];
cin >> ip1[i];
cin >> ism1[i];
cin >> iis1[i];
}

cout << "Datele Introduse: " << endl;

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


cout << "(" << j + 1 << ") Date" << endl;
cout << bs1[j];
cout << ip1[j];
cout << ism1[j];
cout << iis1[j];
}

return 0;
}

Rezultatul programului:

Codul programului b):

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <string.h>
#include <new>

using namespace std;

/* Creaţi o ierarhie a claselor: corabie – clasa de bază şi vapor pentru pasageri –


derivată.
* Corabia are un motor, capacitate de încărcare, măsurător de apă, denumire, portul
unde este înscris.
* Pentru setarea cîmpurilor textuale, utilizaţi operatorul new.*/

class motor { // Să se creeze clasa motor


public:
char *firma; // care are o firmă producătoare
char *tip; // tip
float putere; // si putere

motor() {
firma = new char[100];
tip = new char[100];
putere = 0;
}
motor(const motor &m) {
strcpy(this->firma, m.firma);
strcpy(this->tip, m.tip);
this->putere = m.putere;
}

// Determinaţi funcţiile de setare


friend istream &operator>>(istream &in, motor &m) {
cout <<"*********** MOTOR ***********"<<endl;
cout << "Introdu Firma Producatoare: ";
in >> m.firma;
cout << "Introdu Tip de Motor: ";
in >> m.tip;
cout << "Introdu Puterea: ";
in >> m.putere;

return (in);
}

friend ostream &operator<<(ostream &out, motor &m) {


cout <<"*********** MOTOR ***********"<<endl;
return out << "Firma Producatoare: " << m.firma << endl << "Tip de Motor: "
<< m.tip << endl << "Puterea: "
<< m.putere << endl;
}

bool search(char *search) {


if (strcmp(firma, search) == 0) {
return true;
} else {
return false;
}
}

void schimbare() {
int ch;
cout << "Doriti Sa Schimbati Firma Productoare? 1)Da 2)Nu ";
cin >> ch;
if (ch == 1) {
this->firma = new char[100];
cout << "Introdu Firma Productoare Nou: ";
cin >> this->firma;
}

cout << "Doriti sa Schimbati Tip de Motor? 1)Da 2)Nu ";


cin >> ch;
if (ch == 1) {
this->tip = new char[100];
cout << "Introdu Tip de Motor Nou: ";
cin >> this->tip;
}

cout << "Doriti sa Schimbati Puterea? 1)Da 2)Nu ";


cin >> ch;
if (ch == 1) {
this->putere = 0;
cout << "Introdu Puterea Noua: ";
cin >> this->putere;
}
}
};

class corabie { // corabie – clasa de bază


protected:
int capacitate; // capacitate de încărcare,
char *masurator; // masurator de apa,
char *denumire; // denumire,
char *port; // portul unde este înscris.
public:
char *motoare; // Corabia are un motor,
};

class vapor : public corabie { // şi vapor pentru pasageri – derivată.


public:
vapor() {
motoare = new char[100];
capacitate = 0;
masurator = new char[100];
denumire = new char[100];
port = new char[100];
}

friend istream &operator>>(istream &in, vapor &v) {


cout <<"*********** VAPOR ***********"<<endl;

cout << "Cate Persoane Incape: ";


in >> v.capacitate;
cout << "Care Masurator de Apa are: ";
in >> v.masurator;
cout << "Denumirea a vaporului: ";
in >> v.denumire;
cout << "Portul unde este inscris: ";
in >> v.port;

return (in);
}

friend ostream &operator<<(ostream &out, vapor &v) {


cout <<"*********** VAPOR ***********"<<endl;
return out << "Motor: " << v.motoare << endl << "Capacitate: " <<
v.capacitate << endl << "Masurator de Apa: "
<< v.masurator << endl << "Denumirea a Vaporului: " << v.denumire
<< endl
<< "Portul unde este inscris: " << v.port << endl;
}
};

int main() {
motor *m;
vapor *v;
char *search = new char[101];
int n, ch, searc;

cout << "Cate Vapor Aveti: ";


cin >> n;
m = new motor[n + 1];
v = new vapor[n+1];

while (1) {
cout << "********** Pentru Motoarele **********" << endl << endl;
cout << "1) Introducerea." << endl;
cout << "2) Afisarea(MOTOR)." << endl;
cout << "3) Schimbarea(MOTOR)." << endl;
cout << "4) Afisarea(Vapor)." << endl << endl;
cout << "Alegeti o varianta: ";
cin >> ch;
cout << endl;

switch (ch) {
case 1: {
for (int i = 0; i < n; ++i) {
cin >> m[i];
v[i].motoare = m[i].tip;
cout << endl;
cin >> v[i];
cout << endl;
}
}
break;

case 2: {
for (int i = 0; i < n; ++i) {
cout << endl;
cout << m[i];
cout << endl;
}
}
break;

case 3: {
searc = 0;
cout << "Ce Doriti Sa Schimbati: ";
cin >> search;
for (int i = 0; i < n; ++i) {
if (m[i].search(search) == true) {
searc++;
}
}

if (searc > 2) {
cout << "Care " << search << ": " << endl;
for (int i = 0; i < n; ++i) {
if (m[i].search(search) == true) {
cout << i << ") ";
cout << m[i];
}
}
cin >> ch;
m[ch].schimbare();
} else if (searc == 1) {
for (int i = 0; i < n; ++i) {
if (m[i].search(search) == true) {
m[i].schimbare();
}
}
}
}
break;

case 4:{
for (int i = 0; i < n; ++i) {
cout << endl;
cout << v[i];
cout << endl;
}
}
break;
}
}

return 0;
}

Rezultatul programului:
Concluzii :
 In rezultatul elaborarii lucrarii date s-a pus baza aplicarii in practica a cunostintelor
teoretice referitoare la mostenire.
 Astfel se poate judeca despre posibilitatile largi acordate de limbajul C++ referitor
la manipularea claselor.