[C++] Distruttori

[UltraBeginner]

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? Perche se invece commento il mio distruttore tutto fila liscio come l'olio?

Grazie per le rispo! Salutiiiii

[MItaly]

Come hai definito Huge:perator<<?

[UltraBeginner]

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]

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....



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

[UltraBeginner]

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