Can the default destructor be generated as a virtual destructor automatically?

Can the default destructor be generated as a virtual destructor automatically?

If I define a base class but no default destructor, is there a default virtual destructor generated automatically?

No. There is a cost associated with making a method virtual, and C++ has a philosophy of not making you pay for things that you don't explicitly state that you want to use. If a virtual destructor would have been generated automatically, you would have been paying the price automatically.

Why not just define an empty virtual destructor?

In C++ 11 you can use:

class MyClass
{
  // create a virtual, default destructor
  virtual ~MyClass() = default;
};

Yes, by inheriting from a base class with a virtual destructor. In this case, you already pay the price for a polymorphic class (e.g. vtable).

No, all destructor's are by default NOT virtual.

You will need to define a virtual destructor on all the base classes

In addition to that.

To quote Scott Meyers in his book "Effective C++":

> The C++ language standard is > unusually clear on this topic. When > you try to delete a derived class > object through a base class pointer > and the base class has a non-virtual > destructor (as EnemyTarget does), the > results are undefined

In practice, it's usually a good idea to define a class with a virtual destructor if you think that someone might eventually create a derived class from it. I tend to just make all classes have virtual destructor's anyway. Yes, there is a cost associated with that, but the cost of not making it virtual more often that not out weighs a measly bit of run-time overhead.

I suggest, only make it non-virtual when you're absolutely certain that you want it that way rather than the rely on the default non-virtual that the compilers enforce. You may disagree, however (in summary) I recently had a horrid memory leak on some legacy code where all I did was add a std::vector into one of the classes that had existed for several years. It turns out that one of it's base classes didn't have a destructor defined (default destructor is empty, non-virtual!) and as no memory was being allocated like this before no memory leaked until that point. Many days of investigation and time wasted later...

Uri and Michael are right -- I'll just add that if what's bugging you is having to touch two files to declare and define the destructor, it's perfectly all right to define a minimal one inline in the header:

class MyClass
{
   // define basic destructor right here
   virtual ~MyClass(){}
   
   // but these functions can be defined in a different file
   void FuncA();
   int FuncB(int etc);
}

Currently, Uri is right. On the other hand, after you have declared a virtual method in your class, you are paying the price for the existence of the virtual table anyway. In fact, the compiler will warn you if your class has a virtual method, but no virtual destructor. This could become a candidate for automatic generation of the default virtual destructor instead of the pesky warning.

No. You need to declare it as virtual.

Some people stated that it is never defaulted to virtual. That's not exactly true.

> Even though destructors are not inherited, if a base class declares its destructor virtual, the derived destructor always overrides it.

This means that if the base class has a virtual destructor you don't have to define a destructor of the derived class as virtual nor explicitly write:

/// All of these are unnecessary and won't change the destruction behavior
/// as long as Class inherits from a base class with a virtual destructor
virtual ~Class() = default;
// or
~Class() override = default;
// or
~Class() {}