[C++] ridefinizione degli operatori

[leon84]

Class C {
C (doube rI=0, double iI=0) : r(rI), i(iI) {}
public:
friend C operator + (const C a, const C b) { return C(a.r+b.r,a.i+b.i);};

private:
double r,i;
}

void main()
{
C c1(3.,5.);
C c2(1.,2.);
c1 = c2 +1. ;
c1 = 1. +c2 ;
}



Il commento del libro :

c1 = c2+1. ; //OK se la funzione "+" è membro oppure ordinaria
c1 = 1. +c2 ; //OK solo se la funzione "+" è ordinaria


Non l'ho capita mi spiegate ?

Prova a interpretare :

il compilatore si trova dinanzi all'operatore "+" e sa che uno degli operandi è di tipo "C", classe che ha ridefinito l'operatore +. Si va quindi a guardare la funzione "+" ridefinita e si accorge che prende 2 parametri visto che si tratta di un operatore binario. Allora mi chiedo com'è possibile che usi quella funzione se gli operandi sono di tipo diverso ? Cioè uno di tipo C e l'altro di tipo double ? Probabilmente, ma questo lo penso io, siccome le operazioni sono definite su tipi uguali assume che il valore 1. possa essere trasformato nel tipo C invocando il costruttore di C. Dico bene ?

Ma in ogni caso non capisco il perché di quell'ok solo se la funzione è ordinaria.
Mi date una mano a capire ?

[leon84]

up

[marco.r]

Ma in ogni caso non capisco il perché di quell'ok solo se la funzione è ordinaria.
Mi date una mano a capire ?

Quando il compilatore deve scegliere che funzione/metodo usare, guarda il tipo degli elementi coinvolti. Se ne trova una che fa al caso bene, altrimenti cerca di vedere se puo' convertire gli argomenti in modo opportuno.
Nel tuo caso, quando fai c2 + 1. si accorge che puo' convertire 1. in un oggetto ti tipo C, per cui trasforma la tua chiamata in

operator + ( c2, C(1.) )

Similmente, se definisci la somma come metodo e non funzione, la tua chiamata viene convertita in

c2.operator+( C(1.) )

La cosa pero' non funziona quando io definisco un metodo e scrivo 1. + c1.
Questo perche'il compilatore quando fa il controllo sui metodi verifica solo la possibilita' di conversione per gli argomenti del metodo, non per l'oggetto cui il metodo appartiene.

La cosa e' piu' chiara se invece di un operatore pensi ad un metodo tradizionale...

se io ho le due classi

class F
{
public:
F(const G&);
void foo( int );
};

class G
{
public:
};


E scrivo

G g;
g.foo();

NON mi aspetto che il compilatore mi converta g in un tipo F e poi mi chiami F::foo()... e d'altra parte e' proprio quello che accadrebbe se venisse convertito 1. in C in 1. + c1: se + e' metodo, scrivere c1+c2 e come scrivere
c1.add(c2);
Spero di aver chiarito.

[leon84]

No. Purtroppo non ho capito. Prima che qualcuno rispondesse io mi sono divertito col compilatore Dev C++ e utilizzando il seguente codice :


#include <iostream.h>
#include <stdlib.h>

class C {

private:
int a,b;
public:
C (int x=0, int y=0) : a(x),b(y) {} ;
friend C operator + (C c1, C c2);
void stampa();
};

C operator + (C c1,C c2)
{
return C(c1.a+c2.a,c1.b+c2.b);
};

void C::stampa()
{
cout << a << " " << b ;

};


int main()
{
C c1(3,3);
C c2(5,5);
C somma ;
somma = 2 + c1 ;
somma.stampa();
system("pause");
return 0;

};



Ho scoperto che "2+c1" oppure "c1+2" mi produce lo stesso effetto. Perché ? perché una funzione friend non appartiene alla classe? E' questa la spiegazione ? Se si non ancora capito bene il concetto allora

[marco.r]

No. Purtroppo non ho capito. Prima che qualcuno rispondesse io mi sono divertito col compilatore Dev C++ e utilizzando il seguente codice :


#include <iostream.h>
#include <stdlib.h>

class C {

private:
int a,b;
public:
C (int x=0, int y=0) : a(x),b(y) {} ;
friend C operator + (C c1, C c2);
void stampa();
};

C operator + (C c1,C c2)
{
return C(c1.a+c2.a,c1.b+c2.b);
};

void C::stampa()
{
cout << a << " " << b ;

};


int main()
{
C c1(3,3);
C c2(5,5);
C somma ;
somma = 2 + c1 ;
somma.stampa();
system("pause");
return 0;

};



Ho scoperto che "2+c1" oppure "c1+2" mi produce lo stesso effetto. Perché ? perché una funzione friend non appartiene alla classe? E' questa la spiegazione ? Se si non ancora capito bene il concetto allora

Il fatto che sia friend non importa, e' il fatto che e' una funzione.
Cerchero' di essere piu' sintetico:
Ripartiamo da metodi/funzione classici:

class C
{
C( float f );
void method( C c2 );
friend void function( C c1, C c2);
};
void function( C c1, C c2);

Quando chiamo function( c1, 1.0) o function( 1.0, c2 ), visto che non esiste la funzione con quei tipi, il compilatore prova a vedere se, usando operatori di conversione o costruttori disponibili, sia possile arrivare alla funzione che hai definito tu, ovvero che prende due istanze di tipo C. Vede che ci riesce in entrambi i casi, perche' puo' trasformare la funzione in
function( c1, C(1.0) ) o function( C(1.0), c2 ), ovvero convertendo implicitamente un float in un tipo C, grazie al costruttore che hai definito tu. Quando tu invece chiami il metodo method, scrivi qualcosa del tipo c1.method(1.0), in questo caso il compilatore prova a vedere se riesce a convertire 1.0 in un C, in modo da poter usare il metodo che hai definito tu, trasformando la tua chiamata in c1.method( C(1.0) ).
Quel che pero' il compilatore non fa e' provare a vedere se puo' convertire c1 in un altro oggetto, sul quale poi invocare method.
Fin qui e' chiaro ?
Gli operatori sono la stessa cosa, ovvero se tu l'operatore lo definisci come funzione, si comporta nel primo caso, ovvero viene fatta la prova di conversione di entrambi gli argomenti, se tu invece lo definisci come metodo, si comporta come nel secondo caso, ovvero viene tentata la conversione del solo secondo argomento.
Sarebbe piu' preciso dire che nel secondo caso hai un solo argomento della chiamata, quello a destra del +, in quanto il primo in realta' e' l'oggetto sul quale invochi il metodo (e quello non viene mai convertito).
Spero di essere stato piu' preciso ora, altrimenti fammi sapere quali cose non ti sono chiare.

[leon84]

Ah si ... capito ... per fortuna. Grazie mille