3. Operatorul indice

Supraîncărcarea operatorului indice ([]) este realizată atunci, când se doreşte accesul la datele ce formează conţinutul unui obiect după modelul accesului la elementele unui tablou, adică:

nume_ob[indice]

Operatorul indice poate fi supraîncărcat doar prin metoda funcţiilor membre. Acest operator este unul binar, de aceea lista parametrilor fictivi este formată dintr-un singur parametru, şi anume indicele. Trebuie de ţinut cont de faptul că operatorul indice poate fi utilizat în expresii atât în partea stângă, cât şi în partea dreaptă a operatorului de atribuire. Supraîncărcarea operatorului este realizată printr-o funcţie, iar o funcţie poate fi plasată în partea stângă a operatorului de atribuire doar când returnează o valoare de tip referinţă. De aceea funcţia care realizează supraîncărcarea operatorului indice va trebui să returneze o valoare de tip referinţă. Pentru descrierea funcţiei va fi utilizat în caz general următorul prototip:

class nume_cl

{

. . .

tipr & operator [](tip indice)

. . .

}

Tipul utilizat la descrierea parametrului indice este deseori tipul int, dar nu sunt excluse în descriere şi alte tipuri de date, obţinând astfel un indice generalizat. Din ideea că tipul parametrului indice poate fi descris prin diferite tipuri de date rezultă că o clasă poate avea mai multe supraîncărcări ale operatorului [].

Exemplu. De alcătuit un program în care este implementată clasa vector, realizând supraîncărcarea operatorului indice pentru accesul la componentele vectorului.

#include<iostream.h>

#include<conio.h>

class vector

{

int dim;

float *componente;

public:

vector (int d)

{

componente=new float[d];

if(componente) dim=d; else dim=0;

for(int i=0; i<dim; i++) componente[i]=0;

}

~vector ()

{

delete [] componente;

}

float & operator[] (int ind)

{

return componente[ind];

}

friend ostream & operator <<(ostream & fluxIes, vector v);

};

//------

ostream & operator <<(ostream &fluxIes, vector v)

{

fluxIes<<”(”;

for(int i=0; i<v.dim-1; i++) fluxIes<<v.componente[i]<<”,”;

if(v.dim>=1) fluxIes<<v.componente[i];

fluxIes<<”)”;

return fluxIes;

}

//--------

void main()

{

vector v1(3), v2(7);

v1[0]=3.4;

v1[1]=2.1;

v1[2]=-3.2;

v2[0]=v1[0]+v1[1];

v2[2]=v1[0]-5.6;

v2[3]=v2[2]+v1[1];

cout << v1 << endl << v2 << endl;

getch();

}

4. Operatorul funcţie

Supraîncărcarea operatorului funcţie (()) este realizată atunci, când se doreşte accesul la conţinutul unui obiect, efectuând anumite prelucrări sau transformări. Accesul la conţinutul obiectului este efectuat după modelul apelării unei funcţii, adică:

nume_ob(lista_parametri_reali)

Operatorul funcţie poate fi supraîncărcat doar prin metoda funcţiilor membre. Acest operator este unul binar, însă lista parametrilor fictivi poate fi formată, de la caz la caz, dintr-un număr diferit de parametri tot aşa precum şi lista de parametri a diferitelor funcţii poate consta din număr diferit de parametri. Din acest fapt rezultă că o clasă poate avea mai multe supraîncărcări ale operatorului (), deosebindu-se după numărul de parametri sau tipurile parametrilor fictivi. În contextul clasei complex s-ar putea realiza două variante de supraîncărcare a operatorului funcţie cu următoarele sensuri:

• una ar calcula modulul numărului complex;

• alta ar modifica partea reală şi partea imaginară a numărului complex.

Pentru aceasta în clasa complex vor fi introduse următoarele prototipuri de funcţii:

class complex

{

. . .

float operator ()();

complex operator ()(float r, float i);

. . .

};

Funcţiile membre corespunzătoare vor fi implementate după cum urmează:

• funcţia de calculare a modulului:

float complex :: operator ()()

{

return sqrt(r*r+i*i);

}

• funcţia de modificare a părţii reale şi a părţii imaginare a numărului:

complex complex :: operator ()(float r, float i)

{

this->r = r;

this->i = i;

return *this;

}

O aplicare a acestor operatori poate fi următoarea:

. . .

void main()

{

complex c(1.3,-2.5);

cout << c() << endl; // modulul numar complex

c(3.7,2.8); //schimbare numar

}