14.

Supraîncărcarea funcţiilor şi operatorilor

Supraîncărcarea funcţiilor

Supraîncărcarea funcţiilor este procesul de folosire a aceluiaşi nume pentru două sau mai multe funcţii.
Esenţial este ca fiecare redefinire să folosească sau tipuri diferite sau un număr diferit de parametri.
ATENŢIE: Nu pot fi surpraîncărcate două funcţii care diferă doar prin tipul returnat, cum ar fi exemplul următor:
int funtie(int i);
float functie(int i); //error: nu este suficient ca tipurile returnate să difere.

Supraîncărcarea operatorilor

O funcţie operator defineşte operaţiile specifice pe care le va efectua operatorul supraîncărcat relativ la
clasa în care este destinat să lucreze. Funcţiile operator pot fi sau nu membri ai clasei în care vor opera. Funcţiile
operator care nu sunt de tip membru sunt totuşi, de obicei, funcţii friend ale clasei. Felul în care sunt scrise
funcţiile operator diferă pentru cele de tip membru de cele pentru friend.

#include<iostream>
using namespace std;

class COORDONATA {
int x, y;
public:
COORDONATA(){}
COORDONATA(int i, int j){
x = i;
y = j;
}
void arata() {
cout<<"x="<<x<<" ";
cout<<"y="<<y<<endl;
}
COORDONATA operator+(COORDONATA operand_dreapta) {
COORDONATA operand_temp;
operand_temp.x = x /*operand_stanga*/ + operand_dreapta.x;
operand_temp.y = y /*operand_stanga*/ + operand_dreapta.y;
return operand_temp;
}
COORDONATA operator*(COORDONATA operand_dreapta) {
COORDONATA operand_temp;
operand_temp.x = x /*operand_stanga*/ * operand_dreapta.x;
operand_temp.y = y /*operand_stanga*/ * operand_dreapta.y;
return operand_temp;
}
COORDONATA operator(COORDONATA operand_dreapta) {
COORDONATA operand_temp;
operand_temp.x = x /*operand_stanga*/ operand_dreapta.x;
operand_temp.y = y /*operand_stanga*/ operand_dreapta.y;
return operand_temp;
}
COORDONATA operator-(COORDONATA operand_dreapta) {
COORDONATA operand_temp;
operand_temp.x = x /*operand_stanga*/ - operand_dreapta.x;
operand_temp.y = y /*operand_stanga*/ - operand_dreapta.y;
return operand_temp;
}
/*ATENTIE LA ORDINEA DE ARANJARE A OBIECTELOR:
Urmãtoarea suprascriere a operatorului '-' are sens dar
scade obiectul din stanga din cel din dreapta
COORDONATA operator-(COORDONATA operand_dreapta) {
COORDONATA operand_temp;
operand_temp.x = operand_dreapta.x - x;
operand_temp.y = operand_dreapta.y - y;
 return operand_temp;
}*/
COORDONATA operator=(COORDONATA operand_dreapta) {
x = operand_dreapta.x;
y = operand_dreapta.y;
return *this;
}
COORDONATA operator++() {
x++;
y++;
return *this;
}
};

void main() {
COORDONATA c1(1, 3), c2(2, 6);
(++c1).arata();
(c2 - c1).arata();
(c1 * c2).arata();
(c2 = c1).arata();
}

Operandul-din-stânga este pasat implicit funcţiei operator folosind pointerul this. Operandul-din-dreapta este pasat
în parametrul operand_dreapta.  când există operatori binari supraîncărcaţi, cel care generează apelarea funcţiei
operator este operandu-din-stânga.

RESTRICŢII:
1. nu se poate modifica precedenţa unui operator;
2. nu se poate modifica numărul operanzilor preluaţi de un operator (dar se poate ignora unul);
3. funcţiile operator nu pot avea argumente implicite;
4. următorii operatori nu pot fi supraîncărcaţi: . :: .* ?

Supraîncărcarea operatorilor folosind o funcţie friend

Un prieten nu este membru al clasei, deci nu are un pointer this. De accea, unei funcţii surpaîncărcate de tip
friend operator i se transmit explicit operanzii. Aceasta înseamnă că un prieten care supraîncarcă un operator binar
are doi parametri, iar unul care supraîncarcă un operator unar are un parametru. Când supraîncărcaţi un operator
binar, operandul din stânga este plasat în primul parametru iar cel din dreapta în cel de-al doilea parametru al
funcţiei friend operator.

#include<iostream.h>

class LOC {
int x, y;
public:
LOC() {}
LOC(int i, int j) {
x = i; y = j;
}
void arata() {cout<<x<<" "<<y<<endl;}
LOC operator++() {
x++;
y++;
return *this;
}
friend LOC operator+(LOC operand_stanga, LOC operand_dreapta) {
LOC temp;
temp.x = operand_stanga.x + operand_dreapta.x;
temp.y = operand_stanga.y + operand_dreapta.y;
return temp;
}
};
void main() {
LOC l1(1, 1), l2(2, 2);

(++l1).arata();
}

RESTRICŢII:
1. nu se pot supraîncărca operatorii =, (), [] sau -> folosind funcţii friend;
2. când se supraîncarcă operatorii de incrementare sau decrementare utilizând funcţii friend, trebuie folosit un
parametru de referinţă.

Pentru supraîncărcarea operatorilor de incrementare sau decrementare, trebuie să transmiteţi operandul ca parametru
de referinţă, deoarece funcţiile friend nu au pointeri this. Pentru explicaţii vezi: “Herber Schildt – C++ Manual
Complet, p. 356). Pentru versiunea cu sufix se specifică un al doilea parametru întreg, fictiv:

friend LOC operator++(LOC &op, int a);

#include<iostream>
using namespace std;

class LOC {
int x, y;
public:
LOC() {}
LOC(int i, int j) {x = i; y = j;}
void arata(){cout<<x<<" "<<y<<endl;}
friend LOC operator++(LOC &op, int a){
op.x++;
op.y++;
return op;
}
friend LOC operator--(LOC &op, int a);
};

LOC operator--(LOC &op, int a) {

op.x--;
op.y--;
return op;
}

void main() {
LOC l1(1,1);
l1.arata();
(l1++).arata();
l1.arata();
}