[C++] Caso di overload degli operatori

[gygabyte017]

Ho scritto questo codice per fare un po' di pratica con gli operatori, ed ho scoperto una cosa strana:

#include <iostream>

using namespace std;

class Zn
{
    private:
        unsigned int _n;
        int _val;
        int _mod(int x);
    public:
        Zn(unsigned int n){ _n = n; }

        Zn operator =(Zn b);
        Zn operator =(int x);
        Zn operator +(Zn b);
        //Zn operator -(Zn b;)

        void print(){ cout << _val<< "\n" ; }
};

int Zn::_mod(int x)
{
    if (x < 0)
        return _n - ((-x) % _n);
    else
        return x % _n;
}

Zn Zn::operator =(Zn b)
{
    cout << "Chiamato Zn = Zn\n";
    _val = _mod(b._val);
    return *this;
}

Zn Zn::operator =(int x)
{
    cout << "Chiamato Zn = Int\n";
    _val = _mod(x);
    return *this;
}

Zn Zn::operator +(Zn b)
{
    cout << "Chiamato Zn + Zn\n";
    Zn temp(_n);
    temp = _mod(_val + b._val);
    return temp;
}

int main()
{
    Zn a(5), b(5), c(5);

    a = 2; cout << "STOP 1!\n";
    c = a + 4; cout << "STOP 2!\n";
    a.print(); c.print();

    return 0;
}

lo compila correttamente e funziona anche.

Ora, io ho ridefinito l' = tra classe e classe, e tra classe e int, e il + tra classe e classe.
Nel main vado a fare con c = a + 4, classe + int, ma classe + int non è definita! Come fa a "indovinare" cosa deve fare?!?!?!!?

[KrOW]

Ciao ... La cosa è abbastanza semplice ... Quando in una classe viene definito un costruttore che prende un solo parametro, si crea automaticamente anche una conversione "automatica" tra il tipo del parametro e la classe ad esempio:

#include<iostream>
using namespace std;
class A
{
public:
	A( int int_par ) : a(int_par){}
	int a;
	A operator+ ( const A& right ) const
	{
		cout << "Richiamato A + A" << endl;
		return A(a + right.a);
		// oppure "return a+right.a;"
	}
};

int main()
{
A ob1(1), ob2(2);
cout << "** Somma A + A" << endl;
A obSum = ob1 + ob2;
cout << "** Somma A + int" << endl;
obSum = obSum + 4;
cout << "obSum = " << obSum.a << endl;
return 0;
}

Questo codice funzionante (almeno spero) è simile al tuo ... Se guardi la 5a linea del codice nel main, puoi vedere lo stesso comportamento che ti ha incuriosito (anche nella parte commentata della definizione dell' operatore overloaded) ... Questo perchè (come già detto) si viene a creare una conversione automatica (ove bisogno e a meno che non definita) tra il tipo del parametro (int in questo caso) e il tipo della classe (A) ..Insomma viene richiamato "di nascosto" il costruttore di A con il parametro int (4) per creare un' oggetto temporaneo il quale viene utilizzato come argomento per l' operatore + ... Spero di averti illuminato e non confuso di più ...

[gygabyte017]

Perfetto grazie tutto chiaro, solo 2 domande:
1) Però perché "int + class" non lo sa fare (invece di "class + int") ?
2) Facendo questa chiamata nascosta, non si spreca memoria?

Anzi già che ci sto ti chiedo un'altra cosa sugli operatori che mi fa preoccupare:

Leggendo un libro sul c++, ho letto di fare molta attenzione riguardo al costruttore per copia, perché visto che quello di default copia bit a bit, se uso puntatori nella classe rischio di andare a condividere lo stesso membro tra più classi se uso l'=. Questo fatto mi ha fatto venire la paranoia e non so mai bene cosa fare per fare le cose fatte bene...

Ad esempio se ho la classe C, e C1, C2, C3 tre variabili di quella classe, se io scrivo:
C3 = C1 + C2
allora, viene chiamato il + di C1 e viene passato C2, il + fa il suo lavoro e crea un NUOVO oggetto che chiamiamo T1; Poi viene chiamato il costruttore per copia (o l'operator = ?!?) di C3, gli viene passato T1, e si crea un nuovo oggetto T2, e T1 muore. Infine T2 viene copiato bit a bit in C3, e T2 muore.

Ora, non sono per niente sicuro di quello che ho detto (perdonami sto studiando ora), ma chi viene chiamato in quel codice? il costruttore per copia o l'=?
E inoltre possibile che per una semplice assegnazione vengono create ben 2 classi temporanee? Non è uno spreco indecente di memoria? Se facessi qualche espressione composita tipo (C1 + C2) + (C3 + C4) vengono create tantissime variabili temporanee?!

Inoltre c'è differenza tra fare:
C C1; C C2; C C3; C3 = C1 + C2;
e
C C1; C C2; C C3 = C1 + C2;
??? quegli uguali che fanno???


Scusami per le troppe domande, ma sono molto confuso su questa cosa!
Ti ringrazio in anticipo

[shodan]

E inoltre possibile che per una semplice assegnazione vengono create ben 2 classi temporanee? Non è uno spreco indecente di memoria? Se facessi qualche espressione composita tipo (C1 + C2) + (C3 + C4) vengono create tantissime variabili temporanee?!

Si. E appunto per evitare questo spreco che in C++0x è stata introdotta la "move semantics".

Inoltre c'è differenza tra fare:
C C1; C C2; C C3; C3 = C1 + C2;
e
C C1; C C2; C C3 = C1 + C2;
??? quegli uguali che fanno???

nel primo caso è invocato operator=, nel secondo il costruttore di copia.

[KrOW]

1) Però perché "int + class" non lo sa fare (invece di "class + int") ?

In linea generale il compilatore cerca sempre di convertire il secondo parametro con il tipo del primo ... Siccome la conversione da int a class è definita (seppur in maniera automatica) in fase di compilazione non si hanno errori di sorta, diversamente dal secondo caso (la cui conversione non avviene in automatico ma deve essere definita dal programmatore)

Leggendo un libro sul c++, ho letto di fare molta attenzione riguardo al costruttore per copia, perché visto che quello di default copia bit a bit, se uso puntatori nella classe rischio di andare a condividere lo stesso membro tra più classi se uso l'=. Questo fatto mi ha fatto venire la paranoia e non so mai bene cosa fare per fare le cose fatte bene...

In generale non bisogna mai lasciare il costruttore di copia di default quando si hanno puntatori come attributi (anche se delle volte potrebbe essere voluto) soprattutto quando si utilizzano i puntatori per allocare memoria

Ad esempio se ho la classe C, e C1, C2, C3 tre variabili di quella classe, se io scrivo: C3 = C1 + C2 allora, viene chiamato il + di C1 e viene passato C2, il + fa il suo lavoro e crea un NUOVO oggetto che chiamiamo T1; Poi viene chiamato il costruttore per copia (o l'operator = ?!?) di C3, gli viene passato T1, e si crea un nuovo oggetto T2, e T1 muore. Infine T2 viene copiato bit a bit in C3, e T2 muore.

In realtà verrebbe creato un oggetto temporaneo (T1) che poi verrebbe passato all' operator= per riferimento (quindi niente T2) e poi T1 verrebbe distrutto

Ora, non sono per niente sicuro di quello che ho detto (perdonami sto studiando ora), ma chi viene chiamato in quel codice? il costruttore per copia o l'=?

All' inizio è molto facile confondersi ... Comunque tieni bene a mente che quando un oggetto viene definito (quindi costruito) e copiato allo stesso tempo, viene richiamato il costruttore di copia (non a caso è chiamato costruttore). Se invece un oggetto viene copiato ma dopo la sua definizione, viene richiamato l' operator=