Chiamare il metodo virtuale dal distruttore - soluzione alternativa?

Question

Devo dichiarare il metodo di finalizzazione finalize() per tutti i discendenti della classe base Base, che dovrebbe essere chiamato durante la distruzione, e il mio intento era di chiamare puro virtual void Base::finalize() = 0 dal ~Base(), ma C++ proibisce una cosa del genere. Quindi la mia domanda è

Come possiamo obbligare i discendenti di fare qualche lavoro di finalizzazione in modo giusto e definito preliminare?

Questo codice non può essere compilato:

#include <QDebug> 
class Base { 
     public: 
      Base(){} 
      virtual ~Base(){ 
       qDebug("deleting b"); 
       finalize(); 
      } 
      virtual void finalize() = 0; 

    }; 

class A : public Base 
    { 
    public: 
     A(){} 
     ~A(){} 
     void finalize(){qDebug("called finalize in a");} 
    }; 

    int main(int argc, char *argv[]) 
    { 
     Base *b = new A; 
     delete b; 
    } 

Se faccio Base::finalize() non virtuale pura, si chiama da ~Base() senza dispacciamento a figlio poiché è stato già distrutta.

posso chiamare finalizzare() dal distruttore del bambino ma domanda è come alla forza per farlo. In altre parole, la mia domanda è: è possibile obbligare le persone che scriveranno discendenti della classe Base a usare il metodo di finalizzazione, beh, in un altro modo che commentare in una documentazione? :)

Answer 1

distruttori sono il posto giusto per liberare risorse acquisite, ma ogni classe è responsabile di liberare le proprie risorse. Le risorse acquisite da class A non dovrebbero (e non possono) essere rilasciate da class Base.

Definizione distruttori virtuali permette class A 'distruttore s da chiamare quando si elimina un puntatore a class Base che punta a un oggetto class A

Base* p = new A; 
delete p; // Both A and Base destructors are sequencially called! 

Quindi, per ottenere il corretto rilascio delle risorse è sufficiente rilasciare ogni classe' risorse nella sua proprio distruttore.

Answer 2

Questo è ciò che un distruttore virtuale è per:

class A 
{ 
public: 
    virtual ~A() {} 
}; 

class B : public A 
{ 
public: 
    virtual ~B() {} 
}; 

Quando un oggetto di tipo B è distrutta, indipendentemente da un puntatore a una B o un puntatore a un A, entrambi distruttori saranno chiamato. Innanzitutto, B::~B() e poi A::~A().

Answer 3

rendere la classe distruttore di base pura virtuale con un corpo, che dovrebbe fare esattamente quello che vuoi.

Answer 4

Perché non utilizzare il decodificatore di Base? Quello per cui sono fatti i distruttori.

Ricerca per RAII e scoprire una delle più belle cose in C++.

La maggior parte delle persone utilizzato per utilizzare altre lingue devono scoprire questo. La gestione delle risorse in C++ è completamente diverso che in molti altri linguaggi di programmazione