Newsgroup: it.comp.lang.c++
Titolo: E' ammesso questo?

Si puo' utilizzare l'operatore = nel costruttore per copia? 
CMyClass::CMyClass( const CMyClass& other )
{
  *this = other;
}
CMyClass& CMyClass::operator=( const CMyClass& other ) 
{
  if ( this != &other )
  {
     // ...
  }
  return *this;
}


Perche' non dovrebbe?
 bye
	av.

 av.
ciao
merlinO
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 
Beh, se parliamo di stile, a me non piace usare gli overload degli 
operatori della classe nell'implementazione delle funzioni membro. Nel tuo 
caso, avrei probabilmente aggiunto un metodo 'assign', che avrei usato sia 
nel copy ctor che nell'operatore assegnamento. (Per altro, la verifica 
dell'identità this-&other non ha senso nel copy ctor.)
Max

...

Forse perche' non e' molto furbo? Il costruttore *inizializza* un
oggetto, mentre l'operatore di assegnamento opera su un oggetto gia'
costruito. Quest'ultimo deve assumere di doversi disfare dei valori
precedenti, che nel caso del costruttore non esistono ancora.
Se consideri che il motivo principale per cui si definiscono
costruttori e operatori di assegnamento e' gestire memoria allocata
dinamicamente, l'approccio presentato qui sopra e' una buona ricetta
per ottenere disastri. Considera:
class C {
  public:
    C();
    C(const C &);
    C & operator=(const C &);
  private:
    int * p;
};
C & C::operator= (const C & arg) {
  if ( this != &arg ) {
    delete p;
    p = arg.p;
  }
}
Cosa succede nel costruttore di copia?
Ciao,
Nicola

 Cosa succede nel costruttore di copia?
Che fai un delete su un p non inizializzato.
Questo comunque e' un caso particolare (facilmente risolvibile
comunque), che non rende illecito l'uso di operator = nei costruttori
*in generale*.
 bye
	av.

 Nicola


 Max


 *in generale*.
Infatti non ho detto che e' illecito. Ho solo detto che e' stupido.
Ciao,
Nicola

 }
L'effetto del tuo esempio e' che viene creato un oggetto locale
temporaneo senza nome all'interno del tuo costruttore, che viene
immediatamente distrutto.
E' equivalente a scrivere
CMyClass::CMyClass( const CMyClass& other )
{
  {
    CMyClass c;
  }
  *this = other;
}
Un approccio popolare da qualche tempo in qua ribalta quello che hai
presentato e prevede di implementare l'operatore di assegnamento
tramite il costruttore di copia:
CMyClass & CMyClass::operator = ( const CMyClass& other )
{
  CMyClass c(other);
  swap(c);
}
Dove swap e' una funzione membro che scambia membro a membro il
contenuto dell'argomento con quello dell'oggetto corrente. Questa
implementazione puo' non essere particolarmente efficente, ma ha il
pregio di garantire che se nel corso della copia viene lanciata
un'eccezione l'oggetto corrente non viene modificato (questo a patto
che swap non lanci eccezioni, ma questa e' una condizione che e'
sempre possibile rispettare).
Ciao,
Nicola

 E' equivalente a scrivere
[...]
Ti ringrazio per la spiegazione, sei stato chiarissimo. Effettivamente avevo
provato a fare una cosa del genere e non ha ovviamente funzionato, ma non
capivo il perche'.
Purtroppo ho sempre avuto troppo poco tempo per allontanarmi da quello che
sembra funzionare subito e analizzare con piu' attenzione certe logiche.
