Overloading: differenze tra le versioni

==Overloading degli operatori==
Prendiamo in considerazione il seguente esempio [[C++]]: una classe che rappresenta i [[numeri complessi]] (sono omesse le implementazioni del file .cpp)
<source lang="Cpp">
<nowiki>
class Complex {
{
private:
double _r;
double _i_r;
double _r_i;
 
public:
Complex(int r, int i);
Complex(float r, float i);
Complex(double r, double i);
Complex(Complex c);
}
</nowikisource>
Vorremmo essere in grado di eseguire sui numeri complessi le stesse operazioni che eseguiamo normalmente sui [[numeri reali]]. Ad esempio, vorremmo poter eseguire il seguente codice:
<source lang="Cpp">
<nowiki>
Complex c,d;
...
if (c < d) ....
....
...
cout << c;
</nowiki>
</source>
Tale codice solleverebbe un errore di [[compilazione]], in quanto il [[compilatore]] non è in grado di valutare da solo se il complesso c è minore di d, né tantomeno di scriverlo a video. La soluzione, adottabile '''solo''' in [[C++]] e [[C sharp|C#]], è quella di definire un opportuno ''sovraccarico'' per gli operatori ''<'' e ''<<''. Per fare ciò è necessario conoscere come il compilatore dei linguaggi C tratta le espressioni con operatore. Esso le traduce con una chiamata a subroutine ''operator?()'', dove al posto di ''?'' va il simbolo dell'operatore. Ecco quindi i prototipi (e un paio di realizzazioni) di una completa famiglia di overloading per gli operatori principali di confronto e output.
NOTA: in una applicazione reale è richiesto l'utilizzo della [[libreria]] Math
<source lang="Cpp">
<nowiki>
//operator<
int operator<(Complex a, Complex b) {
{
return (sqrt(a.r*a.r+a.i*a.i)<sqrt(b.r*b.r+b.i*b.i));
}
int operator<(Complex a, double b) {
 
return (sqrt(a.r*a.r+a.i*a.i)<b);
int operator<(Complex a, double b) {
}
{
int operator<(Complex a, float b);
return (sqrt(a.r*a.r+a.i*a.i)<b);
int operator<(Complex a, int b);
}
int operator<(double a, Complex b);
 
int operator<(float a, Complex b);
int operator<(intComplex a, Complexfloat b);
int operator<(Complex a, floatint b);
int operator<(double a, Complex b);
int operator<(float a, Complex b);
int operator><(floatint a, Complex b);
//operator>
int operator>(Complex a, Complex b) {
{
return (sqrt(a.r*a.r+a.i*a.i)>sqrt(b.r*b.r+b.i*b.i));
}
int operator>(Complex a, double b) {
 
return (sqrt(a.r*a.r+a.i*a.i)>b);
int operator>(Complex a, double b) {
}
{
int operator>(Complex a, float b);
return (sqrt(a.r*a.r+a.i*a.i)>b);
int operator>(Complex a, int b);
}
int operator>(double a, Complex b);
 
int operator>(float a, Complex b);
int operator>(intComplex a, Complexfloat b);
int operator<>(Complex a, int b);
int operator>(Complexdouble a, floatComplex b);
int operator>(Complexfloat a, intComplex b);
int operator>(doubleint a, Complex b);
 
//operator<<
ostream& operator<<(ostream& out, Complex c) {
{
cout << c.r;
if (c.i > 0) cout << "+"c.r;
if cout << (c.i <<> "i";0)
cout << c.r"+";
}
cout << c.i << "i";
</nowiki>
}
</source>
In linguaggio [[Visual Basic]] è possibile simulare il sovraccarico degli operatori implementando l'[[interfaccia]] IComparable.
 
3 252

contributi