Sunteți pe pagina 1din 7

Ministerul Educaţiei, Culturii, Inovației și Cercetării al

Republicii Moldova
Universitatea Tehnică a Moldovei
Catedra Informatica şi Ingineria Sistemelor

Raport
Lucrarea de laborator nr.3
La POO (Programarea Orientată pe Obiecte)

A efectuat: st. gr. IA-171


Bodorin Adrian

A verificat: lector.univ.
Plotnic Constantin

Chişinău 2018
Lucrarea de laborator nr. 3
Tema: Supraincarcarea operatorilor
Scopul lucrării: familiarizarea studenţilor cu noţiunile operatori supraîncărcaţi.
Varianta:5
Sarcina:
Să se creeze clasa Stack – stivă, utilizînd memoria dinamică. Să se definească
următorii operatori ca metode ale clasei: "+" – de adunare a două stive, "=" – de
atribuire, "()" – de returnare a unei stive noi care conţine ultimele n elemente ale
stivei date. 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 stivei. Să se definească operatorii "<<" şi ">>" pentru
ieşiri/intrări de obiecte. Clasa trebuie să fie absolut funcţională, adică să conţină
toţi constructorii necesari şi destructorul.

Listing-ul programului:

#include <iostream>

using namespace std;

class Stack
{
public:
struct Nod
{int info;
Nod * next;
};
Nod *cap;
int n;
Stack()
{
cap = NULL;
n = 0;
}

Stack(const Stack& o) {
cap = NULL;
this->n = o.n;
Nod * temp = NULL, *prec = NULL;
Nod * c = o.cap;
for (int i = 0; i < this->n; i++) {
temp = new Nod;
temp->next = NULL;
temp->info = c->info;
if (this->cap == NULL)
this->cap = temp;
else
prec->next = temp;
prec = temp;
c = c->next;
}
}

~Stack() {
Nod * t;
do {
t = cap;
cap = cap->next;
delete t;
} while (cap);
}

void Creare_Stivei(void)
{
Nod *temp = NULL;
cout << "\n Introduceti numarul de noduri "; cin >> n;
for (int i = 0; i<n; i++)
{ temp = new Nod;
cout << "\nIntroduceti informatia in nod: ";cin >>
temp->info;
temp->next = cap;
cap=temp;
}

void Afisare_Stivei()

{cout<<"\n____________________________________________________________
__\n";
Nod *temp = cap;
cout << "\n Elementele listei sunt: ";
while (temp)
{
cout << temp->info << " ";
temp = temp->next;
}
cout<<"\n_____________________________________________________________
_\n";
}

Stack invers()
{ Stack t;
t.n = this->n;
Nod * temp = NULL;
Nod * c = this->cap;
for (int i = 0; i < this->n; i++) {
if (c == NULL) break;
temp = new Nod;
temp->info = c->info;
temp->next = t.cap;
t.cap = temp;
c = c->next;
}
return t;
}

Stack operator()( int n)


{ Stack t;
t.n = n;
Nod *temp = NULL, *prec = NULL;
Nod *c=this->cap;
for (int i = 0; i<n; i++)
{ temp = new Nod;
temp->next = NULL;
temp->info = c->info;
if (t.cap == NULL)
t.cap = temp;
else
prec->next = temp;
prec = temp;
c = c->next;
}
return t;
}

Stack operator +(Stack & k)


{
Stack t(*this);
Stack t2( k.invers() );
t.n += t2.n;
Nod * temp = NULL;
Nod * c = t2.cap;
for (int i = 0; i < t2.n; i++) {
temp = new Nod;
temp->info = c->info;
temp->next = t.cap;
t.cap = temp;
c = c->next;
}
return t;
}

Stack operator = (const Stack & o) {


if (cap != NULL) {
this->~Stack();
cap = NULL;
}
this->n = o.n;
Nod * temp = NULL, *prec = NULL;
Nod * c = o.cap;
for (int i = 0; i < n; i++) {
temp = new Nod;
temp->next = NULL;
temp->info = c->info;
if (this->cap == NULL)
this->cap = temp;
else
prec->next = temp;
prec = temp;
c = c->next;
}
return *this;
}
friend bool operator == (Stack o1,Stack o2) ;
friend bool operator != (Stack o1,Stack o2) ;
friend bool operator < (Stack o1,Stack o2) ;
friend bool operator > (Stack o1,Stack o2) ;

};

bool operator ==( Stack o1, Stack o2)


{
{
if (o1.n!=o2.n) return false;
Stack:: Nod *t1=o1.cap,*t2=o2.cap;
for(int i=0;i<o1.n;i++)
{
if(t1->info!=t2->info) return false;
t1=t1->next;
t2=t2->next;
}
return true;
}
}
bool operator != (Stack o1,Stack o2)
{
return !(o1==o2);
}

bool operator < (Stack o1,Stack o2)


{
if (o1.n<o2.n) return true;
else if (o1.n>o2.n) return false;
Stack::Nod *t1=o1.cap,*t2=o2.cap;
for(int i=0;i<o1.n;i++)
{
if(t1->info<t2->info) return true;
else if (t1->info>t2->info)return false;
t1=t1->next;
t2=t2->next;
}
return false;
}
bool operator > (Stack o1,Stack o2)
{
if (o1.n>o2.n) return true;
else if (o1.n<o2.n) return false;
Stack::Nod *t1=o1.cap,*t2=o2.cap;
for(int i=0;i<o1.n;i++)
{
if(t1->info>t2->info) return true;
else if (o1.n<o2.n) return false;
t1=t1->next;
t2=t2->next;
}
return false; }

int main()
{
Stack o1;
o1.Creare_Stivei();
o1.Afisare_Stivei();
cout<<"\n* Crearea unei noi stive din prima prin metoda de copiere :";
Stack o2;
int n;
cout << "\n\nCite elemente din prima doriti sa copiati in a 2-a: ";
cin >> n;
o2 = o1(n);
o2.Afisare_Stivei();
cout<<"\n* Crearea unei noi stive cu ajutorul operatorului=:";
Stack o3;
o3=o2;
o3.Afisare_Stivei();
cout<<"\n* Crearea unei noi stive cu ajutorul operatorului+:";
Stack o4;
o4=o1+o2;
o4.Afisare_Stivei();
cout<<"\n* Raspunsurile la operatorii de comparare sunt:";
cout<<"\n_____________________________________________________________
_\n";
cout<<"Egalitate "<<(o1==o2)<<endl;
cout<<"Inegalitate "<<(o1!=o2)<<endl;
cout<<"Mai mare "<<(o1>o2)<<endl;
cout<<"Mai mic "<<(o1<o2)<<endl;
cout<<"\n_____________________________________________________________
_\n";
}

Rezultatul:

S-ar putea să vă placă și