Sunteți pe pagina 1din 11

Ministerul Educaiei 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:

gr. TI-142

st.
Chifa Vladislav
A verificat:

lector un.

Potlog Mihail

Chiinu 2015

LUCRARE DE LABORATOR NR.

Tema:

Suprancrcarea operatorilor

Scopul lucrrii:

Studierea
Studierea
Studierea
Studierea

) S se creeze clasa numerelor mari ntregi. S se defineasc


operatorii "+" i "*" ca metode ale clasei, iar "-" i "/" - ca funcii
prietene. S se suprancarce operatorii de incrementare i de
decrementare n ambele forme (prefix i postfix). Operatorii trebuie
s permit realizarea operaiilor att cu variabilele clasei date, ct i cu
variabilele de tip predefinit long.

b) S se creeze clasa Matrix matrice, utiliznd memoria dinamic. S


se defineasc operatorii "+" adunarea matricilor, "-" scderea
matricilor, "=" atribuirea ca metode ale clasei. S se defineasc
operatorii de comparare: "==", "!=", "<", ">" ca funcii prietene.
Pentru realizarea ultimilor doi operatori s se defineasc funcia de
calcul a normei elementelor matricei. S se defineasc operatorul "[]"
astfel nct s fie cu sens adresarea [][] la elemente. S se suprancarce
operatorii "<<" i ">>" pentru ieiri/intrri de obiecte.

necesitii suprancrcrii operatorilor;


sintaxei de definire a operatorilor;
tipurilor de operatori;
formelor de suprancrcare;
Varianta 6

Noiuni de baz
Operatorii sunt notaii concise, infixate, pentru operaii 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 existeni 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 funcie, n care termenii sunt argumentele
funciei (n lipsa operatorului +, expresia a+b s-ar calcula apelnd funcia
aduna(a,b)).
Limbajul C++ introduce urmtorii operatori noi: new i deletepentru gestiunea memoriei dinamice, operatorul de rezoluie (::) i
operatorii de acces la membri: .* i ->*.

1. Suprancrcare.
Prin suprancrcarea unui operator, acesta este utilizat n contexte
diferite, avnd aceeai semnificaie sau o semnificaie diferit. Astfel
operatorul + este suprancrcat pentru adunarea ntregilor i a realilor;
operatorul << este suprancrcat cu semnificaia de deplasare la stnga,
dac termenii sunt ntregi sau inserare n flux, dac un termen este un
flux de date, iar cellalt un obiect.
Programatorul poate asocia noi semnificaii operatorilor existeni
prin suprancrcarea operatorilor. Vom evita folosirea termenului
redefinire, cruia i vom da o semnificaie diferit, n contextul motenirii.
Anumii operatori pot fi utilizai cu orice tip de termeni (sunt deja
suprancrcai global de ctre compilator). Acetia sunt: new, delete,
sizeof, ::, =, &, ->*, .*, ., ->.
Pot fi suprancrcai urmtorii operatori:
+ - * / % ^ & |~ ! = < >
+= -= *= /= %= ^= &= |= >>= <<= == != <= >=
&& || ++ -- ->* , -> << >> [] ()
new new[] delete delete[]
Nu pot fi suprancrcai operatorii: ::, ., .*, ?:, sizeof.
Setul de operatori ai limbajul C++ nu poate fi extins prin asocierea
de semnificaii noi unor caractere, care nu sunt operatori de exemplu nu
putem defini operatorul **).
Prin suprancrcarea unui operator nu i se poate modifica aritatea
(astfel operatorul ! este unar i poate fi redefinit numai ca operator unar.
De asemeni asociativitatea i precedena operatorului se menin.
La suprancrcarea unui operator nu se pot specifica argumente cu
valori implicite.
Operatorii suprancrcai ntr-o clas sunt motenii n clasele
derivate (excepie face operatorul de atribuire =).
Semntura unei funcii n care se suprancarc un operator este:

tip_rezultat operator#(list_argumente);

Listingul programului:
a)
#include
#include
#include
#include

<iostream>
<math.h>
<conio.h>
<stdlib.h>

using namespace std;


class intreg{
// int a;
public:
int a;
int b,c;
intreg():a(0),b(0),c(0){ };
intreg(int );
intreg(int,int);
intreg(const intreg&);
~intreg();
void afisare();
intreg&operator +(int);
intreg&operator *(int);
intreg&operator ++();
intreg&operator ++(int);
intreg&operator --();
intreg&operator --(int);
friend intreg operator -(const
intreg&,intreg&);
friend intreg operator /(const
intreg&,intreg&);
};

intreg::intreg(int a){
this->a=a;
}
intreg::intreg(int b,int c):b(b),c(c)
{}
intreg::intreg(const
intreg&obj):a(obj.a),b(obj.b),c(obj.
c){}
void intreg::afisare(){
cout<<a<<""<<endl;
}
intreg::~intreg(){}
intreg&intreg::operator + (int b)
{
a+=b;
return *this;
}
intreg&intreg::operator*(int b){
a*=b;
return *this;
}
intreg&intreg::operator ++(){
++a;
return *this;
}
intreg&intreg::operator --(){
--a;

return *this;
}
intreg&intreg::operator
fals){
intreg cop(*this);
this->a+=1;
return cop;

++(int

}
intreg&intreg::operator --(int fals)
{
intreg cop(*this);
this->a-=1;
return cop;
}
intreg operator /(intreg &x,intreg
&y){
intreg p(x);
p.a=p.a/y.a;
return p;
}
intreg operator -(intreg &x,intreg
&y){
intreg p(x);
p.a=p.a-y.a;
return p;
}
int main()
{
int sc;
intreg a(2);
intreg b=a,c=a,d=a;
intreg e=a,f=a;
intreg w(8),q(2);

cout<<"Obiectul a:"; a.afisare();


cout<<"Obiectul w:"; w.afisare();
cout<<"Obiectul q:"; q.afisare();
cout<<"Dati scalarul:";cin>>sc;
cout<<"Supraincacarea op + :";
a+(sc);
a.afisare();
cout<<"Supraincarcarea op *:";
b*(sc);
b.afisare();
cout<<"Supraincarcarea ++
prefixat:";
++c;
c.afisare();
cout<<"Supraincarcarea -prefixat:";
--d;
d.afisare();
cout<<"Supraincarcarea ++
postfixata:";
e++;
e.afisare();
cout<<"Supraincarcarea -postfixata:";
f--;
f.afisare();
cout<<"Supraincarcarea
operatorului friend /:"<<endl;
cout<<"Obiectul w/q=:";
intreg rs;
rs=w/q;
rs.afisare();
cout<<"Supraincarcare
operatorului friend -:"<<endl;
intreg rz;
rz=w-q;
rz.afisare();
return 0;
}

b)
#include <iostream>
#include <math.h>
#include <conio.h>
#include <stdlib.h>
using namespace std;
class Matrix{
int **mat;
int line;
int col;
public:
Matrix();
Matrix(int,int);
Matrix(const Matrix&);
~Matrix();
void set_matrix();
void print_matrix();
Matrix&operator +(Matrix &);
Matrix& operator -(Matrix&);

Matrix & operator =(Matrix&);


friend istream &operator
>>(istream &, Matrix &);
friend ostream &operator
<<(ostream &,Matrix &);
friend bool operator
==(Matrix&,Matrix &);
friend bool operator <(Matrix
&,Matrix&);
friend bool operator
>(Matrix&,Matrix&);
friend bool operator !
=(Matrix&,Matrix&);
};

Matrix::Matrix():line(0),col(0),mat(
0){}

Matrix::Matrix(int l,int c){


line=l;
col=c;
mat=new int *[line];
for (int i = 0; i < line; ++i)
{
mat[i]=new int[col];
}
}
Matrix::~Matrix(){
if(mat){
for (int i = 0; i < line; ++i)
delete mat[i];
delete mat;
line=0;
col=0;
mat=NULL;
}
}
Matrix::Matrix(const Matrix &
obj){
line=obj.line;
col=obj.col;
mat=new int *[obj.line];
for (int i = 0; i < obj.line; ++i)
{
mat[i]=new int[obj.col];
}
}

}
}

ostream&operator <<(ostream&
out,Matrix &obj){
if(!obj.mat)return out<<"Nu este
alocat !!";
for (int i = 0; i < obj.line; ++i)
{
for (int j = 0; j <obj.col; ++j)
{
out<<obj.mat[i][j]<<" ";
}
out<<endl;
}
return out;
}
istream& operator >>(istream&
in,Matrix & obj){
for (int i = 0; i <obj.line; ++i)
{
for (int j = 0; j < obj.col; ++j)
{
cout<<"mat["<<i<<"]
["<<j<<"]:";
in>>obj.mat[i][j];
}
}
return in;
}

void Matrix::set_matrix(){
for (int i = 0; i < line; ++i)
{
for (int j = 0; j < col; ++j)
{
cout<<"mat["<<i<<"]
["<<j<<"]:";
cin>>mat[i][j];
}

Matrix&Matrix::operator +
(Matrix &t){
this->line=t.line;
this->col=t.col;
for(int i=0;i<line;++i){
for(int j=0;j<col;++j){

this->mat[i][j]
+=t.mat[i][j];
}
}
return *this;
}
Matrix&Matrix::operator -(Matrix
&t){
this->line=line;
this->col=col;
for(int i=0;i<line;++i){
for(int j=0;j<col;++j){
this->mat[i][j]-=t.mat[i]
[j];
}
}return *this;
}

Matrix&Matrix::operator
=(Matrix &obj){
{ if(this==&obj) return *this;
this->line=obj.line;
this->col=obj.col;
for (int i = 0; i < line; ++i)
{
for (int j = 0; j < col; ++j)
mat[i][j]=obj.mat[i][j];
}
return *this;
}
}
bool operator ==(Matrix
&obj1,Matrix &obj2){
for (int i = 0; i <
obj1.line&&obj2.line; ++i)
{
for (int j = 0; j <
obj1.col&&obj2.col; ++j)
if(obj1.mat[i]
[j]==obj2.mat[i][j])
return true;

return false;
}
}
bool operator <(Matrix
&obj1,Matrix &obj2){
for (int i = 0; i <
obj1.line&&obj2.line; ++i)
{
for (int j = 0; j <
obj1.col&&obj2.col; ++j)
if(obj1.mat[i][j]<obj2.mat[i]
[j])
return true;
return false;
}
}
bool operator >(Matrix
&obj1,Matrix &obj2){
for (int i = 0; i <
obj1.line&&obj2.line; ++i)
{
for (int j = 0; j <
obj1.col&&obj2.col; ++j)
if(obj1.mat[i][j]>obj2.mat[i]
[j])
return true;
return false;
}
}
bool operator !=(Matrix
&obj1,Matrix &obj2){
for (int i = 0; i <
obj1.line&&obj2.line; ++i)
{
for (int j = 0; j <
obj1.col&&obj2.col; ++j)
if(obj1.mat[i][j]!
=obj2.mat[i][j])
return true;
return false;
}
}

int main()
{
int x,y,z;
Matrix r1,r2;
cout<<"Get x,y:";
cin>>x>>y;
Matrix a(x,y);
Matrix b(a);
cout<<"Introduceti obiectul
a"<<endl;
cin>>(cin,a);
cout<<(cout,a);
cout<<endl<<"Iintroduceti
obectul b"<<endl;
cin>>(cin,b);
cout<<(cout,b);
bool test;
test = a == (a,b);
cout<<"Verificarea daca
matricile sunt egale:"<<test;
cout<<endl;
bool test1;

test1 = a >(a,b);
cout<<"Matricea 1 este mai
mare de cit Matricea
2:"<<test1<<endl;
bool test2;
test2 = a<(a,b);
cout<<"Maticea 1 este mai
mica de cit Matricea
2:"<<test2<<endl;
bool test3;
test3= a!=(a,b);
cout<<"Matricile sunt
difeite:"<<test3<<endl;
cout<<"Suma:"<<endl;
a+(b);
cout<<(cout,a);
cout<<"Diferenta:"<<endl;
a-(b);
cout<<(cout,a);
cout<<"Atribuirea
a=b:"<<endl;
a=(b);
cout<<(cout,a);

Concluzie: Efectuind aceasta lucrare de laborator am capatat deprinderi


de a lucre cu supraincarcarea operatorilor . Avantajul utilizrii operatorilor
(reducerea codului) n acelai timp complic nelegerea codului, deoarece
nu este posibil ntotdeauna sau este complicat s se urmreasc dac se
utilizeaz un operator predefinit sau suprancrcat. ns suprancrcarea
operatorilor este necesar. Sunt probleme care se soluioneaz numai prin
suprancrcarea operatorilor,cum ar fi operatorul de atribuire si etc.