Devo chiamare esplicitamente il distruttore virtuale di base?

Quando eseguo l'override di una classe in C ++ (con un distruttore virtuale) sto implementando nuovamente il distruttore come virtuale sulla classe ereditaria, ma devo chiamare il distruttore di base?

Se è così, immagino che sia qualcosa del genere ...

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

    // Some destructing specific to MyChildClass
}

Ho ragione?

No, i distruttori vengono chiamati automaticamente nell'ordine inverso rispetto alla costruzione. (Le classi di base sono le ultime). Non chiamare distruttori della classe base.

No, non è necessario chiamare il distruttore di base, un distruttore di base viene sempre chiamato per te dal distruttore derivato. Si prega di consultare la mia risposta correlata qui per ordine di distruzione .

Per capire perché desideri un distruttore virtuale nella classe base, consulta il codice seguente:

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


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

Quando lo fai:

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

Quindi se non avessi un distruttore virtuale in B, verrebbe chiamato solo ~ B (). Ma poiché hai un distruttore virtuale, prima verrà chiamato ~ D (), quindi ~ B ().

Quello che hanno detto gli altri, ma nota anche che non devi dichiarare il distruttore virtuale nella classe derivata. Una volta dichiarato virtuale un distruttore, come nella classe base, tutti i distruttori derivati ​​saranno virtuali, indipendentemente dal fatto che lo 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
};

No. A differenza di altri metodi virtuali, in cui si chiamerebbe esplicitamente il metodo Base dal derivato per "concatenare" la chiamata, il compilatore genera codice per chiamare i distruttori nell'ordine inverso in cui sono stati chiamati i loro costruttori.

No, non si chiama mai il distruttore della classe base, viene sempre chiamato automaticamente come altri hanno sottolineato, ma qui è la prova del concetto con i 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 imposti il ​​distruttore della classe base come virtuale quale dovrebbe essere, i risultati del caso 3 sarebbero gli stessi dei casi 1 e 2.

No. Viene chiamato automaticamente.

I distruttori in C ++ vengono chiamati automaticamente nell'ordine delle loro costruzioni (Derivato poi Base) solo quando viene dichiarato il distruttore della classe Basevirtual .

In caso contrario, al momento dell'eliminazione dell'oggetto viene invocato solo il distruttore della classe base.

Esempio: senza distruttore virtuale

#include <iostream>

using namespace std;

class Base{
public:
  Base(){
    cout << "Base Constructor \n";
  }

  ~Base(){
    cout << "Base Destructor \n";
  }

};

class Derived: public Base{
public:
  int *n;
  Derived(){
    cout << "Derived Constructor \n";
    n = new int(10);
  }

  void display(){
    cout<< "Value: "<< *n << endl;
  }

  ~Derived(){
    cout << "Derived Destructor \n";
  }
};

int main() {

 Base *obj = new Derived();  //Derived object with base pointer
 delete(obj);   //Deleting object
 return 0;

}

Produzione

Base Constructor
Derived Constructor
Base Destructor

Esempio: con base Virtual Destructor

#include <iostream>

using namespace std;

class Base{
public:
  Base(){
    cout << "Base Constructor \n";
  }

  //virtual destructor
  virtual ~Base(){
    cout << "Base Destructor \n";
  }

};

class Derived: public Base{
public:
  int *n;
  Derived(){
    cout << "Derived Constructor \n";
    n = new int(10);
  }

  void display(){
    cout<< "Value: "<< *n << endl;
  }

  ~Derived(){
    cout << "Derived Destructor \n";
    delete(n);  //deleting the memory used by pointer
  }
};

int main() {

 Base *obj = new Derived();  //Derived object with base pointer
 delete(obj);   //Deleting object
 return 0;

}

Produzione

Base Constructor
Derived Constructor
Derived Destructor
Base Destructor

Si consiglia di dichiarare il distruttore della classe base in caso virtualcontrario, causa un comportamento indefinito.

Riferimento: Virtual Destructor