Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnica a Moldovei

Catedra ATI

Raport
LUCRARE DE LABORATOR NR. 3
LA DISCIPLINA „PROGRAMAREA ÎN LIMBAJUL C++”

Tema: Supraincarcarea operatorilor

A efectuat: st.
gr. TI-142 Chifa Vladislav

A verificat:
lector un.
Potlog Mihail

Chişinău 2015
 LUCRARE DE LABORATOR NR. 3

Tema: Supraîncărcarea operatorilor

Scopul lucrării:

 Studierea necesităţii supraîncărcării operatorilor;

 Studierea sintaxei de definire a operatorilor;
 Studierea tipurilor de operatori;
 Studierea formelor de supraîncărcare;
 Varianta 6
 а) Să se creeze clasa numerelor mari întregi. Să se definească
operatorii "+" şi "*" ca metode ale clasei, iar "-" şi "/" - ca funcţii
prietene. Să se supraîncarce operatorii de incrementare şi de
decrementare în ambele forme (prefixă şi postfixă). Operatorii trebuie
să permită realizarea operaţiilor atît cu variabilele clasei date, cît şi cu
variabilele de tip predefinit long.
 b) Să se creeze clasa Matrix – matrice, utilizînd memoria dinamică. Să
se definească operatorii "+" – adunarea matricilor, "-" – scăderea
matricilor, "=" – atribuirea ca metode ale clasei. Să se definească
operatorii de comparare: "==", "!=", "<", ">" ca funcţii prietene.
Pentru realizarea ultimilor doi operatori să se definească funcţia de
calcul a normei elementelor matricei. Să se definească operatorul "[]"
astfel încît să fie cu sens adresarea [][] la elemente. Să se supraîncarce
operatorii "<<" şi ">>" pentru ieşiri/intrări de obiecte.

Noţiuni de bază

Operatorii sunt notaţii concise, infixate, pentru operaţii matematice

uzuale. Limbajul C++, ca orice limbaj de programare asigură un set de
operatori pentru tipurile primitive. În plus, faţă de limbajul C, C++ oferă
posibilitatea asocierii operatorilor existenţi cu tipurile definite de
utilizator . Astfel, prezintă interes extinderea operatorilor în aritmetică
complexă, algebra matricială, în lucrul cu şiruri de caractere, etc. Un
operator poate fi privit ca o funcţie, în care termenii sunt argumentele
funcţiei (în lipsa operatorului +, expresia a+b s-ar calcula apelând funcţia
aduna(a,b)).

Limbajul C++ introduce următorii operatori noi: new şi delete-

pentru gestiunea memoriei dinamice, operatorul de rezoluţie (::) şi
operatorii de acces la membri: .* şi ->*.
 1. Supraîncărcare.

Prin supraîncărcarea unui operator, acesta este utilizat în contexte

diferite, avînd aceeaşi semnificaţie sau o semnificaţie diferită. Astfel
operatorul + este supraîncărcat pentru adunarea întregilor şi a realilor;
operatorul << este supraîncărcat cu semnificaţia de deplasare la stînga,
dacă termenii sunt întregi sau inserare în flux, dacă un termen este un
flux de date, iar celălalt un obiect.

Programatorul poate asocia noi semnificaţii operatorilor existenţi

prin supraîncărcarea operatorilor. Vom evita folosirea termenului
redefinire, căruia îi vom da o semnificaţie diferită, în contextul moştenirii.

Anumiţi operatori pot fi utilizaţi cu orice tip de termeni (sunt deja

supraîncărcaţi global de către compilator). Aceştia sunt: new, delete,
sizeof, ::, =, &, ->*, .*, ., ->.

Pot fi supraîncărcaţi următorii operatori:

+ - * / % ^ & |~ ! = < >

+= -= *= /= %= ^= &= |= >>= <<= == != <= >=

&& || ++ -- ->* , -> << >> [] ()

new new[] delete delete[]

Nu pot fi supraîncărcaţi operatorii: ::, ., .*, ?:, sizeof.

Setul de operatori ai limbajul C++ nu poate fi extins prin asocierea

de semnificaţii noi unor caractere, care nu sunt operatori de exemplu nu
putem defini operatorul **).

Prin supraîncărcarea unui operator nu i se poate modifica aritatea

(astfel operatorul ! este unar şi poate fi redefinit numai ca operator unar.
De asemeni asociativitatea şi precedenţa operatorului se menţin.

La supraîncărcarea unui operator nu se pot specifica argumente cu

valori implicite.

Operatorii supraîncărcaţi într-o clasă sunt moşteniţi în clasele

derivate (excepţie face operatorul de atribuire =).

Semnătura unei funcţii în care se supraîncarcă un operator este:

tip_rezultat operator#(listă_argumente);

Listingul programului:
a)
#include <iostream> intreg::intreg(int a){
#include <math.h> this->a=a;
#include <conio.h> }
#include <stdlib.h> intreg::intreg(int b,int c):b(b),c(c)
{}
using namespace std; intreg::intreg(const
intreg&obj):a(obj.a),b(obj.b),c(obj.
class intreg{ c){}
// int a;
public: void intreg::afisare(){
int a; cout<<a<<""<<endl;
int b,c; }
intreg():a(0),b(0),c(0){ };
intreg(int ); intreg::~intreg(){}
intreg(int,int);
intreg(const intreg&); intreg&intreg::operator + (int b)
~intreg(); {
void afisare(); a+=b;
intreg&operator +(int); return *this;
intreg&operator *(int); }
intreg&operator ++(); intreg&intreg::operator*(int b){
intreg&operator ++(int); a*=b;
intreg&operator --(); return *this;
intreg&operator --(int); }
friend intreg operator -(const
intreg&,intreg&); intreg&intreg::operator ++(){
friend intreg operator /(const ++a;
intreg&,intreg&); return *this;

}; }
intreg&intreg::operator --(){
--a;
 return *this; cout<<"Obiectul a:"; a.afisare();
cout<<"Obiectul w:"; w.afisare();
} cout<<"Obiectul q:"; q.afisare();
cout<<"Dati scalarul:";cin>>sc;
intreg&intreg::operator ++(int cout<<"Supraincacarea op + :";
fals){ a+(sc);
intreg cop(*this); a.afisare();
this->a+=1; cout<<"Supraincarcarea op *:";
return cop; b*(sc);
b.afisare();
} cout<<"Supraincarcarea ++
prefixat:";
intreg&intreg::operator --(int fals) ++c;
{ c.afisare();
intreg cop(*this); cout<<"Supraincarcarea --
this->a-=1; prefixat:";
return cop; --d;
d.afisare();
} cout<<"Supraincarcarea ++
intreg operator /(intreg &x,intreg postfixata:";
&y){ e++;
intreg p(x); e.afisare();
p.a=p.a/y.a; cout<<"Supraincarcarea --
return p; postfixata:";
} f--;
intreg operator -(intreg &x,intreg f.afisare();
&y){ cout<<"Supraincarcarea
intreg p(x); operatorului friend /:"<<endl;
p.a=p.a-y.a; cout<<"Obiectul w/q=:";
return p; intreg rs;
} rs=w/q;
rs.afisare();
int main() cout<<"Supraincarcare
{ operatorului friend -:"<<endl;
int sc; intreg rz;
intreg a(2); rz=w-q;
intreg b=a,c=a,d=a; rz.afisare();
intreg e=a,f=a; return 0;
intreg w(8),q(2); }
 b)

#include <iostream> Matrix & operator =(Matrix&);

#include <math.h> friend istream &operator
#include <conio.h> >>(istream &, Matrix &);
#include <stdlib.h> friend ostream &operator
<<(ostream &,Matrix &);
using namespace std; friend bool operator
==(Matrix&,Matrix &);
class Matrix{ friend bool operator <(Matrix
int **mat; &,Matrix&);
int line; friend bool operator
int col; >(Matrix&,Matrix&);
public: friend bool operator !
Matrix(); =(Matrix&,Matrix&);
Matrix(int,int); };
Matrix(const Matrix&);
~Matrix();
void set_matrix();
void print_matrix(); Matrix::Matrix():line(0),col(0),mat(
Matrix&operator +(Matrix &); 0){}
Matrix& operator -(Matrix&);
 Matrix::Matrix(int l,int c){ }
line=l; }
col=c;
mat=new int *[line];
for (int i = 0; i < line; ++i) ostream&operator <<(ostream&
{ out,Matrix &obj){
mat[i]=new int[col]; if(!obj.mat)return out<<"Nu este
} alocat !!";
} for (int i = 0; i < obj.line; ++i)
{
Matrix::~Matrix(){ for (int j = 0; j <obj.col; ++j)
if(mat){ {
for (int i = 0; i < line; ++i) out<<obj.mat[i][j]<<" ";
delete mat[i]; }
delete mat; out<<endl;
line=0; }
col=0; return out;
mat=NULL;
} }
}
istream& operator >>(istream&
Matrix::Matrix(const Matrix & in,Matrix & obj){
obj){ for (int i = 0; i <obj.line; ++i)
line=obj.line; {
col=obj.col; for (int j = 0; j < obj.col; ++j)
mat=new int *[obj.line]; {
for (int i = 0; i < obj.line; ++i) cout<<"mat["<<i<<"]
{ ["<<j<<"]:";
mat[i]=new int[obj.col]; in>>obj.mat[i][j];
} }
}
} return in;
}
void Matrix::set_matrix(){

for (int i = 0; i < line; ++i)

{ Matrix&Matrix::operator +
for (int j = 0; j < col; ++j) (Matrix &t){
{ this->line=t.line;
cout<<"mat["<<i<<"] this->col=t.col;
["<<j<<"]:"; for(int i=0;i<line;++i){
cin>>mat[i][j]; for(int j=0;j<col;++j){
}
 this->mat[i][j] return false;
+=t.mat[i][j]; }
} }
} bool operator <(Matrix
return *this; &obj1,Matrix &obj2){
} for (int i = 0; i <
Matrix&Matrix::operator -(Matrix obj1.line&&obj2.line; ++i)
&t){ {
this->line=line; for (int j = 0; j <
this->col=col; obj1.col&&obj2.col; ++j)
for(int i=0;i<line;++i){ if(obj1.mat[i][j]<obj2.mat[i]
for(int j=0;j<col;++j){ [j])
this->mat[i][j]-=t.mat[i] return true;
[j]; return false;
} }
}return *this; }
} bool operator >(Matrix
&obj1,Matrix &obj2){
for (int i = 0; i <
Matrix&Matrix::operator obj1.line&&obj2.line; ++i)
=(Matrix &obj){ {
{ if(this==&obj) return *this; for (int j = 0; j <
this->line=obj.line; obj1.col&&obj2.col; ++j)
this->col=obj.col; if(obj1.mat[i][j]>obj2.mat[i]
for (int i = 0; i < line; ++i) [j])
{ return true;
for (int j = 0; j < col; ++j) return false;
mat[i][j]=obj.mat[i][j]; }
} }
return *this;
} bool operator !=(Matrix
} &obj1,Matrix &obj2){
for (int i = 0; i <
bool operator ==(Matrix obj1.line&&obj2.line; ++i)
&obj1,Matrix &obj2){ {
for (int i = 0; i < for (int j = 0; j <
obj1.line&&obj2.line; ++i) obj1.col&&obj2.col; ++j)
{ if(obj1.mat[i][j]!
for (int j = 0; j < =obj2.mat[i][j])
obj1.col&&obj2.col; ++j) return true;
if(obj1.mat[i] return false;
[j]==obj2.mat[i][j]) }
return true; }
 test1 = a >(a,b);
cout<<"Matricea 1 este mai
int main() mare de cit Matricea
{ 2:"<<test1<<endl;
bool test2;
int x,y,z; test2 = a<(a,b);
Matrix r1,r2; cout<<"Maticea 1 este mai
cout<<"Get x,y:"; mica de cit Matricea
cin>>x>>y; 2:"<<test2<<endl;
Matrix a(x,y); bool test3;
Matrix b(a); test3= a!=(a,b);
cout<<"Introduceti obiectul cout<<"Matricile sunt
a"<<endl; difeite:"<<test3<<endl;
cin>>(cin,a); cout<<"Suma:"<<endl;
cout<<(cout,a); a+(b);
cout<<endl<<"Iintroduceti cout<<(cout,a);
obectul b"<<endl; cout<<"Diferenta:"<<endl;
cin>>(cin,b); a-(b);
cout<<(cout,b); cout<<(cout,a);
bool test; cout<<"Atribuirea
test = a == (a,b); a=b:"<<endl;
cout<<"Verificarea daca a=(b);
matricile sunt egale:"<<test; cout<<(cout,a);
cout<<endl;
bool test1;
}
Concluzie: Efectuind aceasta lucrare de laborator am capatat deprinderi
de a lucre cu supraincarcarea operatorilor . Avantajul utilizării operatorilor
(reducerea codului) în acelaşi timp complică înţelegerea codului, deoarece
nu este posibil întotdeauna sau este complicat să se urmărească dacă se
utilizează un operator predefinit sau supraîncărcat. Însă supraîncărcarea
operatorilor este necesară. Sunt probleme care se soluţionează numai prin
supraîncărcarea operatorilor,cum ar fi operatorul de atribuire si etc.