Newsgroup: it.comp.lang.c++
Titolo: operatore di assegnamento

Ciao,
  ho un problema con il codice seguente:
template<typename T>
class A
{
public:
   const T& operator =(const T& value){...};
   ...
};
class B: public A<int>
{
public:
   ...
};
int main()
{
   B p;
   p = 3;
   return 0;
}
Perché il compilatore (MSVC 6.0) da errore dicendo che l'operatore di 
assegnamento non č definito? Non dovrebbe essere ereditato dalla classe A?
Grazie per l'aiuto, Stefano.

 wrote in message
news:chkjh6$3f5$1...@fata.cs.interbusiness.it...

Non e' possibile ereditare un operatore di assegnamento dalla classe base.
Fabio

    const T& operator =(const T& value){...};
Sei sicuro di quel ritorno "const" ?
Non e' che era: 
T & operator=( const T & value );
Dan

 
Anche moficando la signature il problema rimane.
Grazie, Stefano.

 
L'operatore assegnamento definito in A<T> viene *nascosto* dall'operatore
assegnamento implicitamente definito in B. Con un compilatore conforme allo
Standard, per compilare quel codice dovrebbe bastare aggiungere
 
    using A<int>::operator=;
nella definizione di B. Non assicuro perņ che questo funzioni con VC++6. Con
GCC >=3.3 e con il Comeau funziona.
Max

 ...
Potresti aggiungere qui una "fotocopia" dell'operatore che hai in A:
   inline const int& operator =(const int& value)
   {
      return A<int>::operator =(value);
   }
Pragmaticamente dovrebbe funzionare: l'ho compilato persino con un vecchio
VC++ vers. 4. Come performance, credo che una funzione inline che non fa
altro che chiamare un'altra funzione non differisca minimamente dal chiamare
direttamente l'altra funzione.
Dal punto di vista teorico e/o stilistico, non garantisco che sia un'opera
d'arte...
--
Cingar
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

    }
Si cosí funziona ma è proprio quello che vorrei evitare: il mio scopo 
sarebbe di implementare l'operatore di assegnamento solo nella classe 
base tramite delle funzioni virtuali. In pratica cosí:
template<typename T>
class A
{
public:
   const T& operator =(const T& value){setValue(value); return getValue();};
   virtual void setValue(const T& value){};
   virtual const T& getValue(const T& value){};
   ...
};
class B: public A<int>
{
public:
   virtual void setValue(const T& value){...};
   virtual const T& getValue(const T& value){...};
};
In questo modo mi basterebbe definire la funzione setValue(...) e 
getValue() nelle sotto-classi. Purtroppo, però non riesco ad ereditare 
l'operatore di assegnamento.

 Si cosí funziona ma è proprio quello che vorrei evitare: [...]
Immaginavo... ma, just in case, l'ho sparata.


 l'operatore di assegnamento.
Mi pare una idea balzana, perche' l'operatore di assegnamento e'
proprio di ciascuna classe e non si presta ad un'implementazione
tramite funzioni virtuali. Tra l'altro l'operatore ritorna sempre
*this, quindi getValue e' inutile; a questo punto tra scrivere
l'operatore della sottoclasse e un nuovo override di setValue la
differenza e' poca.
Senza parlare di tutti i problemi legati alla sicurezza dalle
eccezioni...
Ciao,
Nicola

 Nicola
Saluti, Stefano.

 A quali problemi ti riferisci?
Puoi cominciare dando un'occhiata qui: 
http://www.gotw.ca/gotw/059.htm
Ciao,
Nicola

 Nicola
Grazie per i consigli.
Ciao, Stefano.

 assegnamento non č definito? Non dovrebbe essere ereditato dalla classe A?
Ma si dice operatore di assegnamento o operatore di assegnazione ?
-- 
alef