Supraîncărcare funcţii şi operatori

Polimorfism – același nume ascunde transformări diferite:

int suma( int i1, int i2) ; // suma de intregi
double** suma(double **m1, double ** m2, int m, int n); // suma de
matrici
double suma(Pers &p1, Pers &p2); // suma de persoane => cumul
salarii

Overloading (static)
– rezolvat din compilare/linkeditare, prin completari la numele
funcțiilor
Overriding (dinamic)
– rezolvat la executie prin vector (tabela) de pointeri la funcții;
pointerii se
incarcă la momentul execuției

Overloading
 treaba compilatorului; cum? decorare nume; chiar când avem o
singura funcţie, deoarece nu stim daca la linkeditare nu apar altele
 Supraîncărcare funcţii şi operatori

Conflict: conversii de adaptare la prototip  posibilitatea supraîncărcării!

Solutie automată: etapizarea identificării funcției de apelat.

 identificarea conform prototipului funcţiei (fără conversii);

 dacă nu există, se aplică conversii nedegradante (fără pierderi de informaţii):
char, short, int, respectiv float, double;
 se continuă cu operarea conversiilor degradante (cu pierderi de informaţii): de la
numeric la numeric, indiferent de tip; între pointeri de orice tip şi void; de la o
constantă întreagă către pointer sau de la pointer de clasă derivată la pointer de
clasă de bază;
 într-o ultimă etapă, procesul de identificare a funcţiei de apelat continuă prin
aplicarea eventualelor conversii introduse de utilizator, prin supraîncărcarea
operatorului cast.

• căutarea se opreşte când o singură funcţie corespunde criteriilor de selecţie;

• dacă după conversii, corespund mai multe funcţii => eroare de ambiguitate.
• nicio versiune selectata pana la sfarsit => eroare la linkeditare (simbol
nedefinit).
 Supraîncărcare operator++

Pre / post fixare in raport de:

• alt operator: x[++i]=10; v = --i; // momentul atribuirii
• o instructiune: while (i--) { …. } // momentul testului
• un apel de functie: f(++i); // momentul punerii pe stiva

Observatie: se aplica si la apel de constructor pentru initializare:

Pers() : marca(++nrPers) { } // la transfer de sarcini

Supraincarcare prin funcție independentă:

operator++(p1) echivalent cu ++p1; // forma prefixata

operator++(p1, 1) echivalent cu p1++; // forma postfixata

Supraincarcare prin funcție membră:

p1.operator++(); echivalent cu ++p1; // forma prefixata

p1.operator++(1); echivalent cu p1++; // forma postfixata
 Supraîncărcare operator++ prin functie independenta
class Pers
{
private: int varsta=25;
friend const Pers & operator++(Pers &a) // prefixat
{ a.varsta++; return a; }
friend const Pers operator++(Pers &a, int) // postfixat
{
Pers aux = a; // conservarea starii initiale
a.varsta++; return aux; // return prin valoare
}
friend ostream& operator<<(ostream& os, Pers &a)
{ os<< a.varsta; return os; }
};
void main()
{
Pers p1, p2;
p2 = ++p1; cout << p2 << " "; // 26
p2 = p1++; cout << p2 << " "; // 26
cout << p1; // 27
operator++(p1); operator++(p1,1); cout << p1;
}
 Supraîncărcare operator++ prin functie membra
class Pers
{
private: int varsta=25;
public:
const Pers & operator++() // prefixat
{ varsta++;return *this;}
const Pers operator++(int) // postfixat
{
Pers aux = *this; // conservarea starii initiale
varsta++; return aux;
}
friend ostream& operator<<(ostream& os, Pers &a)
{ os<< a.varsta; return os; }
};
void main()
{
Pers p1,p2;
p2 = ++p1; cout << p2 << " "; // 26
p2 = p1++; cout << p2 << " "; // 26
cout << p1 << " "; // 27
p1.operator++(1); p1.operator++(); cout << p1;
}
 Supraîncărcare operator++ : discutii

De ce la postfixat returneaza valoare ?

Daca ar returna referinta (sau pointer) ar trebui ca aux sa rămâna
alocat!

static Pers aux = p; // initializare de static! O singura data!

static Pers aux; aux = p; // atribuire
Probleme:
- ce ar insemna p++++ ?
- pe cine incrementeaza a doua oara ?
- referinta intoarsa de primul apel este a lui aux (obiect
neincrementat)
- lucru cu fire de executie ? Cine a scris ultima data in aux ?

Pers & aux = *new Pers(); // alocarea cu new rezolva ?

Probleme:
- alocă la fiecare intrare in functie!
- cine dezalocă si cand ?