§14. Supraîncărcarea operatorilor

Un tip de date este caracterizat nu doar prin domeniul de valori admisibile, dar şi printr-o serie de operaţii care sunt permise asupra lor, numită funcţionalitatea tipului. În cadrul tipurilor predefinite operaţiile sunt exprimate prin operatori, ceea ce nu este valabil pentru tipurile abstracte de date create de programator. În cadrul tipurilor abstracte de date funcţionalitatea este exprimată prin funcţii membre. Însă expresiile scrise în bază de operatori sunt mai simple şi pot fi mai uşor citite, comparativ cu cele scrise în bază de funcţii. De exemplu, expresia:

C+A*B

exprimată prin operatori este mult mai simplă decât expresia:

C.Adunare(A.Produs(B))

exprimată prin funcţii.

Pentru a extinde posibilitatea de utilizare a unui operator în contextul unor obiecte, este necesar de a realiza procesul de supraîncărcare a operatorului dat în cadrul clasei. O supraîncărcare a unui operator în interiorul unei clase înseamnă a-i da un anumit sens operatorului vizat în cadrul clasei date, păstrându-i sensul sau semnificaţia pentru celelalte tipuri de date.

Supraîncărcarea operatorilor este legată de supraîncărcarea funcţiilor, deoarece procedeul de supraîncărcare a operatorilor se realizează în baza funcţiilor.

Supraîncărcarea operatorilor se face prin următoarele două metode:

• supraîncărcarea ca funcţii membre;

• supraîncărcarea ca funcţii prietene.

Unii operatori pot fi supraîncărcaţi prin ambele metode, iar alţii pot fi supraîncărcaţi doar printr-o singură metodă. De exemplu, operatorul aditiv + poate fi supraîncărcat prin ambele metode. Pe când operatorul indice [] poate fi supraîncărcat doar prin metoda funcţiilor membre, iar operatorul de extragere >> poate fi supraîncărcat doar prin metoda funcţiilor prietene.

În procesul de supraîncărcare a operatorilor sunt respectate o serie de restricţii:

• supraîncărcarea nu poate schimba aritatea operatorului, adică dacă operatorul este unar sau binar, atunci după supraîncărcare el va fi respectiv tot unar sau binar;

• supraîncărcarea nu poate schimba precedenţa operatorilor;

• funcţiile prin intermediul cărora se face supraîncărcarea nu pot avea valori implicite.

Pot fi supraîncărcaţi toţi operatorii cu excepţia următorilor patru:

• ?: operatorul condiţional ternar;

• :: operatorul rezoluţiei;

• . operatorul punct de acces la membrii clasei;

• .* operatorul de acces la membrii clasei prin intermediul pointerilor la membrii clasei.

În continuare va fi caracterizat procedeul de supraîncărcare a operatorilor prin metoda funcţiilor membre. Particularitatea principală este faptul că funcţia membră, prin intermediul căreia va fi efectuată supraîncărcarea unui operator, va fi o funcţie cu un nume special format prin utilizarea cuvântului-cheie operator. În rest este o funcţie membră obişnuită şi deci va fi descrisă şi definită ca şi oricare altă funcţie membră a clasei:

class nume_cl //Ø–orice operator supraincarcabil

{

. . .

tip_r operator Ø (lista_pf);

. . .

}

. . .

tip_r nume_cl :: operator Ø (lista_pf)

{

//instructiuni

}

. . .

unde Ø este numele operatorului supraîncărcat, iar lista_pf reprezintă lista parametrilor fictivi ai funcţiei. Lista parametrilor fictivi conţine, de regulă, un parametru pentru operatorii binari sau este vidă pentru operatori unari. Acest moment se datorează faptului că orice funcţie membră ne-statică are acces la pointerul intern this. Astfel, pentru un operator binar primul operand este obiectul care apelează funcţia membru, iar al doilea operand este reprezentat de parametrul care substituie parametrul fictiv. Pentru un operator unar operandul este obiectul care apelează funcţia membru. Prin pointerul this există acces anume la obiectul care apelează funcţia membru.

Exemplu. De alcătuit un program în care este implementată clasa complex, definind operatorii caracteristici numerelor complexe prin supraîncărcarea operatorilor prin metoda funcţiilor membre.

#include <iostream.h>

#include <iomanip.h>

class complex

{

float r,i;

public:

complex (float r1=0, float i1=0)

{ r=r1; i=i1; }

complex operator + (complex);

complex operator - (complex);

complex operator * (complex);

complex operator / (complex);

void afisare ();

};

complex complex :: operator + (complex c)

{

complex s;

s.r = r + c.r;

s.i = i + c.i;

return s;

}

complex complex :: operator - (complex c)

{

complex s;

s.r = r - c.r;

s.i = i - c.i;

return s;

}

complex complex :: operator * (complex c)

{

complex p;

p.r = r*c.r – i*c.i;

p.i = r*c.i + i*c.r;

return p;

}

complex complex :: operator / (complex c)

{

complex r;

r.r = (c.r*r + c.i*i)/(c.r*c.r + c.i*c.i);

r.i = (c.r*i – r*c.i)/(c.r*c.r + c.i*c.i);

return r ;

}

void complex :: afisare ()

{

cout << r << setiosflafs(ios :: showpos)

<< i << "i"

<< resetiosflags (ios :: showpos);

}

void main ()

{

complex c1(7, -2.3), c2(3, 4.9);

complex s, d, i, c;

s = c1. operator + (c2);

s = c1 + c2;

d = c1 - c2;

i = c1 * c2;

c = c1 / c2;

s.afisare ();

d.afisare ();

i.afisare ();

c.afisare ();

}