Newsgroup: it.comp.lang.c++
Titolo: Problema con l'overloading di operatori..

Salve a tutti!
Ho un problema con l'overloading degli operatori ke nn riesko a
risolvere.
class Test{
	public:
		Test(int NumElementi):NumElementi(NumElementi){
			/*...*/			
			Elementi=new float[NumElementi];
			/*...*/
		}
		~Test(){
			delete[] Elementi;
			/*...*/	
		}
	/*...*/
	Test operator+(const Test&) const;
	private:
		float* Elementi;
		int NumElementi;
		/*...*/
};
Test Test:operator+(const Test& test) const{
	/*...*/
	Test Result(NumElementi);
	/*somma..*/
	return Result;
}
Result viene creato e poi distrutto, prima di essere ritornato!
Dove sbaglio??

Dove sbaglio??
Una curiosità: visto che utilizzi l'allocazione dinamica, hai definito un
costruttore per copia? Se non lo hai fatto, la memoria in cui si trovano i dati
viene distrutta dalla variabile temporanea all'uscita della funzione di
somma e... Buum!
Ciao
Domenico Barra

Dove sbaglio??
No. Result viene sicuramente distrutto quando esce dallo scope.
Ho provato il seguente esempio :
#include <iostream>
#include <string>
class A {
      private :
         std::string name ;
         int num ;
         float *v ;
      public  :
         A( int _num, std::string id ) : num(_num), name(id) {
             v = new float[num] ;
             std::cout << name << " : creato con " << num << "
elementi"
                       << std::endl ;
         }
         A( const A& a )
         {
            int min = ( a.num < num ) ? a.num : num ;
            name = "-- COPIA --" ;
            for ( int i = 0 ; i < min ; i++ )
            {
                v[i] = a.v[i] ;
            }
         }
         ~A() {
             delete [] v ;
             std::cout << name << " : distrutto" << std::endl ;
         }
         A operator+( const A& a ) ;
} ;
A A::operator+( const A& a )
{
     int min = ( a.num < num ) ? a.num : num ;
     A Result( min, "[Risultato Temporaneo]"  ) ;
     for ( int i = 0 ; i < min ; i++ )
     {
         Result.v[i] = v[i] + a.v[i] ;
     }
     return Result ;
}
int main()
{
    A Mio( 5, "Primo oggetto  " ) ;
    A Tuo( 3, "Secondo oggetto" ) ;
    A Somma( 0, "Oggetto Somma  " ) ;
    Somma = Mio + Tuo ;
    return 0 ;
}
E l'output e' il seguente :
Primo oggetto   : creato con 5 elementi
Secondo oggetto : creato con 3 elementi
Oggetto Somma   : creato con 0 elementi
[Risultato Temporaneo] : creato con 3 elementi
[Risultato Temporaneo] : distrutto
-- COPIA -- : distrutto
-- COPIA -- : distrutto
Secondo oggetto : distrutto
Primo oggetto   : distrutto
Se fai uno step by step col debugger, ti accorgi che il risultato
viene distrutto solo DOPO essere stato assegnato mediante costruttore
di copia. La copia che viene assegnata a Somma, e che e' un oggetto
temporaneo, viene distrutta prima possibile (secondo la regola).
Somma adesso ha nome anch'essa uguale a "COPIA" (per via del
costruttore di copia) e viene distrutta all'uscita del programma. A
seguire sia il Secondo che il Primo oggetto.
Ditemi se ci sono errori, che sto imparando pure io ! ;)
--
Andrea Laforgia (ICQ 87230455)
http://www.geocities.com/AndreaLaforgia
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

 
in effetti, c'era un'errore proprio nel costruttore di copia!
ma me ne sono accorta solo dopo un bel po di debug..
ora, cmq, sembra funzionare tutto ((:
grazie mille x l'aiuto (anke ad Andrea)
ciao, adre