As the author of the slides I’ll try to clarify. If you write code explicitly allocating a Derived instance with new and destroying it with delete using a base class pointer then you need to define a virtual destructor, otherwise you end up with incompletely destroying the Derived instance. However, I recommend to abstain from … Read more
You don’t pay for what you don’t need. If you never delete through base pointer, you may not want the overhead of the indirected destructor call. Perhaps you were thinking that the mere existence of the vtable is the only overhead. But each individual function dispatch has to be considered, too, and if I want … Read more
Yes, declaring any destructor will prevent the implicit-declaration of the move constructor. N3337 [class.copy]/9: If the definition of a class X does not explicitly declare a move constructor, one will be implicitly declared as defaulted if and only if X does not have a user-declared copy constructor, X does not have a user-declared copy assignment … Read more
There is no need to use a virtual destructor when any of the below is true: No intention to derive classes from it No instantiation on the heap No intention to store with access via a pointer to a superclass No specific reason to avoid it unless you are really so pressed for memory.
You need virtual destructor when at least one of class methods is virtual. This is because the reason for virtual method is that you want to use polymorphism. Meaning you will call a method on the base class pointer and you want the most derived implementation – this is the whole point of polymorphism. Now … Read more
Every abstract class should either have a, protected destructor, or, virtual destructor. If you’ve got a public non-virtual destructor, that’s no good, since it allows users to delete through that pointer a derived object. Since as we all know, that’s undefined behavior. For an abstract class, you already need a virtual-table pointer in the object, … Read more
Yes. If the base destructor is not virtual then the override marking will cause the program to not compile: class Base { public: ~Base() {} }; class Derived : public Base { public: virtual ~Derived() override //error: ‘~Derived’ marked ‘override’ but does // not override any member functions {} };
Yes, they are the same. The derived class not declaring something virtual does not stop it from being virtual. There is, in fact, no way to stop any method (destructor included) from being virtual in a derived class if it was virtual in a base class. In >=C++11 you can use final to prevent it … Read more
It’s even more important for an interface. Any user of your class will probably hold a pointer to the interface, not a pointer to the concrete implementation. When they come to delete it, if the destructor is non-virtual, they will call the interface’s destructor (or the compiler-provided default, if you didn’t specify one), not the … Read more
Virtual destructors are useful when you might potentially delete an instance of a derived class through a pointer to base class: class Base { // some virtual methods }; class Derived : public Base { ~Derived() { // Do some important cleanup } }; Here, you’ll notice that I didn’t declare Base’s destructor to be … Read more