Devo chiamare esplicitamente il distruttore virtuale di base?

Question

Quando si esegue l'override di una classe in C++ (con un distruttore virtuale) sto implementando di nuovo il distruttore come virtuale nella classe ereditaria, ma devo chiamare il distruttore di base?

Se quindi immagino che sia qualcosa di simile ...

MyChildClass::~MyChildClass() // virtual in header 
{ 
    // Call to base destructor... 
    this->MyBaseClass::~MyBaseClass(); 

    // Some destructing specific to MyChildClass 
} 

ho ragione?

Answer 1

No, i distruttori vengono chiamati automaticamente nell'ordine inverso di costruzione. (Le classi base durano). Non chiamare i distruttori della classe base.

Answer 2

No non è necessario chiamare il distruttore di base, un distruttore di base viene sempre chiamato dal distruttore derivato. Please see my related answer here for order of destruction.

Per comprendere il motivo per cui si desidera un distruttore virtuale nella classe base, si prega di consultare il codice qui sotto:

class B 
{ 
public: 
    virtual ~B() 
    { 
     cout<<"B destructor"<<endl; 
    } 
}; 


class D : public B 
{ 
public: 
    virtual ~D() 
    { 
     cout<<"D destructor"<<endl; 
    } 
}; 

Quando si esegue:

B *pD = new D(); 
delete pD; 

Quindi se non si dispone di un distruttore virtuale in B, sarebbe chiamato solo ~ B(). Ma dal momento che hai un distruttore virtuale, prima verrà chiamato ~ D(), quindi ~ B().

Answer 3

No. Viene chiamato automaticamente.

Answer 4

Ciò che gli altri hanno detto, ma anche notare che non è necessario dichiarare il distruttore virtuale nella classe derivata. Una volta dichiarato un distruttore virtuale, come si fa nella classe base, tutti i distruttori derivati ​​saranno virtuali sia che li dichiariate o meno. In altre parole:

struct A { 
    virtual ~A() {} 
}; 

struct B : public A { 
    virtual ~B() {} // this is virtual 
}; 

struct C : public A { 
    ~C() {}   // this is virtual too 
}; 

Answer 5

No. A differenza di altri metodi virtuali, dove si sarebbe esplicitamente chiamare il metodo di base della derivata per 'catena' la chiamata, il compilatore genera codice per chiamare i distruttori in ordine inverso in cui i loro costruttori furono chiamati.

Answer 6

No, mai chiamata la classe distruttore bese, si è sempre chiamato automaticamente come altri hanno fatto notare, ma qui è la prova di concetto con risultati:

class base { 
public: 
    base() 
    { 
     cout << __FUNCTION__ << endl; 
    } 
    ~base() 
    { 
     cout << __FUNCTION__ << endl; 
    } 
}; 

class derived : public base { 
public: 
    derived() 
    { 
     cout << __FUNCTION__ << endl; 
    } 
    ~derived() 
    { 
     cout << __FUNCTION__ << endl; 
    } // adding call to base::~base() here results in double call to base destructor 
}; 


int main() 
{ 
    cout << "case 1, declared as local variable on stack" << endl << endl; 
    { 
     derived d1; 
    } 

    cout << endl << endl; 

    cout << "case 2, created using new, assigned to derive class" << endl << endl; 
    derived * d2 = new derived; 
    delete d2; 

    cout << endl << endl; 

    cout << "case 3, created with new, assigned to base class" << endl << endl; 
    base * d3 = new derived; 
    delete d3; 

    cout << endl; 

    return 0; 
} 

L'output è:

case 1, declared as local variable on stack 

base::base 
derived::derived 
derived::~derived 
base::~base 


case 2, created using new, assigned to derive class 

base::base 
derived::derived 
derived::~derived 
base::~base 


case 3, created with new, assigned to base class 

base::base 
derived::derived 
base::~base 

Press any key to continue . . . 

Se si imposta il distruttore della classe base come virtuale, quale dovrebbe essere, i risultati sono gli stessi del caso 1 & 2.