Newsgroup: it.comp.lang.c++
Titolo: overloading operator+: qualcosa mi sfugge

Per imparare bene il C++ ho deciso di farmi una mia personale classe
per gestire liste dinamiche, e fin qui tutto bene. Il problema sorge
al momento dell'overload dell'operatore +. L'idea e' che se
lista = lista + lista2;
lista diventa uguale a se stessa ed in piu' con tutti gli elementi di
lista2. E anche fin qui tutto bene. Il problema sorge nel caso che
lista = lista2 + lista3;
in teoria lista diventa uguale agli elementi della seconda e terza
lista. Tutto funziona, ma anche lista2 si modifica prendendo anche lei
se stessa con tutti gli elementi di lista3. Come accade l'ho anche
capito: il compilatore traduce tutto in
lista.operator=(lista2.operator+(lista3));
non e' possibile evitare questo lista2.operator+(lista3) per qualcosa
che consenti di evitare la modifica di lista2?
nb: e' la prima volta che sfrutto queste capacita' avanzate del C++
^^;;;;;
Grazie
Ecco i codici:
...
template <class E>
struct OBJLIST {
	E m_e; //elemento
	OBJLIST<E> * m_s; //successivo
}; //struttura per la lista
...
template <class T>
class CList {
private:
	OBJLIST<T> * p; //primo elemento
public:
	CList (); //costruttore
	~CList (); //distruttore
	//funzioni
	//OVERLOADING
	CList (const CList&); //ridefinisce costruttore
	CList& operator=(const CList&); //ridefinisce =	
	CList<T> operator+ (CList<T>); //ridefinisce operatore +
	CList<T> operator+= (CList<T>); //ridefinisce operatore +=
	//altri overload
}
...
template <class T>
CList<T>& CList<T>::operator=(const CList& copy)
{
	//ridefinisce =	
	OBJLIST<T> * list = copy.p;
	Reset ();
	delete p;
	p = NULL;
	while (list != NULL) {
		Add (list->m_e);
		list = list->m_s;
	}
	return *this;
}
...
template <class T>
CList<T> CList<T>::operator+ (CList<T> copy)
{
	//ridefinisce operatore +
	OBJLIST<T> * list = copy.p;
	while (list != NULL) {
		Add (list->m_e);
		list = list->m_s;
	}
	return *this;
}
...
__
Scritto da Gordon
E-mail: 
tbe...@avpu.vg

 }
Non vedo come funzioni Add(), ma a me pare che tu aggiunga tutto a lista2.
e poi tu ritorni un oggetto temporaneo che e' una copia di lista2 (return
*this).
Tu invece dovresti crearti un bel oggetto temporaneo, chiamiamolo:
tmp_add_result all'inizio del metodo.
Successivamente aggiungi a questo tutti gli elementi di lista2 e poi di
lista3, lasciando sia lista2 che lista3 intatti.
In seguito ritorni tmp_add_result e non *this.
Ricordati di ritornare un CList<T> (come fai ora) e non un CList<T>&, visto
che putroppo di questo oggetto devi farne un'altra copia visto che "muore"
presto.
Per essere sicuro di non modificare lista2 ne tantomeno lista3 potresti
mettere un bel 'const' tra:
CList.......(.....copy) const
{
   ..............
   return tmp_add_result;
}
e nella sua dichiarazione dentro la classe.
Se incontri altri problemi scrivi pure.
Tommy

Se incontri altri problemi scrivi pure.
ok, grazie.
vado subito a scrivere il nuovo codice ;D


vado subito a scrivere il nuovo codice ;D
template <class T>
CList<T> CList<T>::operator+ (CList<T> a) const
{
	//ridefinisce operatore +
	CList<T> tempAdd;
	OBJLIST<T> * lista = a.p;
	while (lista != NULL) {
		tempAdd.Add (lista->m_e);
		lista = lista->m_s;
	}
	lista = p;
	while (lista != NULL) {
		tempAdd.Add (lista->m_e);
		lista = lista->m_s;
	}
	return tempAdd;
}
ora funziona tutto!!


 CList<T> (da che ci sono ne approfitto ;P)?
Se hai un libro di C++ ti consiglio di studiarti li i "reference". E' un
argomento interessante.
Non per cattiveria, solo perche' gli autori dei libri di solito si sanno
spiegare meglio di me ;-)
Se poi non hai capito proveremo di venirti incontro.
Tommy

argomento interessante.
ah ottimo, leggo subito.
