Laborator 10

Supraîncărcarea operatorilor (partea I)

Probleme

EXEMPLE:

EXEMPLUL 1:
Trecerea de la o funcŃie membră obişnuită la un operator supraîncărcat. Un operator
supraîncărcat poate fi definit ca şi o funcŃie membră specială a unei clase.

Rezolvare (cod incomplet):

class matrice
{
//…
public:
matrice AdunMatrice(matrice&);
matrice operator + (matrice&);
//…
};

//...
// Diferenta dintre cele doua metode este comoditatea apelului
// in cazul celei de a doua:
//...

matrice a, b, c;
//...
c=a.AdunMatrice(b); //corect, dar incomod
c=a.operator+(b); //corect, dar incomod
c=a+b; //prin supraincarcare, mult mai comod si mai natural
//...

EXEMPLUL 2:
Supraîncărcarea unui operator prin funcŃii membre (adunarea a doi vectori cu originea în
punctul (0,0) şi vârful în punctul de coordonate date).

Rezolvare (cod incomplet):

class vector
{
double x, y;
public:
vector operator + (vector);
};

//Metodele clasei vector

vector vector::operator + (vector a)
{ vector p;
p.x=x + a.x; //echivalent cu p.x=this->x+a.x;
p.y=y + a.y; //echivalent cu p.y=this->y+a.y;
return p;
}

1
void main()
{ vector A(1.1, 2.2); A.afisare();
vector B(-5.5, -6.6); B.afisare();
vector C;
C=A+B; C.afisare();
C=A+B+C; C.afisare();
}

EXEMPLUL 3:
Supraîncărcarea unui operator prin funcŃii prietene (adunarea a doi vectori cu originea în
punctul (0,0) şi vârful în punctul de coordonate date).

Rezolvare (cod incomplet):

class vector {
double x, y;
public:
// . . . . . .
friend vector operator + (vector, vector);
};

//Metodele clasei vector

vector operator + (vector a, vector b)
{ vector p;
p.x=a.x + b.x;
p.y=a.y + b.y;
return p;
}

void main()
{ vector A(1.1, 2.2); A.afisare();
vector B(-5.5, -6.6); B.afisare();
vector C;
C=A+B; C.afisare();
C=A+B+C; C.afisare();
}

EXEMPLUL 4:
Supraîncărcarea prefixată şi postfixată a operatorului unar de incrementare ++. Se observă că
numărul de parametri, în cazul unui operator unar, este mai mic cu unu decât în cazul
operatorilor binari. Operatorul de incrementare postfixată are un parametru în plus faŃă de
forma prefixată, pentru a permite compilatorul să facă deosebirea între cei doi operatori.

Rezolvare (cod incomplet):

class vector {
int x, y;
public:
// . . .
vector & operator ++ (int ); //forma postfixata
vector & operator++(); //forma prefixata
};

vector & vector::operator ++ (int)

{ vector p=*this; x++; y++; return p; }

vector & vector::operator++()

{ x++; y++; return *this; }

2
void main()
{ vector A(11, 10); vector C=A++; A.afisare( ); C.afisare( );
vector C=++A; A.afisare( ); C.afisare( );
}

EXEMPLUL 5:
Supraîncărcarea operatorilor insertor << şi extractor >>. Deoarece întotdeauna operandul
stâng este de tip istream (cin este obiect predefinit, de tip istream) sau ostream (cout este
obiect predefinit, de tip ostream), şi nu de tipul introdus prin clasă, operatorii << şi >> pot fi
supraîncărcaŃi numai prin funcŃii prietene. Modificatorul const previne modificarea
operandului drept în cazul afişării.

Rezolvare (cod incomplet):

// Prototipurile operatorilor sunt:
friend ostream &operator << (ostream &,const complex&);
//operator afisare complex

friend istream & operator >> (istream &,complex&);

//operator citire complex

// Definitiile functiilor operator:

ostream &operator << (ostream &ecran, const complex &z)
{ ecran<<"("<<z.re;
if (z.im>=0) ecran<<'+';ecran<<z.im<<"*i)"; return ecran; }

istream &operator >> (istream &tastatura, complex &z)

{ tastatura >>z.re>>z.im; return tastatura; }

EXEMPLUL 6:
Supraîncărcarea operatorului de atribuire =. În cazul în care operatorul de atribuire = nu este
supraîncărcat explicit, compilatorul generează implicit unul, care va fi binar, cu ambii
operanzi de acelasi tip şi va copia valorile datelor membre ale operandului drept în datele
membre ale operandului stâng. Operatorul de atribuire implicit este nesatisfăcător în situaŃiile
în care obiectele clasei au ca date membre pointeri, sau în situaŃiile în care memoria este
alocată în mod dinamic.

Rezolvare (cod incomplet):

a. prin funcŃie membru

class complex
{ double re, im;
public:
complex operator = (complex );
};

complex complex::operator = (complex z)

{ re=z.re; im=z.im; return *this;
/* this este pointer catre obiectul curent, a in main */
}

void main()
{ complex a, b;
a = b; // a.operator=(b);
}

3
b. prin funcŃie prietenă
class complex
{ double re,im;
public:
friend complex &operator=(complex&,const complex&);
//functie prietena constanta
};

complex &operator = (complex &z1, const complex &z2)

{ z1.re=z2.re; z1.im=z2.im; return z1;}

void main()
{ complex a, b;
a = b; //a.operator=(b);
}

PROBLEME PROPUSE:

1. RealizaŃi un program C++ complet care să definească clasa vector şi să supraîncarce

operatorii de adunare a doi vectori (+) şi de incrementare prefixată şi postfixată (++), folosind
exemplele 2, 3 şi 4.

2. ModificaŃi programul de la problema 1 de mai sus, astfel încât să se poată realiza citirea şi
afişarea vectorilor, prin supraîncărcarea operatorilor insertor << şi extractor >>, folosind
exemplul 5.

3. ModificaŃi acelaşi program de mai sus, implementând supraîncărcarea operatorului de

atribuire a doi vectori =.

4. ModificaŃi acelaşi program de mai sus, adăugând o funcŃie membru având prototipul float
operator*(vector) ce va da posibilitatea definirii produsului scalar, deci o supraîncărcare
pentru înmulŃire *, după modelul următor:

vector v1, v2;

float prod_scal;
prod_scal=v1*v2;

5. ModificaŃi acelaşi program de mai sus, adăugând o funcŃie membru având prototipul float
operator*(float) ce va da posibilitatea definirii produsului dintre un număr real şi un vector,
după modelul următor:

vector v1, v2;

float h;
v2=v1*h;

Argumentele funcŃiilor de la problemele 4 şi 5 fiind diferite, aceste funcŃii pot fi realizate în

acelaşi program.

Ce se va întâmpla dacă dorim să realizăm operaŃia următoare? v2=h*v1; Cum putem rezolva
această problemă?