Universitatea Tehnica a Moldovei

RAPORT La lucrarea de laborator nr.3

Tema : Supraincarcarea operatorilor

Elaborat de studenta Butucea Mariana

gr. FI-141 :

Verificat de profesorul : Rusu Mariana

Chişinău-2016
Problema 1
Să se creeze clasa Date – data, care conţine cîmpurile: ziua, luna, anul. Să se definească operatorii "+" şi
"-" ca metode ale clasei, iar operatorii "++" şi "--" în ambele variante(prefixă şi postfixă) ca funcţii
prietene. Operatorul "+" trebuie să permită realizarea operaţiilor numai cu variabilele de tip predefinit int
(x=y+5).
Problema 2 :
Să se creeze clasa List – coadă. Să se definească operatorii "+" – de adunare a listelor, "=" – de atribuire ca
metode ale clasei. Să se definească operatorii de comparare "==", "!=", "<", ">" ca funcţii prietene. Să se
supraîncarce operatorii "<<" şi ">>" pentru ieşiri/intrări de obiecte, precum şi pentru inserarea/eliminarea
elementelor în/din coadă. Clasa trebuie să fie absolut funcţională, adică să conţină toţi constructorii
necesari şi destructorul. Pentru simplificarea lucrului să se utilizeze clasa sau structura ListItem pentru
reprezentarea elementelor listei spre care referă List.
1. Codul sursa :
#include<iostream>
#include<conio.h>
#include<stdlib.h>
#include<string.h>

using namespace std ;

class Date
{
int day;
int month;
int year;

public:
Date() //constr.implicit
{
day=0;
month=0;
year=0;
};
Date(Date &d) //constr.copie
{
this->day=d.day;
this->month=d.month;
this->year=d.year;
};
Date(int d,int m,int y) //constr. general
 {
day=d;
month=m;
year=y;
};
~Date(){}; //destructor
Date operator+(Date &s) // supraincarcarea operatorului + ca metoda a clasei
{
Date res;
res.day=this->day+s.day; // suma zilelor obiectului curent +
obiectul ca parametru
res.month=this->month+s.month;
res.year=this->year+s.year;
return res;
};
Date operator-(Date &d)
{
Date dif;
dif.day=this->day-d.day;
dif.month=this->month-d.month;
dif.year=this->year-d.year;
return dif;
};
friend Date& operator++(Date& pr); // metode prietene - ca sa aiba acces
la datele private ale obiectului
friend Date operator++(Date& post,int);
friend Date& operator--(Date& dec);
friend Date operator--(Date& post,int);

void print()
{
cout<<endl<<"Le jour "<<day;
cout<<endl<<"Le mois "<<month;
cout<<endl<<"L'annee "<<year<<endl;
}
};
Date& operator++(Date& pr)
 {
Date pre; // preincrementarea
pr.day++;
pr.month++;
pr.year++;
pre.day=pr.day;
pre.month=pr.month;
pre.year=pr.year;
return pre;
}
Date operator++(Date& post,int)
{
Date st; // posincrementarea
st.day=post.day;
st.month=post.month;
st.year=post.year;
post.day++;
post.month++;
post.year++;
return st;
}
Date& operator--(Date& dec)
{
Date decr;
dec.day--;
dec.month--;
dec.year--;
decr.day=dec.day;
decr.month=dec.month;
decr.year=dec.year;
return decr;
}
Date operator--(Date& post,int)
{
Date st;
st.day=post.day;
st.month=post.month;
 st.year=post.year;
post.day--;
post.month--;
post.year--;
return st;

int main()
{
Date data1(10,11,2010),data2(data1),data3(5,1,3),data4();// am construit obiecte de tip date ;
int d=2,d2=1;
cout<<endl<<"Voila l'objet data2(l'objet de travail):";
data2.print();
getch();
cout<<endl<<"Voila l'objet data3:";
data3.print();
getch();
cout<<endl<<"La somme de deux objets de type Date:";
data2=data1+data3;
data2.print();
getch();
cout<<endl<<"La differece de deux objets de type Date:";
data2=data1-data3;
data2.print();
getch();
cout<<endl<<"L'operateur '++' prefix:";
++data2;
data2.print();
getch();
cout<<endl<<"L'operateur '++'postfix:(avant et apres l'incrementation)";
data2++.print();
data2.print();
getch();
cout<<endl<<"L'operateur '--' prefix:";
--data2;
data2.print();
 getch();
cout<<endl<<"L'operateur '--'postfix(avant et apres la decrementation)";
data2--.print();
data2.print();
getch();
return 0;
}

Rezultatele compilarii :
Afisarea datelor initiale si in urma prelucrarilor:
2. Codul sursa :
#include <iostream>
#include <sstream>

using namespace std;

class Node {
public:
int data;
Node *link;
};
using namespace std;

class Set {
private:
Node *p;

public:
Set();

Set &operator+(Set &); // supraincarcarea operatorilor ca metode membre

Set &operator*(Set &);

Set &operator-(Set &);

friend void operator+=(Set &, int); // ca metode prietene inserarea unui element nou

friend bool operator==(Set &, Set&);//comparare la egalitate

friend ostream &operator<<(ostream &, Set&); // supraincarcarea fluxului de iesire

friend istream &operator>>(istream &, Set&); // de intrare

bool has(int);

Node *first();// returneaza primul element

int size(); // nr de el in multimi

};
Set::Set() {
p = NULL;
}

bool Set::has(int element) {// implementarea metodei has : verifica daca multimea curenta
contine elementul transmis ca arg
Node *q;
bool has = false;

for (q = p; q != NULL; q = q->link) {

if (q->data == element) {
has = true;
 break;
}
}

return has;
}

Node *Set::first() { return p; }

int Set::size() {
Node *q;
int size = 0;
for (q = p; q != NULL; q = q->link)
size++;

return size;
}

Set &Set::operator+(Set &set) {

Set result;
Node *q;

for (q = p; q != NULL; q = q->link) {

result += q->data;
}

for (q = set.first(); q != NULL; q = q->link) {

result += q->data;
}

return result;

Set &Set::operator*(Set &set) {

Set result;
Node *q;

for (q = p; q != NULL; q = q->link)

if (set.has(q->data))
result += q->data;

return result;
}

Set &Set::operator-(Set &set) {

Set result;
Node *q;

for (q = p; q != NULL; q = q->link)

if (!set.has(q->data))
result += q->data;
 return result;
}

void operator+=(Set &set, int value) {

Node *q, *t;

if (!set.has(value)) {

if (set.p == NULL) {
set.p = new Node;
set.p->data = value;
set.p->link = NULL;
}
else {
q = set.p;

while (q->link != NULL)

q = q->link;

t = new Node;
t->data = value;
t->link = NULL;
q->link = t;
}
}

bool operator==(Set &set1, Set &set2) {

Set diff1, diff2;

diff1 = set1 - set2;

diff2 = set2 - set1;

return diff1.size() == 0 && diff2.size() == 0;

ostream &operator<<(ostream &out, Set &set) {//apartenenta el la multime

Node *q;

for (q = set.first(); q != NULL; q = q->link) {

out << q->data << " ";
}

return out;
}

istream &operator>>(istream &in, Set &set) {// declarate ca friend

int data;
 string s;

while (getline( cin, s ) && !s.empty())

{
stringstream ss( s );
ss >> data;
if (!ss)
cout << "Invalid number. Try again" << endl;
else
set += data;
}

return in;
}

int main() {
Set set1, set2, result;

cout << "Give first set: " << endl;

cin >> set1;
cout << "Give second set: " << endl;
cin >> set2;

cout << "First set : " << set1 << endl;

cout << "Second set : " << set2 << endl;

bool b = set1 == set2;

cout << "Equality of sets(0 for false, 1 for true) = " << b << endl;

result = set1 - set2;

cout << "Difference between first and second set : " << result << endl;

result = set1 * set2;

cout << "Intersection between first and second set : " << result << endl;

result = set1 + set2;

cout << "Reunion between first and second set : " << result << endl;

set1 += 10;
cout << "Add element 10 to first set" << endl;
cout << "First set : " << set1 << endl;

cout << "First set's size = " << set1.size();

return 0;
}
Rezultatele compilarii:

Adunarea listelor, diferenta,intersectia

Concluzie:
In aceasta lucrare de laborator am creat o clasa cu anumite cimpuri indicate in sarcina. Am definit
operatorii "+" şi "-" ca metode ale clasei, iar operatorii "++" şi "--" în ambele variante(prefixă şi postfixă)
ca funcţii prietene
In partea a 2 a lucrarii am creat clasa List – coadă. Am definit operatorii "+" – de adunare a listelor, "=" –
de atribuire ca metode ale clasei. Am definit operatorii de comparare "==", "!=", "<", ">" ca funcţii
prietene. Am supraîncarcat operatorii "<<" şi ">>" pentru ieşiri/intrări de obiecte, precum şi pentru
inserarea/eliminarea elementelor în/din coadă. Clasa este funcţională, conţine toţi constructorii necesari şi
destructorul.