Warum sollte ich einen virtuellen Destruktor für eine abstrakte Klasse in C++ deklarieren?

Question

Ich weiß, dass es eine gute Praxis ist, virtuelle Destruktoren für Basisklassen in C++ zu deklarieren, aber ist es immer wichtig, die virtual Destruktoren auch für abstrakte Klassen, die als Schnittstellen fungieren? Bitte geben Sie einige Gründe und Beispiele an, warum.

Answer 1

Bei einer Schnittstelle ist das sogar noch wichtiger. Jeder Benutzer Ihrer Klasse wird wahrscheinlich einen Zeiger auf die Schnittstelle halten, nicht einen Zeiger auf die konkrete Implementierung. Wenn er sie löschen will, wird er, wenn der Destruktor nicht virtuell ist, den Destruktor der Schnittstelle aufrufen (oder den vom Compiler bereitgestellten Standard, wenn Sie keinen angegeben haben), nicht den Destruktor der abgeleiteten Klasse. Sofortiges Speicherleck.

Zum Beispiel

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; 
}

Answer 2

Die Antwort auf Ihre Frage lautet: oft, aber nicht immer. Wenn Ihre abstrakte Klasse den Klienten verbietet, delete auf einen Zeiger auf sie aufzurufen (oder wenn sie dies in ihrer Dokumentation sagt), können Sie keinen virtuellen Destruktor deklarieren.

Sie können Clients verbieten, delete auf einen Zeiger darauf aufzurufen, indem Sie den Destruktor schützen. Auf diese Weise ist es absolut sicher und vernünftig, einen virtuellen Destruktor wegzulassen.

Sie werden am Ende keine virtuelle Methodentabelle haben und Ihren Klienten Ihre Absicht signalisieren, sie durch einen Zeiger darauf nicht löschbar zu machen, also haben Sie in der Tat einen Grund, sie in diesen Fällen nicht als virtuell zu deklarieren.

[Siehe Punkt 4 in diesem Artikel: http://www.gotw.ca/publications/mill18.htm ]

Answer 3

Ich habe beschlossen, einige Nachforschungen anzustellen und zu versuchen, Ihre Antworten zusammenzufassen. Die folgenden Fragen werden Ihnen helfen zu entscheiden, welche Art von Zerstörer Sie benötigen:

1. Soll Ihre Klasse als Basisklasse verwendet werden?
   • Nein: Öffentlichen nicht-virtuellen Destruktor deklarieren, um v-Zeiger auf jedem Objekt der Klasse zu vermeiden * .
   • Ja: Lesen Sie die nächste Frage.
2. Ist Ihre Basisklasse abstrakt? (d. h. irgendwelche virtuellen reinen Methoden?)
   • Nein: Versuchen Sie, Ihre Basisklasse abstrakt zu machen, indem Sie Ihre Klassenhierarchie umgestalten
   • Ja: Lesen Sie die nächste Frage.
3. Möchten Sie die polymorphe Löschung durch einen Basiszeiger zulassen?
   • Nein: Deklarieren Sie einen geschützten virtuellen Destruktor, um die unerwünschte Verwendung zu verhindern.
   • Ja: Öffentlichen virtuellen Destruktor deklarieren (in diesem Fall kein Overhead).

Ich hoffe, das hilft.

* Es ist wichtig zu beachten, dass es in C++ keine Möglichkeit gibt, eine Klasse als final (d.h. nicht unterklassifizierbar) zu kennzeichnen. Falls Sie also beschließen, Ihren Destruktor als nicht-virtuell und öffentlich zu deklarieren, denken Sie daran, Ihre Mitprogrammierer ausdrücklich davor zu warnen, von Ihrer Klasse abzuleiten.

Referenzen:

• "S. Meyers. More Effective C++, Artikel 33 Addison-Wesley, 1996."
• Herb Sutter, Virtualität, 2001
• C++ Faq, 20.7, "Wann sollte mein Destruktor virtuell sein?"
• Die Antworten auf diese Frage, natürlich.

Answer 4

Ja, das ist immer wichtig. Abgeleitete Klassen können Speicher zuweisen oder Verweise auf andere Ressourcen enthalten, die bei der Zerstörung des Objekts bereinigt werden müssen. Wenn Sie Ihre Schnittstellen/abstrakten Klassen nicht mit virtuellen Destruktoren ausstatten, wird jedes Mal, wenn Sie eine Instanz einer abgeleiteten Klasse über ein Handle der Basisklasse löschen, der Destruktor Ihrer abgeleiteten Klasse nicht aufgerufen.

Das bedeutet, dass Sie die Möglichkeit von Speicherlecks eröffnen.

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

Answer 5

Es ist nicht immer erforderlich, aber ich halte es für eine gute Übung. Es ermöglicht, dass ein abgeleitetes Objekt sicher durch einen Zeiger eines Basistyps gelöscht werden kann.

So zum Beispiel:

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

ist missgebildet, wenn Base hat keinen virtuellen Destruktor, weil es versuchen wird, das Objekt zu löschen, als wäre es ein Base * .