OPERATORI

OPERATOR +=

RestaurantCuLivrari& operator+=(int x) {
this->costTransport += x;
return *this;
}

OPERATOR -=

RestaurantCuLivrari& operator-=(int x) {
this->costTransport -= x;
return *this;
}

OPERATOR +

RestaurantCuLivrari operator+(int x) {
RestaurantCuLivrari copie(*this);
this->costTransport += x;
return copie;
}

OPERATOR ++ PRE

RestaurantCuLivrari& operator++() {
this->costTransport += 100;
return *this;
}

OPERATOR ++ POST

RestaurantCuLivrari operator++(int) {
RestaurantCuLivrari copie(*this);
this->costTransport += 500;
return copie;
}

OPERATOR ==

bool operator==(RestaurantCuLivrari sursa) {

if (this->costTransport == sursa.costTransport && this->NonStop ==
sursa.NonStop) {
return true;
}
else {
return false;
}
}

OPERATOR <

bool operator<(RestaurantCuLivrari sursa) {

if (this->costTransport < sursa.costTransport) {
return true;
}
else {
return false;
}
}
OPERTOR INDEX []

int& operator[](int i) {
if (i >= 0 && i < this->nrMeniuri) {
return this->preturi[i];
}
else {
throw new exception("Index gresit.");
}
}

METODA CARE ADAUGA UN ELEMENT NOU IN VECTOR

void adaugaPretNou(int pretNou) {

int* vn = new int[nrMeniuri + 1];
for (int i = 0; i < nrMeniuri; i++) {
vn[i] = preturi[i];
}

vn[nrMeniuri] = pretNou;
if (this->preturi) {
delete[]this->preturi;
}

preturi = vn;
nrMeniuri++;
}

OPERATOR += CARE ADAUGA UN ELEMENT NOU IN VECTOR

Restaurant& operator+=(int pretNou) {

int* vn = new int[nrMeniuri + 1];
for (int i = 0; i < this->nrMeniuri; i++) {
vn[i] = preturi[i];
}
vn[this->nrMeniuri] = pretNou;
if (this->preturi) {
delete[]this->preturi;
}
this->preturi = vn;
this->nrMeniuri++;
return *this;
}

OPERATOR - - CARE STERGE ULTIMUL ELEMENT

Restaurant& operator--() {
int* vn;

if (nrMeniuri > 0) {
vn = new int[nrMeniuri - 1];
for (int i = 0; i < nrMeniuri - 1; i++) {
vn[i] = preturi[i];
}
if (this->preturi) {
delete[]this->preturi;
}
preturi = vn;
nrMeniuri--;
}
return *this;
}
OPERATOR - = CARE SCOATE DIN VECTOR DUPA INDEX

Restaurant& operator-=(int index) {

int* vn;
int k = 0;
if (index >= 0 && index < this->nrMeniuri) {
vn = new int[nrMeniuri - 1];
for (int i = 0; i < this->nrMeniuri - 1; i++) {
if (i != index) {
vn[k++] = preturi[i];
}
}
if (this->preturi) {
delete[]this->preturi;
}
preturi = vn;
nrMeniuri--;
}
return *this;
}

METODA ARE AFISEAZA ELEMENTELE DIN VECTOR MAI MARI DECAT X

int getNrPreturiMaiMariCa(int x) {
int contorPreturiMaiMariCaX = 0;
for (int i = 0; i < this->nrMeniuri; i++) {
if (this->preturi[i] >= x) {
contorPreturiMaiMariCaX++;
}
}
return contorPreturiMaiMariCaX;
}

METODA DE SORTARE ( < )

void sortare() {
for (int i = 0; i < nrMeniuri; i++) {
for (int j = i + 1; j < nrMeniuri; j++) {
if (preturi[i] > preturi[j]) {
int aux;
aux = preturi[i];
preturi[i] = preturi[j];
preturi[j] = aux;
} }
} }
OPERATOR +
Agentie operator + (Imobil im) {
Agentie copie = *this;
Imobil* vn = new Imobil[nrOferte + 1];
for (int i = 0; i < nrOferte; i++) {
vn[i] = oferte[i];
}
vn[nrOferte] = im;

if (copie.oferte) {
delete[] copie.oferte;
}
copie.oferte = vn;
copie.nrOferte++;
return copie; }
Tren & operator += (Vagon VagonNou) {

//nrvagoane 3
// V1 v2 v3
//vagoane (ad0) ---->[adv1][adv2][adv2]
//
Vagon ** v = new Vagon*[this->nrVagoane + 1]; // v (adv)------> [][][][]
for (int i = 0; i < this->nrVagoane; i++) { // v1 v2
v3 vagonNou
v[i] = new Vagon(* this->vagoane[i]); // v(adv)------ >
[advc1][advc2][advc3][advn ]
}
v[this->nrVagoane] = new Vagon ( VagonNou);

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

if (this->vagoane[i]) {
delete this->vagoane[i];
}
}
if (this->vagoane) {
delete[] this->vagoane;// vagoane(ad0)---- >
[0xcccc][0xcccc][0xcccc]
}
// v1 v2 v3 vagonNou
this->vagoane = v;// vagoane( adv) ----->[advc1][advc2][advc3][advn ]
this->nrVagoane += 1; //nr vagoane este 4

return *this;
}

//t3 -= 1;

Tren & operator-= (int index) {

Vagon ** v = nullptr;
if (this->nrVagoane > 0) {

v = new Vagon*[this->nrVagoane - 1];

int k = 0;
for (int i = 0; i < this->nrVagoane; i++) {
if (index != i) {
v[k++] = new Vagon(*this->vagoane[i]);
}
}
for (int i = 0; i < this->nrVagoane; i++) {
if (this->vagoane[i]) {
delete this->vagoane[i];
}
}
if (this->vagoane) {
delete[] this->vagoane;// vagoane(ad0)---- >
[0xcccc][0xcccc][0xcccc]
}
this->vagoane = v;

this->nrVagoane--;
}

return *this;
}
//OPERATORII += SI -= CARE PERMIT INCARCAREA/DESCARCAREA BATERIEI

BateriePowerBank& operator+=(int x) {

this->capacitate += x;

return *this;

BateriePowerBank& operator-=(int y) {

this->capacitate -= y;

return *this;

//OPERATORUL == CARE COMPARA 2 OBIECTE SI RETURNEAZA TRUE DACA TOATE VALORILE

ATRIBUTELOR SUNT EGALE.

bool operator==(BateriePowerBank sursa) {

if ((this->capacitate == sursa.capacitate) && (this->greutate ==

sursa.greutate) && (this->nrPorturiUSB == sursa.nrPorturiUSB) &&

(this->culoare == sursa.culoare) && (this->pret == sursa.pret) &&

(strcmp(this->producator, sursa.producator) == 0)) {

return true;

else {

return false;

//OPERATORUL FUNCTIE () CARE CALCULEAZA VALOAREA ASIGURARII INTR-O VALUTA PENTRU CARE
CURSUL DE SCHIMB ESTE TRANSMIS CA PARAMETRU

float operator()(float n)

return n * this->sumaAsigurata;

Apel: Broker b3(102, "Cristea Mihaela", 300, "Asigurare auto", 2);

cout << "Suma asigurata este acum de: " << b3(4.10) << " lei."<<endl;
//OPERATORUL DE CONVERSIE LA DOUBLE A UNEI ASIGURARI

explicit operator double() {

return this->sumaAsigurata;

Apel: float x = (double)b1;

cout << x << endl;

//OPERATOR ()(int) CARE PRIMESTE NR. LOCUITORI DIN CASA SI RETURNEAZA TRUE DACA
FIECARE PERSOANA ARE POSIBILITATEA DE A AVEA PROPRIA CAMERA SI FALSE DACA SUNT MAI
PUTINE CAMERE DECAT PERSOANE.

bool operator ()(int nrLoc) { // apel opetaror ????

if (nrLoc > 0 && nrLoc < nrCamere) {

if (nrCamere >= nrLocatari) {

return true;

if (nrLocatari > nrCamere) {

return false;

//OPERATOR ! PENTRU A INDICA DACA O PETITIE NU ARE RASPUNS SI A DEPASIT TERMENUL LEGAT
DE 30 ZILE

bool operator !() {

if (this->starePetitie == 0 && this->termen > 30) {

return true;

else {

return false; } }

Apel: if (!p5) {

cout << "Petitia nu are raspuns si a depasit termenul de 30 zile." << endl;

else {

cout << "Petitia a fost rezolvata." << endl;

}
//OPERATOR ~ PENTRU A SCHIMBA STAREA UNEI PETITII ( DESCHISA->REZOLVATA )

void operator~() {

if (starePetitie== true) {

this->starePetitie = false;

else {

this->starePetitie = true;

Apel: ~p1;

cout << p1 << endl;

//OPERATOR INDEX []

int& operator[](int i) {

if (i >= 0 && i < this->nrApartamente) {

return this->pretIntretinerePerApartament[i];

else {

throw new exception("Indexul dat ca parametru este gresit.");

Apel: cout << s1[2] << endl;

//operator de conversie la double care va returna cea mai vizionata productie

explicit operator double()

double viz = 0;

if (nrProductii > 0 && productii != nullptr)

for (int i = 0; i < nrProductii; i++)

 {

if (productii[i].getViz() > viz)

viz = productii[i].getViz();

return viz;

Apel: cout << " Cea mai vizionata productie: " << endl;

float x = (double)s3;

cout << x << endl;

// Sa se exemplifice utilizarea mecanismului TRY-CATCH pentru a gestiona modificarea

valorii unui atribut pentru care a fost implementata metoda setter. Metoda setter
trebuie sa gestioneze o exceptie specifica aplicatiei pentru date
invalide.Utilizatorul este avertizat daca introduce date invalide de la consola avand
posibilitatea sa le reintroduca.

void setNumeFacultate(const char* numeFacultateNou) {

if (strlen(numeFacultateNou) > 2) {

this->numeFacultate = new char[strlen(numeFacultateNou) + 1];

strcpy(this->numeFacultate, numeFacultateNou);

else { throw Exceptie("Facultate invalida!"); }

Apel: try {

d2.setNumeFacultate("A");

catch(Exceptie e){

cout << e.mesaj << endl;

}
//OPERATOR [] PENTRU LOCALIZAREA UNUI PRODUS DIN COS

Produs operator[](int i) {
if (i >= 0 && i<this->nrProduse) {
return this->produse[i];
}
else {
throw new exception("Index gresit");
}
}

Apel: cout << "----------------COS C3: " << endl;

Produs vect2[5] = { p1,p2,p3,p4,p5 };
Cos c3("FOARTE MARE", 5, vect2);
cout << c3 << endl;

cout << "PRODUSUL ASOCIAT INDEXULUI 2 ESTE: " <<c3[2] << endl;

//OPERATOR += SI -= PENTRU ADAUGARE/SCOATERE OBIECT DIN COS, FOLOSIND OPERATOR []

PENTRU IDENTIFICARE

Cos& operator+=(Produs produsNou) {

Produs* vn = new Produs[nrProduse + 1];
for (int i = 0; i < this->nrProduse; i++) {
vn[i] = produse[i];
}
vn[this->nrProduse] = produsNou;
if (this->produse) {
delete[]this->produse;
}
this->produse = vn;
this->nrProduse++;
return *this;
}

Apel: cout << "S-A ADAUGAT UN PRODUS IN COSUL C3:" << endl;
c3 += p6;
cout << c3 << endl;