Universitatea Tehnic a Moldovei

FCIM
Catedra Calculatoare

RAPORT
la lucrarea de laborator nr. 4
la programarea in limbajul C++

Tema: Motenirea i Compoziia

Varianta 13

A efectuat:

st. gr. C-151 Enachi Nicolae

A verificat:

Lector superior Constantin Plotnic

Chiinu 2016
Scopul lucrrii:
studierea motenirii, avantajele i dezavantajele;
studierea compoziiei;
studierea regulilor de definire a motenirii i compoziiei;
studierea formelor de motenire;
studierea iniializatorilor;
principiul de substituie;
motenirea i compoziia ce s alegem.

Sarcina:
) De creat o ierarhie a claselor joc joc sportiv volei. Determinai constructorii, destructorii,
operatorii de atribuire i alte funcii obligatorii.
b) De creat clasa roata, care conine raz. Determinai constructorii i metodele de acces. Creai
clasa automobil, care conine roi i un cmp care reprezint firma productoare. Creai o clas derivat
autocamion care se deosebete prin tonaj. Determinai constructorii, destructorii i alte funcii necesare.

Codul Programului:
a) Joc Joc sportiv Volei
#include
#include
#include
#include

"stdafx.h"
<iostream>
<conio.h>
<string>

using namespace std;

class Joc{
int nJ;
public:
Joc();
Joc(int nJ);
Joc(Joc& joc);
~Joc();
Joc& operator = (Joc& joc);
friend ostream& operator << (ostream& os, Joc& joc);
friend istream& operator >> (istream& is, Joc& joc);
};
class JocSportiv : public Joc{
string dnmr;
public:
JocSportiv();
JocSportiv(const string& dnmr);
JocSportiv(Joc& joc, const string& dnmr);
JocSportiv(JocSportiv& jocSportiv);
~JocSportiv();
JocSportiv& operator = (JocSportiv& jocSportiv);
friend ostream& operator << (ostream& os, JocSportiv& jocSportiv);
friend istream& operator >> (istream& is, JocSportiv& jocSportiv);
};
1

class Volei : public JocSportiv{

int lt, lg;
public:
Volei();
Volei(int lt, int lg);
Volei(JocSportiv& jocSportiv, int lt, int lg);
Volei(Volei& volei);
~Volei();
Volei& operator = (Volei& volei);
friend ostream& operator << (ostream& os, Volei& volei);
friend istream& operator >> (istream& is, Volei& volei);
};
Joc::Joc(){}
Joc::Joc(int nJ) : nJ(nJ){}
Joc::Joc(Joc& joc) : nJ(joc.nJ){}
Joc::~Joc(){
nJ = 0;
}
ostream& operator << (ostream& os, Joc& joc) {
os << "\n\n Numarul de jucatori: " << joc.nJ;
return os;
}
istream& operator >> (istream& is, Joc& joc) {
cout << "\n Introduceti numarul de jucatori: ";
is >> joc.nJ;
return is;
}
Joc& Joc::operator = (Joc& joc){
if (this == &joc)
return (*this);
nJ = joc.nJ;
return (*this);
}
JocSportiv::JocSportiv(){}
JocSportiv::JocSportiv(const string& dnmr) : dnmr(dnmr){}
JocSportiv::JocSportiv(Joc& joc, const string& dnmr)
: Joc(joc), dnmr(dnmr){}
JocSportiv::JocSportiv(JocSportiv& jocSportiv) : Joc(jocSportiv),
dnmr(jocSportiv.dnmr){}
JocSportiv::~JocSportiv(){}
ostream& operator << (ostream& os, JocSportiv& jocSportiv) {
os << dynamic_cast<Joc&>(jocSportiv);
os << "\n Denumirea Echipei: " << jocSportiv.dnmr;
return os;
}
istream& operator >> (istream& is, JocSportiv& jocSportiv) {
is >> dynamic_cast<Joc&>(jocSportiv);
cout << " Denumirea Echipei: ";
2

is >> jocSportiv.dnmr;
return is;
}
JocSportiv& JocSportiv::operator = (JocSportiv& jocSportiv){
if (this == &jocSportiv)
return *this;
dynamic_cast<Joc&>((*this)) = dynamic_cast<Joc&>(jocSportiv);
dnmr = jocSportiv.dnmr;
return *this;
}
Volei::Volei() {}
Volei::Volei(int lt, int lge) : lt(lt), lg(lg){}
Volei::Volei(JocSportiv& jocSportiv, int lt, int lg): JocSportiv(jocSportiv), lt(lt), lg(lg)
{}
Volei::Volei(Volei& volei) : JocSportiv(volei),lt(volei.lt), lg(volei.lg){}
Volei::~Volei(){
lt = 0;
lg = 0;
}
ostream& operator << (ostream& os, Volei& volei) {
os << dynamic_cast<JocSportiv&>(volei);
os << "\n Latimea terenului: " << volei.lt;
os << "\n Lungimea terenului: " << volei.lg;
return os;
}
istream& operator >> (istream& is, Volei& volei) {
is >> dynamic_cast<JocSportiv&>(volei);
cout << " Introduceti latimea terenului: ";
is >> volei.lt;
cout << " Introduceti lungimea terenului: ";
is >> volei.lg;
return is;
}
Volei& Volei::operator = (Volei& volei){
if (this == &volei)
return (*this);
dynamic_cast<JocSportiv&>((*this)) = dynamic_cast<JocSportiv&>(volei);
lt = volei.lt;
lg = volei.lg;
return (*this);
}
int main(){
Joc j(6);
JocSportiv js(j, "Echipa1");
Volei vl1(js, 6, 18);
Volei vl2(vl1);
Volei vl3;
Volei vl4;
3

vl3 = vl2;
cin >> vl4;
cout << "\n\n
cout << vl1;
cout << " \n\n
cout << vl2;
cout << " \n\n
cout << vl3;
cout << " \n\n
cout << vl4;
_getch();
return 0;

->Constructor cu parametri";
->Constructor de copiere";
->vl3=vl2";
->Supraincarcarea operatorului de intrare";

Rezultatele Testrii:

b) Roata-Automobil-Autocamion
#include
#include
#include
#include

"stdafx.h"
<iostream>
<string>
<conio.h>

using namespace std;

class Roata{
public:
float rz;
Roata();
Roata(float raza);
~Roata();
void setRz(float raza) {
rz = raza;
}
float getRz() {
return rz;
}
};
class Automobil{
Roata rt;
string pr;
public:
Automobil();
Automobil(Roata& rt, const string& pr);
~Automobil();
friend ostream& operator << (ostream& cout, Automobil& automobil);
friend istream& operator >> (istream& cin, Automobil& automobil);
};
class Autocamion : public Automobil{
double tn;
public:
Autocamion();
Autocamion(double tn);
Autocamion(Automobil& automobil, double tn);
~Autocamion();
friend istream& operator >> (istream& cin, Autocamion& autocamion);
friend ostream& operator << (ostream& cout, Autocamion& autocamion);
};
Roata::Roata(){}
Roata::Roata(float raza) : rz(raza){
}
Roata::~Roata(){
rz = 0;
}
5

Automobil::Automobil(){}
Automobil::Automobil(Roata& rt, const string& pr) : rt(rt), pr(pr){}
Automobil::~Automobil(){
rt.~Roata();
}
ostream& operator << (ostream& os, Automobil& automobil){
os << "\n\n Firma Producatoare: " << automobil.pr;
os << "\n Raza rotilor: " << automobil.rt.getRz();
return os;
}
istream& operator >> (istream& is,
Automobil& automobil){
cout << "\n Introduceti firma producatoare: ";
is >> automobil.pr;
float raza;
cout << " Introduceti raza rotilor: ";
is >> raza;
automobil.rt.setRz(raza);
return is;
}
Autocamion::Autocamion() : tn(0){}
Autocamion::Autocamion(double tn) : tn(tn){}
Autocamion::Autocamion(Automobil& automobil, double tn) :
Automobil(automobil), tn(tn){}
Autocamion::~Autocamion(){
tn = 0;
}
istream& operator >> (istream& is, Autocamion& autocamion){
is >> dynamic_cast< Automobil& >(autocamion);
cout << " Introduceti tonajul: ";
is >> autocamion.tn;
return is;
}
ostream& operator << (ostream& os, Autocamion& autocamion){
os << dynamic_cast< Automobil& >(autocamion);
os << "\n Tonajul: " << autocamion.tn;
return os;
}
int main(){
Roata r(22.5);
Automobil a(r, "Scania");
Autocamion ac(a, 6.95);
Autocamion ac1;
cin >> ac1;
cout << ac << endl;
cout << ac1 << endl;
_getch();
return 0;
}

Rezultatele Testrii:

Concluzie:
Prin intermediul lucrrii respective de laborator am studiat dou componente
foarte importante din cadrul limbajului de programare C++ i anume mo tenire i
compoziia. Pentru aceasta am creat o ierarhie de clase i am folosit constructori att n
clasele de baz ct i n clasele derivate penru a observa diferena fa de sintaxa de declarare
a constructorilor dintr-o clas simpl. n final putem spune c motenirea i compozi ia sunt
instrumente foarte puternice n cadrul C++ prin intermediul crora se poate crea un cod mai
structurat i mai abstract.