Codice distruttore C++

Question

Ho questo semplice codice C++, ma non so come usare il distruttore.

class date { 

public: 
    int day; 
    date(int m) 
    { 
     day =m; 
    } 

    ~date(){ 
    cout << "I wish you have entered the year \n" << day;  
    } 
}; 


int main() 
{ 
    date ob2(12); 
    ob2.~date(); 
    cout << ob2.day; 
    return 0; 
} 

la domanda è, che cosa devo scrivere nel mio codice distruttore, che dopo aver chiamato il distruttore, allora sarà eliminare la variabile "giorno". ???

Answer 1

Non chiamare il distruttore in modo esplicito.

Quando si crea l'oggetto in pila (come hai fatto) tutto ciò che serve è:

int main() 
{ 
    date ob2(12); 
    // ob2.day holds 12 
    return 0; // ob2's destructor will get called here, after which it's memory is freed 
} 

Quando si crea l'oggetto sul mucchio, è un po bisogno di delete la classe prima della sua distruttore si chiama e memoria viene liberata:

int main() 
{ 
    date* ob2 = new date(12); 
    // ob2->day holds 12 
    delete ob2; // ob2's destructor will get called here, after which it's memory is freed 
    return 0; // ob2 is invalid at this point. 
} 

(Non riuscendo a chiamare eliminare in questo ultimo esempio si tradurrà in perdita di memoria.)

Entrambi i modi hanno i loro vantaggi un d svantaggi. Il modo stack è MOLTO veloce con l'allocazione della memoria che l'oggetto occuperà e non è necessario eliminarlo esplicitamente, ma lo stack ha uno spazio limitato e non è possibile spostare quegli oggetti facilmente, velocemente e in modo pulito.

L'heap è il metodo migliore per farlo, ma quando si tratta di prestazioni, è lento allocare e devi gestire i puntatori. Ma hai molta più flessibilità con quello che fai con il tuo oggetto, è molto più veloce lavorare con i puntatori e hai più controllo sulla vita dell'oggetto.

Answer 2

Non è necessario chiamare il distruttore in modo esplicito. Questo viene fatto automaticamente alla fine del campo di applicazione dell'oggetto ob2, ad esempio alla fine della funzione main.

Inoltre, poiché l'oggetto dispone di archiviazione automatica, non è necessario eliminare la memoria. Anche questo è fatto automaticamente alla fine della funzione.

Calling distruttori manualmente è quasi mai necessario (solo in bassa a livello di codice biblioteca) e la cancellazione della memoria manualmente è necessaria solo (e solo un'operazione valida) quando la memoria è stato precedentemente acquisito utilizzando new (quando si lavora con i puntatori).

Poiché la gestione manuale della memoria è soggetta a perdite, il codice C++ moderno non tenta di utilizzare esplicitamente new e . Quando è veramente necessario utilizzare new, viene utilizzato un cosiddetto "puntatore intelligente" anziché un puntatore normale.

Answer 3

Raramente è mai necessario chiamare il distruttore in modo esplicito. Invece, il distruttore viene chiamato quando un oggetto viene distrutto.

Per un oggetto come ob2 che è una variabile locale, è distrutta quando esce dall'ambito:

int main() 
{ 
    date ob2(12); 

} // ob2.~date() is called here, automatically! 

Se si alloca dinamicamente un oggetto utilizzando new, il suo distruttore è chiamato quando l'oggetto viene distrutto utilizzando delete. Se si dispone di un oggetto statico, il suo distruttore viene chiamato quando il programma termina (se il programma termina normalmente).

A meno che non si crea qualcosa usando dinamicamente new, non c'è bisogno di fare nulla esplicito per ripulirlo (così, ad esempio, quando ob2 è distrutto, tutte le sue variabili membro, tra cui day, vengono distrutti). Se crei qualcosa in modo dinamico, devi assicurarti che venga distrutto quando hai finito con esso; la procedura migliore consiste nell'utilizzare quello che viene chiamato "puntatore intelligente" per garantire che questa pulizia venga gestita automaticamente.

Answer 4

In questo caso il distruttore non deve eliminare la variabile giorno.

È sufficiente chiamare eliminare sulla memoria che è stato assegnato con nuovo.

Ecco come il codice sarà se si stesse utilizzando new e delete per innescare invocare il distruttore

class date { 

    public: int* day; 
    date(int m) { 
     day = new int; 
     *day = m; 
    } 

    ~date(){ 
     delete day; 
     cout << "now the destructor get's called explicitly"; 
    } 
}; 

int main() { 
    date *ob2 = new date(12); 
    delete ob2; 
    return 0; 
} 

Answer 5

Solo in circostanze molto specifiche è necessario chiamare direttamente il distruttore. Per impostazione predefinita, il distruttore verrà chiamato dal sistema quando si crea una variabile di archiviazione automatica e non rientra nell'ambito o quando un oggetto assegnato dinamicamente con new viene distrutto con delete.

struct test { 
    test(int value) : value(value) {} 
    ~test() { std::cout << "~test: " << value << std::endl; } 
    int value; 
}; 
int main() 
{ 
    test t(1); 
    test *d = new t(2); 
    delete d;   // prints: ~test: 2 
}      // prints: ~test: 1 (t falls out of scope) 

Per completezza, (questo non deve essere usato in generale) la sintassi per chiamare il distruttore è simile a un metodo. Dopo il distruttore viene eseguito, la memoria non è più un oggetto di quel tipo (dovrebbe essere gestita come memoria grezzo):

int main() 
{ 
    test t(1); 
    t.~test();   // prints: ~test: 1 
         // after this instruction 't' is no longer a 'test' object 
    new (&t) test(2);  // recreate a new test object in place 
}      // test falls out of scope, prints: ~test: 2 

Nota: dopo aver chiamato il distruttore su t, quella posizione di memoria non è più un test, questo è il motivo della ricreazione dell'oggetto per mezzo del posizionamento nuovo.

Answer 6

Anche se il distruttore sembra qualcosa che devi chiamare per eliminare o "distruggere" il tuo oggetto quando hai finito di usarlo, non dovresti usarlo in quel modo.

Il distruttore è qualcosa che viene chiamato automaticamente quando il tuo oggetto esce dall'ambito, cioè quando il computer lascia le "parentesi graffe" in cui hai istanziato l'oggetto. In questo caso, quando esci da main(). Non vuoi chiamarlo da solo.

Answer 7

Si può essere confusi da un comportamento non definito qui. Lo standard C++ non ha regole su ciò che accade se usi un oggetto dopo che il suo distruttore è stato eseguito, poiché è un comportamento indefinito, e quindi l'implementazione può fare qualsiasi cosa voglia. In genere, i progettisti di compilatori non fanno nulla di speciale per un comportamento indefinito, e quindi ciò che accade è un artefatto di quali altre decisioni di progettazione sono state prese. (Ciò può causare risultati davvero strani a volte.)

Pertanto, una volta eseguito il distruttore, il compilatore non ha alcun obbligo in merito a quell'oggetto. Se non ti riferisci di nuovo, non importa. Se fai riferimento ad esso, è un comportamento indefinito, e dal punto di vista dello Standard il comportamento non ha importanza, e poiché lo Standard non dice nulla, la maggior parte dei progettisti di compilatori non si preoccuperà di ciò che fa il programma.

In questo caso, la cosa più semplice da fare è lasciare l'oggetto inalterato, poiché non sta trattenendo risorse, e la sua memoria è stata allocata come parte dell'avvio della funzione e non verrà recuperata fino alla funzione uscite. Pertanto, il valore del membro dati rimarrà lo stesso.La cosa naturale da fare per il compilatore quando legge ob2.day è accedere alla posizione di memoria.

Come qualsiasi altro esempio di comportamento non definito, i risultati potrebbero cambiare in qualsiasi cambiamento di circostanze, ma in questo caso probabilmente non lo faranno. Sarebbe bello se i compilatori catturassero più casi di comportamento non definito e problemi di diagnostica, ma non è possibile per i compilatori rilevare tutti i comportamenti non definiti (alcuni si verificano in fase di runtime) e spesso non controllano comportamenti che non pensano probabile.