Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra ISA

RAPORT
Lucrarea de laborator nr.3
la Programarea Orientată pe Obiecte

A efectuat:
st. gr. AI-161 S. Chiu

A verificat:
Lector univ. M. Oșovschi

Chişinău 2017
 Lucrarea de laborator nr.3

Tema: Supraîncărcarea operatorilor

Scopul lucrării: familiarizarea studenților cu noțiunile operatori supraîncărcați.

Condiţia problemei (sarcina de lucru):

Varianta 2:
Să se scrie un program pentru implementarea unei clase Matrix, utilizând
memoria dinamică.
Să se definească operatorii (ca metode ale clasei):
 “+” – adunarea element cu element a matricilor;
 “-” – scăderea element cu element a matricilor;
 “=” – atribuirea matricilor;
 “[]” – indexarea elementelor matricei 2D ca elemente ale matricei 1D.
Să se definească operatorii de comparare (ca metode prietene ale clasei):
 “==” – echivalența matricilor element cu element
 “!=” – neechivalența matricilor
 “<” – norma elementelor matricei
 “>” – norma elementelor matricei
Class Matrix cu membrii:
- Table (pointer la pointer de tip întreg)
- n (numărul de linii)
- m (numărul de coloane)

Codul (textul) programului în limbajul C:

#include <iostream>
#include <stdlib.h>

using namespace std;

typedef unsigned int us;
class Matrix
{
public:
int **table;
us n;
us m;
public:
Matrix(){table = NULL; n=0; m=0;}
Matrix(us n, us m)
{
table = new int*[n];
for (us i=0; i<n; i++)
{
for (us j=0; j<m; j++)
2
 {
table[i] = new int[m];
}
}
this->n = n;
this->m = m;
}
void init_mem2D()
{
cout<<"\nDati elementele matricei 2D:\n";
for (us i=0; i<n; i++)
{
for (us j=0; j<m; j++)
{
cin>>table[i][j];
}
}
}
void show_Matrix()
{
cout<<"\nn-linii = "<<n;
cout<<"\nm-coloane = "<<m<<endl;
for (us i=0; i<n; i++)
{
for (us j=0; j<m; j++)
{
cout<<table[i][j]<<"\t";
}
cout<<endl;
}
}
Matrix operator+(Matrix op2)
{
Matrix tmp(n, m);
for (int i=0; i<n; i++)
for (int j=0; j<m; j++)
{
tmp.table[i][j] = table[i][j]+op2.table[i][j];
}
return tmp;
}
Matrix operator-(Matrix op2)
{
Matrix tmp(n, m);
for (int i=0; i<n; i++)
3
 for (int j=0; j<m; j++)
{
tmp.table[i][j] = table[i][j]-op2.table[i][j];
}
return tmp;
}
Matrix &operator=(Matrix op2)
{
if ((n != op2.n)||(m != op2.m))
{
cout<<"Introdu matricile de dimensiuni egale!!"<<endl;
}
else
{
for (int i=0; i<n; i++)
{
for (int j=0; j<m; j++)
{
table[i][j] = op2.table[i][j];
}
}
}
return *this;
}
int operator[](int k)
{
for (int i=0; i<n; i++)
for (int j=0; j<m; j++)
{
if (k==i*m+j)
return table[i][j];
}
}
friend us operator==(Matrix op1, Matrix op2);
friend us operator!=(Matrix op1, Matrix op2);
friend us operator<(Matrix op1, Matrix op2);
friend us operator>(Matrix op1, Matrix op2);
};//end class Matrix

us operator==(Matrix op1, Matrix op2)

{
for (int i=0; i<op1.n; i++)
for (int j=0; j<op1.m; j++)
{
if (op1.table[i][j] != op2.table[i][j])
4
 return 0;
}
return 1;
}
us operator!=(Matrix op1, Matrix op2)
{
for (int i=0; i<op1.n; i++)
for (int j=0; j<op1.m; j++)
{
if (op1.table[i][j] == op2.table[i][j])
return 0;
}
return 1;
}
us operator<(Matrix op1, Matrix op2)
{
int s1=0, s2=0;
for (int i=0; i<op1.n; i++)
for (int j=0; j<op1.m; j++)
{
s1+=op1.table[i][j];
s2+=op2.table[i][j];
}
if (s1<s2)
return 1;
else return 0;
}
us operator>(Matrix op1, Matrix op2)
{
int s1=0, s2=0;
for (int i=0; i<op1.n; i++)
for (int j=0; j<op1.m; j++)
{
s1+=op1.table[i][j];
s2+=op2.table[i][j];
}
if (s1>s2)
return 1;
else return 0;
}

int main()
{
us n1=0, m1=0;
us n2=0, m2=0;
5
 us n3=0, m3=0;
us rs=0;
int k=0;
cout<<"Dati 2 matrici 2D:"<<endl;
cout<<"Dati n1-linii si m1-coloane:"<<endl;
cin>>n1;
cin>>m1;
Matrix ob1(n1,m1);
ob1.init_mem2D();
ob1.show_Matrix();
cout<<"Introdu nr. de ordine al elementului de cautat in matricea
1>>"<<endl;
cin>>k;
cout<<ob1[k]<<endl;
cout<<"\nDati n2-linii si m2-coloane:"<<endl;
cin>>n2;
cin>>m2;
Matrix ob2(n2,m2);
ob2.init_mem2D();
ob2.show_Matrix();
cout<<"\nDati n3-linii si m3-coloane pentru matricea 3 ce va fi egala cu
matricea 1>>:"<<endl;
cin>>n3;
cin>>m3;
Matrix ob3(n3,m3);
ob3=ob1;
ob3.show_Matrix();
Matrix ob4(n1,m1);
cout<<"Suma a 2 matrici=> matricea 4=1+2"<<endl;
ob4 = ob1+ob2;
ob4.show_Matrix();
cout<<"1<2?"<<endl;
rs = ob1<ob2;
cout<<"Rs:(1=da/0=nu) "<<rs<<endl;
rs = 0;
cout<<"3>4?"<<endl;
rs = ob3>ob4;
cout<<"Rs:(1=da/0=nu) "<<rs<<endl;
system("PAUSE");
}

6
Rezultatele obținute:

Figura 1 – Screenshot-ul rezultatelor

7
Concluzii:
În lucrarea dată de laborator ne-am familiarizat cu noțiunea de supraîncărcare
a operatorilor pentru o clasă. Ca sarcină am avut de supradefinit operatorii: “+”,
“-”,“=” , “[]”, “==”, “!=”, “>”, “<” pentru operarea cu clasa matrice. Astfel, primii
4 operatori au fost incluși ca metode ale clase iar ceilalți (de comparare) au fost
declarate ca metode prietene ale clasei Matrix (matrice 2D). La supraîncărcarea
operatorului de indexare nu s-a prevăzut prevenirea cazului când introducem
indicele elementelului matricei ce nu se include în limitele acesteia, însă s-a utilizat
logica de reprezentare a tabloului 2D ca un vector 1D cu formula de calcul
k=i*m+j, ceea ce ne-a permis înlocuirea operatorului de indexare pentru matrici
2D ([n-linii][m-coloane]) cu operatorul de indexare pentru matrici vector ([indicele
elementului din vector]).
În cadrul funcției main() am realizat o serie de exemplificări ai fiecărui
operator supraîncărcat pentru a dovedi că programul a fost gîndit corect și că am
înțeles cu success această temă pentru lucrarea de laborator.