Pourquoi devrais-je déclarer un destructeur virtuel pour une classe abstraite en C ++?

Je sais que c'est une bonne pratique de déclarer des destructeurs virtuels pour les classes de base en C ++, mais est-il toujours important de déclarer des virtualdestructeurs même pour les classes abstraites qui fonctionnent comme des interfaces? Veuillez fournir quelques raisons et exemples.

C'est encore plus important pour une interface. Tout utilisateur de votre classe tiendra probablement un pointeur vers l'interface, pas un pointeur vers l'implémentation concrète. Quand ils viendront à le supprimer, si le destructeur n'est pas virtuel, ils appelleront le destructeur de l'interface (ou la valeur par défaut fournie par le compilateur, si vous n'en avez pas spécifié un), pas le destructeur de la classe dérivée. Fuite de mémoire instantanée.

Par exemple

class Interface
{
   virtual void doSomething() = 0;
};

class Derived : public Interface
{
   Derived();
   ~Derived() 
   {
      // Do some important cleanup...
   }
};

void myFunc(void)
{
   Interface* p = new Derived();
   // The behaviour of the next line is undefined. It probably 
   // calls Interface::~Interface, not Derived::~Derived
   delete p; 
}

La réponse à votre question est souvent, mais pas toujours. Si votre classe abstraite interdit aux clients d'appeler delete sur un pointeur vers elle (ou si elle le dit dans sa documentation), vous êtes libre de ne pas déclarer de destructeur virtuel.

Vous pouvez interdire aux clients d'appeler delete sur un pointeur vers lui en protégeant son destructeur. En travaillant comme ça, il est parfaitement sûr et raisonnable d'omettre un destructeur virtuel.

Vous finirez par vous retrouver sans table de méthode virtuelle, et vous finirez par signaler à vos clients votre intention de la rendre non supprimable via un pointeur vers elle, vous avez donc en effet des raisons de ne pas la déclarer virtuelle dans ces cas.

[Voir le point 4 de cet article: http://www.gotw.ca/publications/mill18.htm ]

J'ai décidé de faire quelques recherches et d'essayer de résumer vos réponses. Les questions suivantes vous aideront à décider du type de destructeur dont vous avez besoin:

1. Votre classe est-elle destinée à être utilisée comme classe de base?
   • Non: Déclarez un destructeur non virtuel public pour éviter le v-pointer sur chaque objet de la classe ^* .
   • Oui: lisez la question suivante.
2. Votre classe de base est-elle abstraite? (c'est-à-dire des méthodes pures virtuelles?)
   • Non: essayez de rendre votre classe de base abstraite en remodelant votre hiérarchie de classes
   • Oui: lisez la question suivante.
3. Voulez-vous autoriser la suppression polymorphe via un pointeur de base?
   • Non: Déclarez le destructeur virtuel protégé pour empêcher l'utilisation indésirable.
   • Oui: Déclarez le destructeur virtuel public (pas de surcharge dans ce cas).

J'espère que ça aide.

^* Il est important de noter qu'il n'y a aucun moyen en C ++ de marquer une classe comme finale (c'est-à-dire non sous-classable), donc dans le cas où vous décidez de déclarer votre destructeur non virtuel et public, n'oubliez pas d'avertir explicitement vos collègues programmeurs contre dérivant de votre classe.

Références:

• "S. Meyers. C ++ plus efficace, article 33 Addison-Wesley, 1996."
• Herb Sutter, Virtualité, 2001
• C ++ Faq, 20.7, "Quand mon destructeur doit-il être virtuel?"
• Les réponses à cette question, bien sûr.

Oui, c'est toujours important. Les classes dérivées peuvent allouer de la mémoire ou contenir des références à d'autres ressources qui devront être nettoyées lorsque l'objet est détruit. Si vous ne donnez pas à vos interfaces / classes abstraites de destructeurs virtuels, alors chaque fois que vous supprimez une instance de classe dérivée via un handle de classe de base, votre destructeur de classe dérivée ne sera pas appelé.

Par conséquent, vous ouvrez le potentiel de fuites de mémoire

class IFoo
{
  public:
    virtual void DoFoo() = 0;
};

class Bar : public IFoo
{
  char* dooby = NULL;
  public:
    virtual void DoFoo() { dooby = new char[10]; }
    void ~Bar() { delete [] dooby; }
};

IFoo* baz = new Bar();
baz->DoFoo();
delete baz; // memory leak - dooby isn't deleted

Ce n'est pas toujours obligatoire, mais je trouve que c'est une bonne pratique. Ce qu'il fait, c'est qu'il permet à un objet dérivé d'être supprimé en toute sécurité via un pointeur d'un type de base.

Donc par exemple:

Base *p = new Derived;
// use p as you see fit
delete p;

est mal formé s'il Basen'a pas de destructeur virtuel, car il tentera de supprimer l'objet comme s'il s'agissait d'un fichier Base *.

Ce n'est pas seulement une bonne pratique. C'est la règle n ° 1 pour toute hiérarchie de classes.

1. La classe la plus de base d'une hiérarchie en C ++ doit avoir un destructeur virtuel

Maintenant pour le pourquoi. Prenez la hiérarchie animale typique. Les destructeurs virtuels passent par la répartition virtuelle comme tout autre appel de méthode. Prenons l'exemple suivant.

Animal* pAnimal = GetAnimal();
delete pAnimal;

Supposons que Animal est une classe abstraite. Le seul moyen pour C ++ de connaître le destructeur approprié à appeler est via la répartition de méthode virtuelle. Si le destructeur n'est pas virtuel, il appellera simplement le destructeur d'Animal et ne détruira aucun objet dans les classes dérivées.

La raison pour laquelle le destructeur est virtuel dans la classe de base est qu'il supprime simplement le choix des classes dérivées. Leur destructeur devient virtuel par défaut.

La réponse est simple, vous avez besoin qu'elle soit virtuelle sinon la classe de base ne serait pas une classe polymorphe complète.

    Base *ptr = new Derived();
    delete ptr; // Here the call order of destructors: first Derived then Base.

Vous préférez la suppression ci-dessus, mais si le destructeur de la classe de base n'est pas virtuel, seul le destructeur de la classe de base sera appelé et toutes les données de la classe dérivée resteront non supprimées.