[c++] overloading operatori

[mistergks]

Ho capito l importanza e lo scopo della ridefinizione degli operatori per gli oggetti.

Quello che non capisco è come farlo.

Ad esempio l'operatore + ha un solo parametro.
Non servirebbero due parametri?
Tipo se io volessi fare l'operazione a+b... Non è come richiamare la funzione operator+(a,b) ?

[[Kendall]]

Ho capito l importanza e lo scopo della ridefinizione degli operatori per gli oggetti.

Quello che non capisco è come farlo.

Ad esempio l'operatore + ha un solo parametro.
Non servirebbero due parametri?
Tipo se io volessi fare l'operazione a+b... Non è come richiamare la funzione operator+(a,b) ?

L'operazione a+b equivale al richiamare la funzione a.operator+(b).
Quando fai l'overload dell'operatore di somma devi usare l'istanza stessa come primo degli addendi, e il parametro passato alla funzione come secondo.

[vendettaaaaa]

Ho capito l importanza e lo scopo della ridefinizione degli operatori per gli oggetti.

Quello che non capisco è come farlo.

Ad esempio l'operatore + ha un solo parametro.
Non servirebbero due parametri?
Tipo se io volessi fare l'operazione a+b... Non è come richiamare la funzione operator+(a,b) ?
Fai come t'ha detto Kendall, oppure:


class A
{
private:
int b;
friend int operator+(const A& left, const A& right);
};

// FUORI dalla classe
inline
int operator+(const A& left, const A& right)
{
// Questo operatore è stato dichiarato friend così può accedere al membro private degli oggetti di classe A, cioè b
return left.b + right.b;
}


A quanto ho capito non c'è un metodo migliore...ma non ho investigato molto. Io preferisco i metodi NON membri.

[mistergks]

Quindi posso scegliere se dare uno o due parametri alla funzione operator+ in fase di definizione?

[Tommo]

No, puoi scegliere se avere un parametro (la r-value solo) e metterlo nella classe, oppure averne due, e metterlo fuori.
In entrambi i modi, l'operatore si usa allo stesso modo.

Io preferisco i metodi membri perche' e' piu' "comodo" accedere agli internals e perche' sono piu' facili da ritrovare, ma concettualmente gli operatori esterni sarebbero piu' puliti perche' sono funzioni pure.

[mistergks]

No, puoi scegliere se avere un parametro (la r-value solo) e metterlo nella classe, oppure averne due, e metterlo fuori.
In entrambi i modi, l'operatore si usa allo stesso modo.

Io preferisco i metodi membri perche' e' piu' "comodo" accedere agli internals e perche' sono piu' facili da ritrovare, ma concettualmente gli operatori esterni sarebbero piu' puliti perche' sono funzioni pure.

Ho capito!
Quindi dichiarando la funzione operator all'esterno come funzione friend non dovrei avere problemi.

Per quanto riguarda gli operatori di input e output vale la stessa cosa vero?

[vendettaaaaa]

Ho capito!
Quindi dichiarando la funzione operator all'esterno come funzione friend non dovrei avere problemi.

Per quanto riguarda gli operatori di input e output vale la stessa cosa vero?
Concettualmente questo modo di fare vale per tutti gli operatori binari.
Con delle eccezioni: l'overload degli operatori << e >> può solo essere fatto definendoli come metodi esterni e friend, in quanto il primo dei 2 parametri che accettano è sempre la ostream/istream (al contrario che nel caso degli altri operatori binari che, se dichiarati come membri, danno per scontato che *this sia il left hand):


class A
{
int b;
friend ostream& operator<<(ostream& os, const A& a);
};

ostream& operator<<(ostream& os, const A& a)
{
os << a.b;
return os;
}

[mistergks]

Non ti seguo.. L operatore > ha come parametro ostream/istream??

[vendettaaaaa]

Non ti seguo.. L operatore > ha come parametro ostream/istream??
cout << "ciao";
cout cos'è? Un oggetto (globale, sempre disponibile nel namespace std) di classe ostream (o una sua derivata).

"ciao" cos'è? Un const char*.

Quindi qui cosa succede? Che c'è un operatore binario, <<, che prende a sinistra (primo parametro) un oggetto di classe ostream, a destra un const char* (e ci sono un sacco di overload, che prendono a dx un int, un double, un bool... eccetera).

ostream& operator<<(ostream& os, const char* s);

Se vuoi fare l'overload di operator<< quindi ricordati che il primo dei due parametri dev'essere ostream& os, e così il return type, mentre il 2° parametro un oggetto della tua classe.

operator>> serve per acquisire dati, quindi non lavora con ostream bensì con istream...

istream& operator>>(istream& is, const MyClass& item);