Ministerul Educaţiei şi Tineretului al Republicii Moldova

Universitatea Tehnică a Moldovei

RAPORT
Lucrare de laborator Nr.2

Gorea Filip MAI-211M:A efectuat

Chişinău 2021
Tema: Supraincarcarea operatorilor

Scopul lucrării:Familiarizarea studenţilor cu noţiunile operatori supraîncărcaţi

Noțiuni teoretice:
Supraîncărcarea operatorilor n Este procesul de atribuire a două sau mai multor operații
aceluiași operator. n Se poate realiza prin ¨Funcții membru ¨Funcții friend globale Clase si funcții
friend. Supraîncărcarea operatorilor 16 Supraîncărcarea operatorilor. Restricții n Prin
supraîncărcarea operatorilor nu se poate modifica: ¨ aritatea operatorilor (numărul operanzilor
asupra cărora se aplică). Astfel, operatori unari nu pot fi supraîncărcați ca operatori binari și invers
¨ asociativitatea ¨ prioritatea n Se pot supraîncărca numai operatori existenți n Nu pot fi
supraîncărcați operatori .* :: ?: sizeof.
Supraîncărcarea operatorilor cu funcții membru n Sintaxa class
IdClasa { tip_rez operator simbol_operator (lista_parametri) ; };
n Numărul de parametri este cu 1 mai mic decât aritatea operatorului. n Primul operand este
obiectul curent pentru care se apelează operatorul Tipul rezultatului obținut cuvânt cheie operatorul ce va fi
supraîncărcat lista de parametri (operanzi asupra carora acționează operatorul) Clase si funcții friend.
Supraîncărcarea operatorilor
Supraîncărcarea operatorilor cu funcții friend n Sintaxa
class IdClasa { friend tip_rez operator simbol_operator (lista_parametri) ; };
tip_rez operator simbol_operator (lista_parametri) { } n
Numărul de parametri este egal cu aritatea operatorului.

Varianta:4.Să se creeze clasa Bool – variabile logice. Să se definească operatorii "+" – SAU
logic, "*" – ŞI logic, "^" – SAU EXCLUSIV, ca metode ale clasei, iar operatorii "==" şi "!=" –
ca funcţii prietene. Operatorii trebuie să permită realizarea operaţiilor atît cu variabilele clasei
date, cît şi cu variabilele de tip predefinit int. (Dacă numărul întreg este diferit de zero, se
consideră că
(.variabila este adevăr, altfel – fals

:Listingul programului
<include <iostream #
;using namespace std

} class Bool
:public
;bool x
;bool y
;bool z
;bool w
:public
constructor fara parametri //
{} ()Bool
{}()Bool ~
constructor cu 4 parametri //
} (Bool(bool f1, bool f2,bool f3,bool f4
;x=f1
;y=f2

;z=f3
;w=f4
{

}()void Initiere
;cout<<"Boolul:"<<endl
;":cout<<"x
;cin>>x
;":cout<<"y
;cin>>y
;":cout<<"y
;cin>>z
;":cout<<"y
;cin>>w
{

}()void Afisare
;cout<< "\n x:"<<x
;cout<< "\n y:"<<y
;cout<< "\n z:"<<z
;cout<< "\n y:"<<w
{

;(friend bool operator ==(Bool &l1, Bool &l2

;(friend int operator !=(Bool &l1, Bool &l2

} (Bool operator+(Bool &l1

;Bool result
;result.x = this->x + l1.x
;result.y = this->y + l1.y

;result.z = this->z + l1.z

;result.w = this->w + l1.w
;return result
;{

} (Bool operator*(Bool & l1

;Bool result
;result.x = this->x * l1.x
;result.y = this->y * l1.y
;result.z = this->z * l1.z
;result.w = this->w * l1.w
;return result
;{
} (Bool operator^(Bool & l1
;Bool result
;result.x = this->x ^ l1.x
;result.y = this->y ^ l1.y
;result.z = this->z ^ l1.z
;result.w = this->w ^ l1.w
;return result
;{
;{

(bool operator == ( Bool &l1, Bool &l2

}
((if ((l1.x == l2.x) && (l1.y == l2.y) && (l1.z == l2.z) && (l1.w == l2.w
;return 1
;return 0
{

(int operator != ( Bool &l1, Bool &l2

}
((if ((l1.x != l2.x) && (l1.y != l2.y) && (l1.z != l2.z) && (l1.w != l2.w
;return 1
;return 0
{

} ()int main
;Bool l1
;(Bool l2(0,0,1,1

;()l1.Initiere
;"cout<<"\nColoana1
;()l1.Afisare
;"cout<<"\nColoana2
;()l2.Afisare
;"+ cout<<"\nSupra
;Bool v3=l1+l2
;()v3.Afisare
;"* cout<<"\nSupra
;Bool v4=l1*l2
;()v4.Afisare
;"^ cout<<"\nSupra
;Bool v5=l1^l2
;()v5.Afisare

{;if(l1==l2){cout<<"\nBoolii sunt egali"<<endl

{;if(l1!=l2) {cout<<"\nBoolii nu este egali"<<endl

;return 0

{
:Rezultat

Concluzii

In urma realizarii lucrarii date de laborator s-au studiat

mai si repetat mai multe tehnici si posibilitati de supraincarcare a
operatorilor acesta fiid un procedeu destul de intalnit in POO,
fiind deseori utilizat insa este necesara utilizarea rationala a
acestei tehnici intrucat riscam sa obtinem careva erori la nivel de
cod.