Sunteți pe pagina 1din 17

Universitatea Tehnica a Moldovei

Catedra Automatica si Tehnologii Informationale


Disciplina: Programarea in limbajul C++

RAPORT
Lucrare de laborator Nr.3
Varianta 2
Tema: Suprancrcarea operatorilor

A efectuat :

studentul grupei ISBM-111


Golubenco Alexandru

A verificat:

lector universitar Cojocaru Svetlana

Chisinau 2012
1

1 Scopul lucrrii:
Studierea necesitii suprancrcrii operatorilor;
Studierea sintaxei de definire a operatorilor;
Studierea tipurilor de operatori;
Studierea formelor de suprancrcare;
Sarcina lucrari:
Sa se creeze clasa stack vector, utiliznd memoria dinamic. S se defineasca urmatorii operatori ca
metode ale clasei: + - de adunare a doi vectori, - de scadere a doi vectori, * de imultirea a
doi vectori, () de returnare a unui vector nou care conine ultimele N elemente ale vectorului, +
cu un numar. S se defineasc operatorii de comparare: ==, !=, <, > ca funcii prietene.
S se defineasc operatorii << i >> pentru ieiri/intrri de obiecte. Clasa trebuie s fie absolut
funcional, adic s conin toi constructorii necesari i destructorul.

2 Indicatii teoretice
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.
Functiile prietene sunt functii care nu sunt metode ale unei clase, dar care au totusi acces la membrii
privati ai acesteia. Orice functie poate fi prietena a unei clase, indiferent de natura acesteia.
2.1 Suprancrcarea
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.

2.2 Crearea si distrugerea obiectelor


Sa consideram urmatorul program C++:
void main()
{ Point p; }
In momentul definirii variabilei p, va fi alocat automat spatiul de memorie necesar, acesta fiind
2

eliberat la terminarea programului. In exemplul de mai sus, variabila p este de tip static. In continuare
vom modifica acest program pentru a folosi o variabila dinamica (pointer).
void main()
{
Point *p;
p = new Point;
p->x = 5;
p->y = 10;
printf("Aria = %d\n", p->Aria());
delete p;
}
Ati observat utilizarea unor operatori pe care nu ii cunoasteti din limbajul C: new si delete. C++
introduce o metoda noua pentru gestiunea dinamica a memoriei, similara celei utilizate in C (malloc() si
free()), dar superioara si special construita pentru programarea orientata pe obiecte. Operatorul new este
folosit pentru alocarea memoriei, iar sintaxa acestuia este:
variabila = new tip;
variabila = new tip(valoare_initiala);
variabila = new tip[n];
Este usor de intuit ca prima varianta aloca spatiu pentru variabila dar nu o initializeaza, a doua varianta
ii aloca spatiu si o initializeaza cu valoarea specificata, iar a treia aloca un tablou de dimensiune n. Acest
operator furnizeaza ca rezultat un pointer continand adresa zonei de memorie alocate, in caz de succes, sau
un pointer cu valoarea NULL (practic 0) atunci cand alocarea nu a reusit.
Eliminarea unei variabile dinamice si eliberarea zonei de memorie aferente se realizeaza cu ajutorul
operatorului delete. Sintaxa acestuia este:
delete variabila;
Desi acesti doi operatori ofera metode flexibile de gestionare a obiectelor, exista situatii in care aceasta
nu rezolva toate problemele (de exemplu obiectele care necesita alocarea unor variabile dinamice in
momentul crearii lor). De aceea pentru crearea si distrugerea obiectelor in C++ se folosesc niste functii
membre speciale, numite constructori si destructori.
Constructorul este apelat automat la instantierea unei clase, fie ea statica sau dinamica.
Destructorul este apelat automat la eliminarea unui obiect, la incheierea timpului de viata in cazul
static, sau la apelul unuidelete in cazul dinamic.
Din punct de vedere cronologic, constructorul este apelat dupa alocarea memoriei necesare, deci in faza
finala a crearii obiectului, iar destructorul inaintea eliberarii memoriei aferente, deci in faza initiala a
distrugerii sale.
Constructorii si destructorii se declara si se definesc similar cu celelalte functii membre, dar prezinta o
serie de caracteristici specifice:
numele lor coincide cu numele clasei careia ii apartin; destructorii se disting de constructori prin faptul
ca numele lor este precedat de caracterul ~
a) nu pot returna nici un rezultat
b) nu se pot utiliza pointeri catre constructori sau destructori
c) constructorii pot avea parametri, destructorii insa nu.
Un constructor fara parametri poarta denumirea de constructor implicit.
De remarcat este faptul ca in cazul in care o clasa nu dispune de constructori sau destructori, compilatorul de
C++ genereaza automat un constructor respectiv destructor implicit.
3

Sa completam in continuare clasa Point cu un constructor si un destructor:


Point::Point()
// constructor implicit
{
x = 0;
y = 0;
}
Point::Point(unsigned X, unsigned Y)
{
x = X;
y = Y;
}
Point::~Point()
{
}
Ati remarcat cu aceasta ocazie modul de marcare a comentariilor in C++: tot ce se afla dupa
caracterul // este considerat comentariu.
De notat este faptul ca definitii de forma
Point p;
sau
Point *p = new Point();
duc la apelarea constructorului implicit.
O intrebare care poate apare este motivul pentru care am realizat functiile GetX(), GetY(), SetX(),
SetY(), cand puteam utiliza direct variabilele membru x si y. Deoarece una din regulile programarii C++,
adoptata in general de catre specialisti, este de a proteja variabilele membru (veti afla in capitolul urmator
cum), acestea neputand fi accesate decat prin intermediul unor functii, care au rolul de metode de prelucrare
a datelor incapsulate in interiorul clasei.
3 Realizarea sarcinii:
Programul dat a fost compus din dou fiiere cu numele File2.h,(vezi fig.1) i File1.cpp(vezi
anexa A) n care se conine funcia pause() care este folosit pentru vizualizarea programului mai comod i
original, i definirea unor culori.
Coninutul fisierului File2.h:

S
incepem sa
discutam
despre
clasa
Stack.
class
stack{
Fig. 1

int *elem;
int dim;
public: stack():elem(NULL),dim(0){};
// constructor implicit
stack(int d):dim(d){elem = new int[d];}
//constr. explicit
~stack(){delete []elem; elem=NULL; dim=0;};
// destructor
aloc(int d){elem = new int[d]; dim=d;}
// alocare de memorie
stack(stack &);
// construct de copiere
ret(int i){return elem[i];};
// return elem[ i ]
friend istream & operator>>(istream &in, stack &obj);
friend ostream & operator<<(ostream &out,stack &obj);
friend int operator>( stack &, stack & );
friend int operator<( stack &, stack & );
friend int operator==(stack &, stack & );
friend int operator!=(stack &, stack & );
stack operator()(int);
stack operator+(stack);
stack operator-(stack);
stack operator+(int);
stack operator*(stack); };
Dupa cum se tie cu ajutorul claselor se realizeaza un vhechi deziderat al programatorilor: unificarea
datelor i a procedurilor. In cazul meu variabilile int *elem, si int dim, sunt private (default).
Publice sunt doar constructori, destructori, funciile (aloc) i operatorii de supraincarcare a operatiilor
de ( adunare, scadere, inmultire etc.) ca funcii membre sau prietene.
3.1 Constructorul de copiere:
stack :: stack(stack &obj){
this->elem = new int[obj.dim];
for (int i = 0; i < obj.dim; i++)
this->elem[i]=obj.elem[i];
this->dim=obj.dim;

// Alocarea memoriei this->elem, obj.dim - elemente


// copierea element cu element;

};
3.2 supraincarcarea operatorului >> (intrare):
Suprancarcarea acestui operator a fost declarata ca funcie prieten.
Cuvntul neneles din aceast funcie poate fi: blue i yellow, care tiu engleza neleg c merge vorba
despre culori, i ar avea dreptate. Mai concret n aceast funcie cnd execuia programului va ajunge la
cuvintul definit blue - nlocuiete codul:
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 9); unde 9 este codul culori albastru.
i tot ce urmeaz dupa el va fi de culoarea albastr;
istream & operator>>(istream & in, stack & obj){
for (int i = 0; i < obj.dim; i++) {
blue; cout<<"V1["; yellow;
cout<<i+1; blue; cout<<"]= ";
white;
in>>obj.elem[i];
}
return in;
}
Exemplu de execuie acestui cod va fi (vezi fig.2):
5

Fig. 2

3.3 supraincarcarea operatorului << (ieire):


ostream &operator<<(ostream & out, stack & obj){
for (int i = 0; i < obj.dim; i++)
out<<" "<<obj.elem[i]<<" ";
return out;
white;
// culoarea alb, (default) a programului dat
}
Exemplu de execuie acestui cod va fi (vezi fig.3):

Fig. 3
3.4 supraincarcarea operatorului + (adunare a doi vectori):
Conditia de baza pentu efectuarea acestei operai este ca trebuie s aib acelai numar de elemente, n cazul
meu trebuie sa fie adevarata condiia:
dac va fi adevrat se va efectua adunarea,
Daca nu va fi adevrat se va afia un mesaj de eroare:
Exemplu de execuia cazului cnd nu coincide dimensiunile vectorilor: (da, culoarea nu e cea mai potrivita )
Funcia exit(1); - ieire forat din program
del; - curt ecranul,
stack stack ::operator +(stack v){
if (dim==v.dim) {
// verivicarea daca au acelai numr de elemente
stack v1;
v1.aloc(v.dim);
// alocarea memoriei pentru vectorul v1 (apel la funcia aloc();)
for (int i = 0; i < v.dim; i++)
v1.elem[i]=elem[i]+v.ret(i);
return v1;
}
else {del; blue; cout<<"Eroare nu se poate de efectuat operatia de adunare !(dim1!=dim2)"; getch();
exit(1);}
}

3.5 supraincarcarea operatorului (scderea a doi vectori):


Suprancrcarea acestui operator este analogic ca i operatorului de adunare i nmulire, toate sunt
declarate ca funcii membre a clasei.
stack stack ::operator -(stack v){
if (dim==v.dim) {
stack v1;
6

v1.aloc(v.dim);
for (int i = 0; i < v.dim; i++)
v1.elem[i]=elem[i]-v.ret(i);
return v1;
}
else {del; blue; cout<<"Eroare nu se poate de efectuat operatia de scadere !(dim1!=dim2)"; getch();
exit(1);}
};
3.6 supraincarcarea operatorului * (nmulirea a doi vectori):
stack stack ::operator *(stack v){
if (dim==v.dim) {
stack v1;
v1.aloc(v.dim);
for (int i = 0; i < v.dim; i++)
v1.elem[i]=elem[i]*v.ret(i);
return v1; }
else {del; cout<<"Eroare nu coincid dimensiuniile vectorilor !"; getch(); };
};
3.7 supraincarcarea operatorului + (vectorului v1 + un N -dat):
Datorit supraincarcari acestui operator i anume pentru a putea aduna un vector cu un numar dat.
Daca nu va fi fcut aceast suprancarcare scierea data va fi eronat:
v=v1+2;
unde v- este un vector i v1- un vector creat (cel putin 1 element);
stack stack ::operator +(int n){
if (dim>0)
{stack v(dim);

// daca vor exista elemente in vector, cel putin 1 atunci


// se creaz un vector v (se apeleaza automat constructorul explicit,
//unde se aloca memorie necesara)

for (int i = 0; i < this->dim; i++)


v.elem[i]=elem[i]+n;
return v;
//se returneaz vectorul v care contine suma vectorului cu n
}
else {del; blue; cout<<"Eroare vectorul adunat este gol !"; getch(); };
3.8 supraincarcarea operatorului < (operator de comparare):
Suprancarcarea operatorilor de comparare sunt declarate ca funcii prietene.
int operator<(stack &v1, stack &v2){
int k;
if (v1.dim<v2.dim) k=v1.dim;
else k=v2.dim;
for (int i = 0; i < k; i++)
if (v1.elem[i]>v2.elem[i]) return 0;
else if (v1.elem[i]<v2.elem[i]) return 1;
if (v1.dim<v2.dim) return 1;
else return 0; };
3.9 supraincarcarea operatorului > (operator de comparare):
int operator>(stack &v1, stack &v2){
int k;
if (v1.dim>v2.dim) k=v1.dim;
else k=v2.dim;
for (int i = 0; i < k; i++)
if (v1.elem[i]<v2.elem[i]) return 0;
7

else if (v1.elem[i]>v2.elem[i]) return 1;


if (v1.dim>v2.dim) return 1;
else return 0;
};
3.10 supraincarcarea operatorului == (operator de comparare):
int operator==(stack & v1, stack &v2){
if (v1.dim!=v2.dim) return 0;
for (int i = 0; i < v1.dim; i++)
if (v1.elem[i]==v2.elem[i]) return 1;
return 0;
};
3.11 supraincarcarea operatorului != (operator de comparare):
int operator!=(stack &v1, stack &v2){
if (v1.dim!=v2.dim) return 1;
else if (v1.dim==v2.dim)
for (int i = 0; i < v1.dim; i++)
if (v1.elem[i]!=v2.elem[i]) return 1;
return 0;
};
3.12 supraincarcarea operatorului ( ) (paranteze rotunde):
Scopul suprancarcari acestui operator const n aceia ca sa pot s returnez un vector care este alctuit din
ultimele N (N numar dat).
De exemplu (N=2) vectorul A conine 5 elemente [2 6 4 -3 1] , se cere s se constuiasc vectorul B
care va conine ultimele N(N=2) de aici rezulta c B va conine [-3 1];
Exemplu cum va rezolva programul aceast problema:

stack stack ::operator ()(int n){


if (n<=this->dim) {
//daca vectorul venit contine cel mult n elemente atunci
Fig. 4
stack v;
// se creaz un vector suplimentar
v n care se vor scrii ultimele n elemente
int k=0;
// creez o variabil de tip intreg, si i atribui 0
v.aloc(n);
// aloc memorie pentru vectorul suplimentar v
for (int i = 0; i<=this->dim; i++) //pornesc un ciclu de la 0 pn la (cte elemente are vectorul venit)
if (i>=(this->dim-n)) { // daca i va ajunge n intervalul (dim-n) atunci se nscrie acest element de pe
v.elem[k]=this->ret(i); // pozitia i n vectorul v suplimentar pe poziia k unde k de prima dat
// este 0,
k++; }
// dup aceasta se incrementeaz k cu 1;
return v;
// se returneaz vectorul suplimentar v
}
//daca vectorul venit conine mai puine elemente ca n introdus atunci se
//afieaz mesajul ca am introdus un N mai mare decit numarul de elemente ale
//vectorului.
else {del; blue; cout<<"Eroare N este mai mare da dimensiunea vectorului !"; getch(); }};
3.13 funcia operaiilor matematice (operatia_M();)
Funcia operatia_M() este de tip void, este sun submeniu, din care se poate de ales comanda dorit.
Datorit acestei functi sa micorat volumul funciei main()
Cum arat submeniul (vezi Fig.)

Fig. 5
Codul surs fuciei operatia_M();
void operatia_M(){
char com;
sus: del;
white; cout<<"1 "; yellow; cout<<"-Suma: V1 + V2"<<endl;
white; cout<<"2 "; yellow;cout<<"-Scaderea: V1 - V2"<<endl;
white; cout<<"3 "; yellow; cout<<"-Produsul: V1 * V2"<<endl;
white; cout<<"4 "; yellow; cout<<"-V1 + N (N - Numar dat)"<<endl;
white; cout<<"5 "; yellow; cout<<"-Compararea V1 si V2"<<endl;
blue; cout<<"Backspace "; white; cout<<"-Inapoi"<<endl;
com=getch();
switch (com) {
case '1':{
del; cyan;
// del; - cura ecranul, cyan; - culoare;
cout<<"Suma: V1 + V2"<<endl;
stack vs;
// Vector Suma
vs=v1+v2;
yellow; cout<<"["<<v1<<"]";
white; cout<<" + ";
cyan; cout<<"["<<v2<<"]";
yellow; cout<<" = ";
white; cout<<"["<<vs<<"]";
break;};
case '2':{ del; cyan;
cout<<"Scaderea: V1 - V2"<<endl;
stack vsc;
//Vector SCcadere
vsc=v1-v2;
yellow; cout<<"["<<v1<<"]";
white; cout<<" - ";
cyan; cout<<"["<<v2<<"]";
yellow; cout<<" = ";
white; cout<<"["<<vsc<<"]";
break;};
case '3':{ del; cyan;
cout<<"Produsul: V1 * V2"<<endl;
stack vp;
//Vector Produs
vp=v1*v2;
yellow; cout<<"["<<v1<<"]";
white; cout<<" * ";
cyan; cout<<"["<<v2<<"]";
yellow; cout<<" = ";
white; cout<<"["<<vp<<"]";
break;};
case '4':{
del; cyan;
int n;
cout<<"N= "; cin>>n;
stack vn;
//Vector Numar
vn=v1+n;
yellow; cout<<"["<<v1<<"]";
9

white; cout<<" + ";


cyan; cout<<n;
yellow; cout<<" = ";
white; cout<<"["<<vn<<"]";
break;};
case '5':{

del; cyan;
if (v1>v2) {
yellow; cout<<"["<<v1<<"]";
white; cout<<" > ";
yellow; cout<<"["<<v2<<"]";
}
else if (v1<v2) {
yellow; cout<<"["<<v1<<"]";
white; cout<<" < ";
yellow; cout<<"["<<v2<<"]";
}
else {
yellow; cout<<"["<<v1<<"]";
white; cout<<" = ";
yellow; cout<<"["<<v2<<"]";
}
break;};
case 8 :{goto stop;}; // daca se testeaza butonul Backspace atunci iese din fincia operatia_M();
default :goto sus; }
getch(); goto sus;
stop:};
3.14 Funcia MAIN()
m funcia principal main() se introduc vectori v1 i v2, se apeleaza la funciile necesare cum ar fi
funcia de returnare a unui vector nou cu ultimele N elemente ale vectorului v1, ea se apeleaz tastnd tasta
cu numarul 4, (vezi Fig. 6);

Fig. 6
Codul surs funciei de returnare a unui vector nou cu ultimele N elemente
.
v1 ct i a v2
Fig. 7)

Introducerea vectorului
sunt la fel (vezi

10

Fig. 7
Apelu la funcia operatia_M() se efectuiaz apsnd tasta cu numarul 3, vezi codul surs apelului la
funcia data (Fig. 8)

Ieirea din program se efectuiaz tastnd tasta Esc (vezi Fig. 9)


Fig. 8

Fig. 9
Concluzi:
In urma efectuarii lucrarii date am determinat ca mediul de prgramare C++ este cu mult flexibil ca
C, care ne permite sa manipulam cu informatia intr-un mod rapid si eficient fara a induce erori grosolane, si
am aflat ca utilizarea claselor este cu mult mai comod si mai rapid in eleborarea unui program.
Am neles importanta suprancarcari operatorilor de adunare, scadere, nmulire i anume pentru a
permite utilizarea acestora in efectuarea operatiilor cu careva date create de utilizator, n cazul meu a fost
vectori, adunarea unor vectori de exemplu (vectorul1+vectorul2) far suprancarcarea operatorului de
adunare este inmposibil, i altor operatori la fel.
Este foarte comod citirea si afiarea unui vector datorita suprancrcri operatorilor de intrare/ieire.

Bibliografie
1 TOTUL DESPRE C SI C++ (MANUALUL FUNDAMENTAL DE PROGRAMARE IN C SI C++)[RO]
[Kris Jamsa][Lars Kland]
2 PROGRAMARE IN C_C++ CULEGERE DE PROBLEME Valiriu Iorga
3 Initiere in C++, Programarea orientata pe obiecte (Editie Prevazuta) Cluj-Napoca 1993

11

Anexa A
Fiierul File1.cpp
#include <conio.h>
#include <iostream.h>
#include <windows.h>
#include "File2.h"
class stack{
int *elem;
int dim;
public: stack():elem(NULL),dim(0){};
// canstructor implicit
stack(int d):dim(d){elem = new int[d];} //c. explicit
~stack(){delete []elem; elem=NULL; dim=0;}; // destructor
aloc(int d){elem = new int[d]; dim=d;}
// alocare
stack(stack &);
// construct de copiere
ret(int i){return elem[i];};
// return
friend istream & operator>>(istream &in, stack &obj);
friend ostream & operator<<(ostream &out,stack &obj);
friend int operator>( stack &, stack & );
friend int operator<( stack &, stack & );
friend int operator==(stack &, stack & );
friend int operator!=(stack &, stack & );
stack operator()(int);
stack operator+(stack);
stack operator-(stack);
stack operator+(int);
12

stack operator*(stack);};
stack v1,v2;
//**********************************************OPERATOR () {returnara a n elem}
stack stack ::operator ()(int n){
if (n<=this->dim) {
stack v;
int k=0;
v.aloc(n);
for (int i = 0; i<=this->dim; i++)
if (i>=(this->dim-n)) {
v.elem[k]=this->ret(i);
k++; }
return v; }
else {del; blue; cout<<"Eroare N este mai mare da dimensiunea vectorului !"; getch(); }};
//***************************************************OPERATOR DE COMPARARE !=
int operator!=(stack &v1, stack &v2){
if (v1.dim!=v2.dim) return 1;
else if (v1.dim==v2.dim)
for (int i = 0; i < v1.dim; i++)
if (v1.elem[i]!=v2.elem[i]) return 1;
return 0;
};
//************************************OPERATOR DE COMPARARE == EGALITATE
int operator==(stack & v1, stack &v2){
if (v1.dim!=v2.dim) return 0;
for (int i = 0; i < v1.dim; i++)
if (v1.elem[i]==v2.elem[i]) return 1;
return 0; };
//**************************************************OPERATOR DE COMPARARE >
int operator>(stack &v1, stack &v2){
int k;
if (v1.dim>v2.dim) k=v1.dim;
else k=v2.dim;
for (int i = 0; i < k; i++)
if (v1.elem[i]<v2.elem[i]) return 0;
else if (v1.elem[i]>v2.elem[i]) return 1;
if (v1.dim>v2.dim) return 1;
else return 0;
};
//***************************************************OPERATOR DE COMPARARE <
int operator<(stack &v1, stack &v2){
int k;
if (v1.dim<v2.dim) k=v1.dim;
else k=v2.dim;
for (int i = 0; i < k; i++)
if (v1.elem[i]>v2.elem[i]) return 0;
else if (v1.elem[i]<v2.elem[i]) return 1;
if (v1.dim<v2.dim) return 1;
else return 0;
};
//******************************************************************OPERATOR +
stack stack ::operator +(stack v){
if (dim==v.dim) {
stack v1;
13

v1.aloc(v.dim);
for (int i = 0; i < v.dim; i++)
v1.elem[i]=elem[i]+v.ret(i);
return v1;
}
else {del; blue; cout<<"Eroare nu se poate de efectuat operatia de adunare !(dim1!=dim2)"; getch();
exit(1);}
}
//******************************************************************OPERATOR stack stack ::operator -(stack v){
if (dim==v.dim) {
stack v1;
v1.aloc(v.dim);
for (int i = 0; i < v.dim; i++)
v1.elem[i]=elem[i]-v.ret(i);
return v1;
}
else {del; blue; cout<<"Eroare nu se poate de efectuat operatia de scadere !(dim1!=dim2)"; getch();
exit(1);}
};
//***************************************************ADUNAREA CU UN NUMAR
stack stack ::operator +(int n){
if (dim>0) // daca vor exista elemente in vector cel putin 1 atunci
{stack v(dim);
for (int i = 0; i < this->dim; i++)
v.elem[i]=elem[i]+n;
return v;
}
else {del; blue; cout<<"Eroare vectorul adunat este gol !"; getch(); };
};
//***************************************************************IMULTIREA V1*V2
stack stack ::operator *(stack v){
if (dim==v.dim) {
stack v1;
v1.aloc(v.dim);
for (int i = 0; i < v.dim; i++)
v1.elem[i]=elem[i]*v.ret(i);
return v1; }
else {del; cout<<"Eroare nu coincid dimensiuniile vectorilor !"; getch(); };
};
//************************************************************CONSTR. DE COPIERE
stack :: stack(stack &obj){
this->elem = new int[obj.dim];
for (int i = 0; i < obj.dim; i++)
this->elem[i]=obj.elem[i];
this->dim=obj.dim;
};
//***********************************************************************CIN, >>
istream & operator>>(istream & in, stack & obj){
for (int i = 0; i < obj.dim; i++) {
blue; cout<<"V1["; yellow; cout<<i+1; blue; cout<<"]= ";
white;
in>>obj.elem[i];
}
return in;
}
//***********************************************************************COUT <<
14

ostream &operator<<(ostream & out, stack & obj){


for (int i = 0; i < obj.dim; i++)
out<<" "<<obj.elem[i]<<" ";
return out;
white;
}
//****************************************************OPERATI MATEMATICE
void operatia_M(){
char com;
sus: del;
white; cout<<"1 "; yellow; cout<<"-Suma: V1 + V2"<<endl;
white; cout<<"2 "; yellow;cout<<"-Scaderea: V1 - V2"<<endl;
white; cout<<"3 "; yellow; cout<<"-Produsul: V1 * V2"<<endl;
white; cout<<"4 "; yellow; cout<<"-V1 + N (N - Numar dat)"<<endl;
white; cout<<"5 "; yellow; cout<<"-Compararea V1 si V2"<<endl;
blue; cout<<"Backspace "; white; cout<<"-Inapoi"<<endl;
com=getch();
switch (com) {
case '1':{
del; cyan;
cout<<"Suma: V1 + V2"<<endl;
stack vs; // Vector Suma
vs=v1+v2;
yellow; cout<<"["<<v1<<"]";
white; cout<<" + ";
cyan; cout<<"["<<v2<<"]";
yellow; cout<<" = ";
white; cout<<"["<<vs<<"]";
break;};
case '2':{ del; cyan;
cout<<"Scaderea: V1 - V2"<<endl;
stack vsc; //Vector SCcadere
vsc=v1-v2;
yellow; cout<<"["<<v1<<"]";
white; cout<<" - ";
cyan; cout<<"["<<v2<<"]";
yellow; cout<<" = ";
white; cout<<"["<<vsc<<"]";
break;};
case '3':{ del; cyan;
cout<<"Produsul: V1 * V2"<<endl;
stack vp; //Vector Produs
vp=v1*v2;
yellow; cout<<"["<<v1<<"]";
white; cout<<" * ";
cyan; cout<<"["<<v2<<"]";
yellow; cout<<" = ";
white; cout<<"["<<vp<<"]";
break;};
case '4':{
del; cyan;
int n;
cout<<"N= "; cin>>n;
stack vn; //Vector Numar
vn=v1+n;
yellow; cout<<"["<<v1<<"]";
white; cout<<" + ";
15

cyan; cout<<n;
yellow; cout<<" = ";
white; cout<<"["<<vn<<"]";
break;};
case '5':{

del; cyan;
if (v1>v2) {
yellow; cout<<"["<<v1<<"]";
white; cout<<" > ";
yellow; cout<<"["<<v2<<"]";
else if (v1<v2) {
yellow; cout<<"["<<v1<<"]";
white; cout<<" < ";
yellow; cout<<"["<<v2<<"]";
}
else {
yellow; cout<<"["<<v1<<"]";
white; cout<<" = ";
yellow; cout<<"["<<v2<<"]";
}
break;};
case 8 :{goto stop;};
default :goto sus;

}
getch(); goto sus;
stop:};
//***********************************************************************MAIN-ul
void main(){
stack s1;
char com;
sus:del;
white;
yellow; cout<<"1 "; white; cout<<"- Introdu vectorul V1"<<endl;
yellow; cout<<"2 "; white; cout<<"- Introdu vectorul V2"<<endl;
yellow; cout<<"3 "; white; cout<<"- Operati matematice asupra V1 si V2"<<endl;
yellow; cout<<"4 "; white; cout<<"- Returneaza un Vect. nou cu ultimile N elemente"<<endl;
yellow; cout<<"Esc "; white; cout<<"- Iesire din program"<<endl;
com=getch();
switch (com) {
case '1':{
int nv1;
white; del;
cout<<"Numarul de elemente= ";
cin>>nv1;
v1.aloc(nv1);
cin>>v1;
pause();
break;};
case '2':{
int nv2;
white; del;
cout<<"Numarul de elemente= ";
cin>>nv2;
v2.aloc(nv2);
cin>>v2;
pause();
break;};
case '3':{
operatia_M();
break;};
case '4':{
del;
16

int n;
blue;
cout<<"Atentie V1 trebuie sa contina cel putin un element"<<endl;
cyan;cout<<"Introdu N= "; cin>>n;
stack vnew(n);
vnew=v1(n);
white;
cout<<"Ultemul(-ele) "; cyan; cout<<n; white; cout<<" element(-e) din V1= ";
yellow; cout<<"["<<v1<<"]";
white;cout<<" este: ";
yellow; cout<<"["<<vnew<<"]";
getch();
break;};
case 27:{pause(); exit(1);}
default: goto sus;
}
goto sus;
getch();}

Fiierul File2.h
# define white SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 11) //alb
# define yellow SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 10) //galben
# define blue SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 9) //albastru
# define cyan SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 8) //cyan
# define del clrscr();
//curata ecranul
//********************************************************************MENU PAUZA
void pause(){
yellow;
cout<<endl<<endl<<"Apasati orice tasta...";
getch();
white;
};

17