PDA

Visualizza la versione completa : [C++] Distruttori


UltraBeginner
01-03-2007, 16:14
Ciao a tutti,

ho un problema con i Distruttori.


Questo il main



int main()
{
Huge Big(155),Big2(1000);
Huge Big3;
Big3=10000;
Big=10000;
cout<<Big;


system("PAUSE");
return EXIT_SUCCESS;
}


Codice distruttore


Huge::~Huge()
{
cout<<"Oggetto Distrutto: "<<pointer<<endl;
delete [] pointer;
}



il codice funziona se tengo la parte legata al distruttore commentata, se invece "abilito" il distruttore ottengo questo output:
Oggetto distrutto:0x34AB;
Oggetto distrutto:0x34BC;
1234234432 // questo numero qui dovrebbe essere invece 10000, cioe il valore a cui inizializzo Big.

Come mai si ha questo comportamento? Il distruttore, anche se definito da me, non dovrebbe essere chiamato quando si esaurisce il lifetime della variabile? :confused: :confused: Perche se invece commento il mio distruttore tutto fila liscio come l'olio?

Grazie per le rispo! Salutiiiii :ciauz: :ciauz:

MItaly
01-03-2007, 16:36
Come hai definito Huge::operator<<?

UltraBeginner
01-03-2007, 16:38
Eccomi

ostream & operator <<(ostream & uscita,Huge& Ogg) //implementazione
{
int i;
for(i=0;i<Ogg.lunghezza;i++)
uscita<<Ogg.pointer[i];

uscita<<endl;
return uscita;

}

Se serve posto anche il costruttore di default/conversione

UltraBeginner
01-03-2007, 16:48
Ho notato una cosa:

prima di tutto posto il costruttore


Huge::Huge(int pippo) // Costruttore di default/conversione

{
int indice,ii;
lunghezza=0;

pointer=(int *) malloc(sizeof(int));
while(pippo!=0)
{
pointer=(int *) realloc(pointer,(lunghezza+1)*sizeof( int));
pointer[lunghezza]=pippo%10;
pippo/=10;
lunghezza++;
}

ii = lunghezza - 1;
for( indice = 0; indice < lunghezza / 2; indice++, ii--) //swap del vettore
{
pointer[indice] = pointer[indice] ^ pointer[ii];
pointer[ii] = pointer[indice] ^ pointer[ii];
pointer[indice] = pointer[indice] ^ pointer[ii];
}
}


prima della chiamata di Big=10000 il membro pointer ha un certo valore, tipo 03AA, dopo la chiamata Big=10000 ho notato che pointer ha un valore diverso da 03AA. Eppure mi aspetterei che questi valori siano identici,per lo meno prima della riga

pointer=(int *) malloc(sizeof(int));

visto che nella chiamata coinvolto lo stesso oggetto.
Quando esco dalla funzione ho visto che il membro pointer assume il valore assegnato dalla chiamata pointer=(int *) malloc(sizeof(int)).

Tutto questo avviene a "Distruttore spento". Se attivo il distruttore, dopo la fine della chiamata Big=10000 il programma salta appunto al distruttore e mi fa perdere il vettore di interi puntato da pointer....

:confused: :confused: :confused:

[EDIT]: forse il fatto del malfunzionamento risiede nel fatto che non ho ridefinito l'operatore =, possibile?

UltraBeginner
01-03-2007, 17:27
Risolto ragazzi,

bisogna ridefinire l'operatore =.

Credo di aver quindi capito le operazioni che il compilatore fa, ma come al solito se qualcuno conferma e meglio:

data l 'istruzione Big=1000 il compilatore

1) Chiama il costruttore di default/conversione creando una copia temporanea di un oggetto di tipo Huge

2) Questa copia temporanea conterra il valore 10000

3) La copia temporanea viene assegnata a Big tramita l'operatore ridefinito '='

4) Viene distrutto l'oggetto temporaneo mediante il distruttore

Loading