When to use virtual destructors

Question

I have a solid understanding of most OOP theory but the one thing that confuses me a lot is virtual destructors  I thought that the destructor always gets called no matter what and for every object in the chain  When are you meant to make them virtual and why

User · Answer

Declare destructors virtual in polymorphic base classes   This is Item 7 in Scott Meyers  Effective C     Meyers goes on to summarize that if a class has any virtual function  it should have a virtual destructor  and that classes not designed to be base classes or not designed to be used polymorphically should not declare virtual destructors

User · Answer

Declare destructors virtual in polymorphic base classes   This is Item 7 in Scott Meyers  Effective C     Meyers goes on to summarize that if a class has any virtual function  it should have a virtual destructor  and that classes not designed to be base classes or not designed to be used polymorphically should not declare virtual destructors

User · Answer

Make the destructor virtual whenever your class is polymorphic

User · Answer

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 virtual  Now  let s have a look at the following snippet   Base  b   new Derived       use b delete b     Here s the problem    Since Base s destructor is not virtual and b is a Base  pointing to a Derived object  delete b has undefined behaviour       In delete b   if the static type of the   object to be deleted is different from its dynamic type  the static   type shall be a base class of the dynamic type of the object to be   deleted and the static type shall have a virtual destructor or the   behavior is undefined    In most implementations  the call to the destructor will be resolved like any non-virtual code  meaning that the destructor of the base class will be called but not the one of the derived class  resulting in a resources leak   To sum up  always make base classes  destructors virtual when they re meant to be manipulated polymorphically   If you want to prevent the deletion of an instance through a base class pointer  you can make the base class destructor protected and nonvirtual  by doing so  the compiler won t let you call delete on a base class pointer   You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter

User · Answer

To be simple  Virtual destructor is to destruct the resources in a proper order  when you delete a base class pointer pointing to derived class object     include lt iostream gt   using namespace std   class B      public         B              cout lt  lt  B   n                   virtual  B               cout lt  lt   B   n                 class D  public B      public         D              cout lt  lt  D   n                    D              cout lt  lt   D   n                 int main        B  b   new D        delete b      return 0      OUTPUT  B   D    D    B                   If you don t give  B    as virtual  then output would be  B   D    B   where destruction of  D   is not done which leads to leak

User · Answer

Declare destructors virtual in polymorphic base classes   This is Item 7 in Scott Meyers  Effective C     Meyers goes on to summarize that if a class has any virtual function  it should have a virtual destructor  and that classes not designed to be base classes or not designed to be used polymorphically should not declare virtual destructors

User · Answer

Also be aware that deleting a base class pointer when there is no virtual destructor will result in undefined behavior   Something that I learned just recently   How should overriding delete in C   behave   I ve been using C   for years and I still manage to hang myself

User · Answer

I like to think about interfaces and implementations of interfaces  In C   speak interface is pure virtual class  Destructor is part of the interface and expected to implemented  Therefore destructor should be pure virtual  How about constructor  Constructor is actually not part of the interface because object is always instantiated explicitly

User · Answer

If you use shared ptr only shared ptr  not unique ptr   you don t have to have the base class destructor virtual    include  lt iostream gt   include  lt memory gt   using namespace std   class Base   public      Base            cout  lt  lt   Base Constructor Called n              Base       not virtual         cout  lt  lt   Base Destructor called n             class Derived  public Base   public      Derived            cout  lt  lt   Derived constructor called n              Derived            cout  lt  lt   Derived destructor called n             int main         shared ptr lt Base gt  b new Derived         output   Base Constructor Called Derived constructor called Derived destructor called Base Destructor called

User · Answer

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 virtual  Now  let s have a look at the following snippet   Base  b   new Derived       use b delete b     Here s the problem    Since Base s destructor is not virtual and b is a Base  pointing to a Derived object  delete b has undefined behaviour       In delete b   if the static type of the   object to be deleted is different from its dynamic type  the static   type shall be a base class of the dynamic type of the object to be   deleted and the static type shall have a virtual destructor or the   behavior is undefined    In most implementations  the call to the destructor will be resolved like any non-virtual code  meaning that the destructor of the base class will be called but not the one of the derived class  resulting in a resources leak   To sum up  always make base classes  destructors virtual when they re meant to be manipulated polymorphically   If you want to prevent the deletion of an instance through a base class pointer  you can make the base class destructor protected and nonvirtual  by doing so  the compiler won t let you call delete on a base class pointer   You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter

User · Answer

A virtual constructor is not possible but virtual destructor is possible  Let us experiment          include  lt iostream gt   using namespace std   class Base   public      Base            cout  lt  lt   Base Constructor Called n              Base            cout  lt  lt   Base Destructor called n             class Derived1  public Base   public      Derived1            cout  lt  lt   Derived constructor called n              Derived1            cout  lt  lt   Derived destructor called n             int main         Base  b   new Derived1        delete b      The above code output the following   Base Constructor Called Derived constructor called Base Destructor called   The construction of derived object follow the construction rule but when we delete the  b  pointer base pointer  we have found that only the base destructor is called  But this must not happen  To do the appropriate thing  we have to make the base destructor virtual  Now let see what happens in the following    include  lt iostream gt   using namespace std   class Base    public      Base            cout  lt  lt   Base Constructor Called n             virtual  Base            cout  lt  lt   Base Destructor called n             class Derived1  public Base   public      Derived1            cout  lt  lt   Derived constructor called n              Derived1            cout  lt  lt   Derived destructor called n             int main         Base  b   new Derived1        delete b      The output changed as following   Base Constructor Called Derived Constructor called Derived destructor called Base destructor called   So the destruction of the base pointer  which takes an allocation on derived object   follows the destruction rule  i e first the Derived  then the Base  On the other hand  there is nothing like a virtual constructor

User · Answer

Also be aware that deleting a base class pointer when there is no virtual destructor will result in undefined behavior   Something that I learned just recently   How should overriding delete in C   behave   I ve been using C   for years and I still manage to hang myself

User · Answer

A virtual constructor is not possible but virtual destructor is possible  Let us experiment          include  lt iostream gt   using namespace std   class Base   public      Base            cout  lt  lt   Base Constructor Called n              Base            cout  lt  lt   Base Destructor called n             class Derived1  public Base   public      Derived1            cout  lt  lt   Derived constructor called n              Derived1            cout  lt  lt   Derived destructor called n             int main         Base  b   new Derived1        delete b      The above code output the following   Base Constructor Called Derived constructor called Base Destructor called   The construction of derived object follow the construction rule but when we delete the  b  pointer base pointer  we have found that only the base destructor is called  But this must not happen  To do the appropriate thing  we have to make the base destructor virtual  Now let see what happens in the following    include  lt iostream gt   using namespace std   class Base    public      Base            cout  lt  lt   Base Constructor Called n             virtual  Base            cout  lt  lt   Base Destructor called n             class Derived1  public Base   public      Derived1            cout  lt  lt   Derived constructor called n              Derived1            cout  lt  lt   Derived destructor called n             int main         Base  b   new Derived1        delete b      The output changed as following   Base Constructor Called Derived Constructor called Derived destructor called Base destructor called   So the destruction of the base pointer  which takes an allocation on derived object   follows the destruction rule  i e first the Derived  then the Base  On the other hand  there is nothing like a virtual constructor

User · Answer

Virtual keyword for destructor is necessary when you want different destructors should follow proper order while objects is being deleted through base class pointer   for example   Base  myObj   new Derived       Some code which is using myObj object myObj- gt fun      Now delete the object delete myObj      If your base class destructor is virtual then objects will be destructed in a order firstly derived object then base    If your base class destructor is NOT virtual then only base class object will get deleted because pointer is of base class  Base  myObj    So there will be memory leak for derived object

User · Answer

I thought it would be beneficial to discuss the  undefined  behavior  or at least the  crash  undefined behavior that may occur when deleting through a base class  struct  without a virtual destructor  or more precisely no vtable   The code below list a few simple structs  the same would be true for classes     include  lt iostream gt  using namespace std   struct a        a           unsigned long long i      struct b   a        b           unsigned long long j      struct c   b        c           virtual void m3           unsigned long long k      struct d   c        d           virtual void m4           unsigned long long l      int main         cout  lt  lt   sizeof a      lt  lt  sizeof a   lt  lt  endl      cout  lt  lt   sizeof b      lt  lt  sizeof b   lt  lt  endl      cout  lt  lt   sizeof c      lt  lt  sizeof c   lt  lt  endl      cout  lt  lt   sizeof d      lt  lt  sizeof d   lt  lt  endl          No issue       a  a1   new a        cout  lt  lt   a1     lt  lt  a1  lt  lt  endl      delete a1          No issue       b  b1   new b        cout  lt  lt   b1     lt  lt  b1  lt  lt  endl      cout  lt  lt    a   b1     lt  lt   a   b1  lt  lt  endl      delete b1          No issue       c  c1   new c        cout  lt  lt   c1     lt  lt  c1  lt  lt  endl      cout  lt  lt    b   c1     lt  lt   b   c1  lt  lt  endl      cout  lt  lt    a   c1     lt  lt   a   c1  lt  lt  endl      delete c1          No issue       d  d1   new d        cout  lt  lt   d1     lt  lt  d1  lt  lt  endl      cout  lt  lt    c   d1     lt  lt   c   d1  lt  lt  endl      cout  lt  lt    b   d1     lt  lt   b   d1  lt  lt  endl      cout  lt  lt    a   d1     lt  lt   a   d1  lt  lt  endl      delete d1          Doesn t crash  but may not produce the results you want       c1    c   new d        delete c1          Crashes due to passing an invalid address to the method which        frees the memory       d1   new d        b1    b   d1      cout  lt  lt   d1     lt  lt  d1  lt  lt  endl      cout  lt  lt   b1     lt  lt  b1  lt  lt  endl      delete b1                This is similar to what s happening above in the  crash  case       char  buf   new char 32       cout  lt  lt   buf     lt  lt   void   buf  lt  lt  endl      buf    8      cout  lt  lt   buf after adding 8     lt  lt   void   buf  lt  lt  endl      delete buf         I m not suggesting whether you need virtual destructors or not  though I think in general it s a good practice to have them   I m just pointing out the reason you may end up with a crash if your base class  struct  does not have a vtable and your derived class  struct  does and you delete an object via a base class  struct  pointer   In this case  the address you pass to the heap s free routine is invalid and thus the reason for the crash   If you run the above code you ll see clearly when the issue occurs   When the this pointer of the base class  struct  is different from the this pointer of the derived class  struct  you re going to run into this problem   In the sample above  struct a and b don t have vtables   structs c and d do have vtables   Thus an a or b pointer to a c or d object instance will be fixed up to account for the vtable   If you pass this a or b pointer to delete it will crash due to the address being invalid to the heap s free routine   If you plan to delete derived instances which have vtables from base class pointers  you need to ensure the base class has a vtable   One way to do that is to add a virtual destructor  which you might want anyway to properly clean up resources

User · Answer

I think the core of this question is about virtual methods and polymorphism  not the destructor specifically  Here is a clearer example   class A   public      A          virtual void foo                 cout  lt  lt   This is A    lt  lt  endl            class B   public A   public      B          void foo                 cout  lt  lt   This is B    lt  lt  endl            int main int argc  char  argv          A  a   new B        a- gt foo        if a    NULL      delete a      return 0      Will print out   This is B    Without virtual it will print out   This is A    And now you should understand when to use virtual destructors

User · Answer

Make the destructor virtual whenever your class is polymorphic

User · Answer

What is a virtual destructor or how to use virtual destructor  A class destructor is a function with same name of the class preceding with   that will reallocate the memory that is allocated by the class  Why we need a virtual destructor  See  the  following  sample with some virtual functions  The sample also tell how you can convert a letter to upper or lower   include  stdafx h   include lt iostream gt  using namespace std     program to convert the lower to upper orlower class convertch   public      void convertch        virtual char  convertChar     0     convertch          class MakeLower  public convertch   public    MakeLower char  passLetter          tolower   true      Letter   new char 30       strcpy Letter  passLetter          virtual  MakeLower           cout lt  lt   called  MakeLower    lt  lt   n       delete   Letter         char  convertChar           size t len   strlen Letter       for int i  0 i lt len i          Letter i    Letter i    32      return Letter       private    char  Letter    bool tolower      class MakeUpper   public convertch   public    MakeUpper char  passLetter          Letter   new char 30       toupper   true      strcpy Letter  passLetter          char  convertChar              size t len   strlen Letter       for int i  0 i lt len i          Letter i    Letter i  - 32      return Letter         virtual  MakeUpper           cout lt  lt   called  MakeUpper    lt  lt   n       delete Letter       private    char  Letter    bool toupper       int  tmain int argc   TCHAR  argv        convertch  makeupper   new MakeUpper  hai       cout lt  lt   Eneterd   hai      lt  lt makeupper- gt convertChar   lt  lt             delete makeupper    convertch  makelower   new MakeLower  HAI       cout lt  lt  Eneterd   HAI      lt  lt makelower- gt convertChar   lt  lt         delete makelower    return 0      From the above sample you can see that the destructor for both MakeUpper and MakeLower class is not called   See the next sample with the virtual destructor   include  stdafx h   include lt iostream gt   using namespace std     program to convert the lower to upper orlower class convertch   public    void convertch      virtual char  convertChar     0  virtual  convertch         defined the virtual destructor     class MakeLower  public convertch   public  MakeLower char  passLetter    tolower   true  Letter   new char 30   strcpy Letter  passLetter     virtual  MakeLower     cout lt  lt   called  MakeLower    lt  lt   n         delete   Letter    char  convertChar     size t len   strlen Letter   for int i  0 i lt len i      Letter i    Letter i    32      return Letter     private  char  Letter  bool tolower      class MakeUpper   public convertch   public  MakeUpper char  passLetter    Letter   new char 30   toupper   true  strcpy Letter  passLetter     char  convertChar      size t len   strlen Letter   for int i  0 i lt len i      Letter i    Letter i  - 32    return Letter    virtual  MakeUpper           cout lt  lt   called  MakeUpper    lt  lt   n   delete Letter    private  char  Letter  bool toupper       int  tmain int argc   TCHAR  argv       convertch  makeupper   new MakeUpper  hai     cout lt  lt   Eneterd   hai      lt  lt makeupper- gt convertChar   lt  lt    n    delete makeupper  convertch  makelower   new MakeLower  HAI     cout lt  lt  Eneterd   HAI      lt  lt makelower- gt convertChar   lt  lt   n      delete makelower  return 0      The virtual destructor will call explicitly the most derived run time destructor of class so that it will be able to clear the object in a proper way   Or visit the link  https   web archive org web 20130822173509 http   www programminggallery com article details php article id 138

User · Answer

Virtual keyword for destructor is necessary when you want different destructors should follow proper order while objects is being deleted through base class pointer   for example   Base  myObj   new Derived       Some code which is using myObj object myObj- gt fun      Now delete the object delete myObj      If your base class destructor is virtual then objects will be destructed in a order firstly derived object then base    If your base class destructor is NOT virtual then only base class object will get deleted because pointer is of base class  Base  myObj    So there will be memory leak for derived object

User · Answer

A basic definition about virtual is it determines if a member function of a class can be over-ridden in its derived classes    A class s D-tor is called basically at the end of the scope  but there is a problem  for example when we define an instance on the Heap  dynamic allocation   we should delete it manually   As soon as the instruction get executed  the base class destructor get called  but not for the derived one   A Pratical example is when  in control field  you have to manipulate effectors  actuators   At the end of the scope  if the destructor of one of the power elements  Actuator   isn t called  there will be fatal consequences    include  lt iostream gt   class Mother   public       Mother               std  cout lt  lt  Mother Ctor  lt  lt std  endl             virtual Mother             std  cout lt  lt  Mother D-tor  lt  lt std  endl              class Child  public Mother       public       Child             std  cout lt  lt  Child C-tor  lt  lt std  endl              Child              std  cout lt  lt  Child D-tor  lt  lt std  endl            int main          Mother  c   new Child        delete c       return 0

User · Answer

Also be aware that deleting a base class pointer when there is no virtual destructor will result in undefined behavior   Something that I learned just recently   How should overriding delete in C   behave   I ve been using C   for years and I still manage to hang myself

User · Answer

Calling destructor via a pointer to a base class  struct Base     virtual void f        virtual  Base          struct Derived   Base     void f   override       Derived   override        Base  base   new Derived  base- gt f       calls Derived  f base- gt  Base       calls Derived   Derived   Virtual destructor call is no different from any other virtual function call   For base- gt f    the call will be dispatched to Derived  f    and it s the same for base- gt  Base   - its overriding function - the Derived   Derived   will be called   Same happens when destructor is being called indirectly  e g  delete base   The delete statement will call base- gt  Base   which will be dispatched to Derived   Derived     Abstract class with non-virtual destructor  If you are not going to delete object through a pointer to its base class - then there is no need to have a virtual destructor  Just make it protected so that it won t be called accidentally      library hpp  struct Base     virtual void f     0   protected     Base     default      void CallsF Base amp  base      CallsF is not going to own  base   i e  call  delete  amp base        It will only call Base  f   so it doesn t need to access Base   Base     -------------------    application cpp  struct Derived   Base     void f   override             int main       Derived derived    CallsF derived        No need for virtual destructor here as well

User · Answer

I like to think about interfaces and implementations of interfaces  In C   speak interface is pure virtual class  Destructor is part of the interface and expected to implemented  Therefore destructor should be pure virtual  How about constructor  Constructor is actually not part of the interface because object is always instantiated explicitly

User · Answer

Virtual base class destructors are  best practice  - you should always use them to avoid  hard to detect  memory leaks  Using them  you can be sure all destructors in the inheritance chain of your classes are beeing called  in proper order   Inheriting from a base class using virtual destructor makes the destructor of the inheriting class automatically virtual  too  so you do not have to retype  virtual  in the inheriting class destructor declaration

User · Answer

when you need to call derived class destructor from base class  you need to declare virtual base class destructor in base class

User · Answer

Calling destructor via a pointer to a base class  struct Base     virtual void f        virtual  Base          struct Derived   Base     void f   override       Derived   override        Base  base   new Derived  base- gt f       calls Derived  f base- gt  Base       calls Derived   Derived   Virtual destructor call is no different from any other virtual function call   For base- gt f    the call will be dispatched to Derived  f    and it s the same for base- gt  Base   - its overriding function - the Derived   Derived   will be called   Same happens when destructor is being called indirectly  e g  delete base   The delete statement will call base- gt  Base   which will be dispatched to Derived   Derived     Abstract class with non-virtual destructor  If you are not going to delete object through a pointer to its base class - then there is no need to have a virtual destructor  Just make it protected so that it won t be called accidentally      library hpp  struct Base     virtual void f     0   protected     Base     default      void CallsF Base amp  base      CallsF is not going to own  base   i e  call  delete  amp base        It will only call Base  f   so it doesn t need to access Base   Base     -------------------    application cpp  struct Derived   Base     void f   override             int main       Derived derived    CallsF derived        No need for virtual destructor here as well

User · Answer

A basic definition about virtual is it determines if a member function of a class can be over-ridden in its derived classes    A class s D-tor is called basically at the end of the scope  but there is a problem  for example when we define an instance on the Heap  dynamic allocation   we should delete it manually   As soon as the instruction get executed  the base class destructor get called  but not for the derived one   A Pratical example is when  in control field  you have to manipulate effectors  actuators   At the end of the scope  if the destructor of one of the power elements  Actuator   isn t called  there will be fatal consequences    include  lt iostream gt   class Mother   public       Mother               std  cout lt  lt  Mother Ctor  lt  lt std  endl             virtual Mother             std  cout lt  lt  Mother D-tor  lt  lt std  endl              class Child  public Mother       public       Child             std  cout lt  lt  Child C-tor  lt  lt std  endl              Child              std  cout lt  lt  Child D-tor  lt  lt std  endl            int main          Mother  c   new Child        delete c       return 0

User · Answer

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 virtual  Now  let s have a look at the following snippet   Base  b   new Derived       use b delete b     Here s the problem    Since Base s destructor is not virtual and b is a Base  pointing to a Derived object  delete b has undefined behaviour       In delete b   if the static type of the   object to be deleted is different from its dynamic type  the static   type shall be a base class of the dynamic type of the object to be   deleted and the static type shall have a virtual destructor or the   behavior is undefined    In most implementations  the call to the destructor will be resolved like any non-virtual code  meaning that the destructor of the base class will be called but not the one of the derived class  resulting in a resources leak   To sum up  always make base classes  destructors virtual when they re meant to be manipulated polymorphically   If you want to prevent the deletion of an instance through a base class pointer  you can make the base class destructor protected and nonvirtual  by doing so  the compiler won t let you call delete on a base class pointer   You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter

User · Answer

Any class that is inherited publicly  polymorphic or not  should have a virtual destructor  To put another way  if it can be pointed to by a base class pointer  its base class should have a virtual destructor    If virtual  the derived class destructor gets called  then the base class constructor  If not virtual  only the base class destructor gets called

User · Answer

when you need to call derived class destructor from base class  you need to declare virtual base class destructor in base class

User · Answer

I thought it would be beneficial to discuss the  undefined  behavior  or at least the  crash  undefined behavior that may occur when deleting through a base class  struct  without a virtual destructor  or more precisely no vtable   The code below list a few simple structs  the same would be true for classes     include  lt iostream gt  using namespace std   struct a        a           unsigned long long i      struct b   a        b           unsigned long long j      struct c   b        c           virtual void m3           unsigned long long k      struct d   c        d           virtual void m4           unsigned long long l      int main         cout  lt  lt   sizeof a      lt  lt  sizeof a   lt  lt  endl      cout  lt  lt   sizeof b      lt  lt  sizeof b   lt  lt  endl      cout  lt  lt   sizeof c      lt  lt  sizeof c   lt  lt  endl      cout  lt  lt   sizeof d      lt  lt  sizeof d   lt  lt  endl          No issue       a  a1   new a        cout  lt  lt   a1     lt  lt  a1  lt  lt  endl      delete a1          No issue       b  b1   new b        cout  lt  lt   b1     lt  lt  b1  lt  lt  endl      cout  lt  lt    a   b1     lt  lt   a   b1  lt  lt  endl      delete b1          No issue       c  c1   new c        cout  lt  lt   c1     lt  lt  c1  lt  lt  endl      cout  lt  lt    b   c1     lt  lt   b   c1  lt  lt  endl      cout  lt  lt    a   c1     lt  lt   a   c1  lt  lt  endl      delete c1          No issue       d  d1   new d        cout  lt  lt   d1     lt  lt  d1  lt  lt  endl      cout  lt  lt    c   d1     lt  lt   c   d1  lt  lt  endl      cout  lt  lt    b   d1     lt  lt   b   d1  lt  lt  endl      cout  lt  lt    a   d1     lt  lt   a   d1  lt  lt  endl      delete d1          Doesn t crash  but may not produce the results you want       c1    c   new d        delete c1          Crashes due to passing an invalid address to the method which        frees the memory       d1   new d        b1    b   d1      cout  lt  lt   d1     lt  lt  d1  lt  lt  endl      cout  lt  lt   b1     lt  lt  b1  lt  lt  endl      delete b1                This is similar to what s happening above in the  crash  case       char  buf   new char 32       cout  lt  lt   buf     lt  lt   void   buf  lt  lt  endl      buf    8      cout  lt  lt   buf after adding 8     lt  lt   void   buf  lt  lt  endl      delete buf         I m not suggesting whether you need virtual destructors or not  though I think in general it s a good practice to have them   I m just pointing out the reason you may end up with a crash if your base class  struct  does not have a vtable and your derived class  struct  does and you delete an object via a base class  struct  pointer   In this case  the address you pass to the heap s free routine is invalid and thus the reason for the crash   If you run the above code you ll see clearly when the issue occurs   When the this pointer of the base class  struct  is different from the this pointer of the derived class  struct  you re going to run into this problem   In the sample above  struct a and b don t have vtables   structs c and d do have vtables   Thus an a or b pointer to a c or d object instance will be fixed up to account for the vtable   If you pass this a or b pointer to delete it will crash due to the address being invalid to the heap s free routine   If you plan to delete derived instances which have vtables from base class pointers  you need to ensure the base class has a vtable   One way to do that is to add a virtual destructor  which you might want anyway to properly clean up resources

User · Answer

Declare destructors virtual in polymorphic base classes   This is Item 7 in Scott Meyers  Effective C     Meyers goes on to summarize that if a class has any virtual function  it should have a virtual destructor  and that classes not designed to be base classes or not designed to be used polymorphically should not declare virtual destructors

User · Answer

Any class that is inherited publicly  polymorphic or not  should have a virtual destructor  To put another way  if it can be pointed to by a base class pointer  its base class should have a virtual destructor    If virtual  the derived class destructor gets called  then the base class constructor  If not virtual  only the base class destructor gets called

User · Answer

Make the destructor virtual whenever your class is polymorphic

User · Answer

To be simple  Virtual destructor is to destruct the resources in a proper order  when you delete a base class pointer pointing to derived class object     include lt iostream gt   using namespace std   class B      public         B              cout lt  lt  B   n                   virtual  B               cout lt  lt   B   n                 class D  public B      public         D              cout lt  lt  D   n                    D              cout lt  lt   D   n                 int main        B  b   new D        delete b      return 0      OUTPUT  B   D    D    B                   If you don t give  B    as virtual  then output would be  B   D    B   where destruction of  D   is not done which leads to leak

User · Answer

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 virtual  Now  let s have a look at the following snippet   Base  b   new Derived       use b delete b     Here s the problem    Since Base s destructor is not virtual and b is a Base  pointing to a Derived object  delete b has undefined behaviour       In delete b   if the static type of the   object to be deleted is different from its dynamic type  the static   type shall be a base class of the dynamic type of the object to be   deleted and the static type shall have a virtual destructor or the   behavior is undefined    In most implementations  the call to the destructor will be resolved like any non-virtual code  meaning that the destructor of the base class will be called but not the one of the derived class  resulting in a resources leak   To sum up  always make base classes  destructors virtual when they re meant to be manipulated polymorphically   If you want to prevent the deletion of an instance through a base class pointer  you can make the base class destructor protected and nonvirtual  by doing so  the compiler won t let you call delete on a base class pointer   You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter

User · Answer

I think the core of this question is about virtual methods and polymorphism  not the destructor specifically  Here is a clearer example   class A   public      A          virtual void foo                 cout  lt  lt   This is A    lt  lt  endl            class B   public A   public      B          void foo                 cout  lt  lt   This is B    lt  lt  endl            int main int argc  char  argv          A  a   new B        a- gt foo        if a    NULL      delete a      return 0      Will print out   This is B    Without virtual it will print out   This is A    And now you should understand when to use virtual destructors

User · Answer

Make the destructor virtual whenever your class is polymorphic

User · Answer

If you use shared ptr only shared ptr  not unique ptr   you don t have to have the base class destructor virtual    include  lt iostream gt   include  lt memory gt   using namespace std   class Base   public      Base            cout  lt  lt   Base Constructor Called n              Base       not virtual         cout  lt  lt   Base Destructor called n             class Derived  public Base   public      Derived            cout  lt  lt   Derived constructor called n              Derived            cout  lt  lt   Derived destructor called n             int main         shared ptr lt Base gt  b new Derived         output   Base Constructor Called Derived constructor called Derived destructor called Base Destructor called

User · Answer

Also be aware that deleting a base class pointer when there is no virtual destructor will result in undefined behavior   Something that I learned just recently   How should overriding delete in C   behave   I ve been using C   for years and I still manage to hang myself

User · Answer

What is a virtual destructor or how to use virtual destructor  A class destructor is a function with same name of the class preceding with   that will reallocate the memory that is allocated by the class  Why we need a virtual destructor  See  the  following  sample with some virtual functions  The sample also tell how you can convert a letter to upper or lower   include  stdafx h   include lt iostream gt  using namespace std     program to convert the lower to upper orlower class convertch   public      void convertch        virtual char  convertChar     0     convertch          class MakeLower  public convertch   public    MakeLower char  passLetter          tolower   true      Letter   new char 30       strcpy Letter  passLetter          virtual  MakeLower           cout lt  lt   called  MakeLower    lt  lt   n       delete   Letter         char  convertChar           size t len   strlen Letter       for int i  0 i lt len i          Letter i    Letter i    32      return Letter       private    char  Letter    bool tolower      class MakeUpper   public convertch   public    MakeUpper char  passLetter          Letter   new char 30       toupper   true      strcpy Letter  passLetter          char  convertChar              size t len   strlen Letter       for int i  0 i lt len i          Letter i    Letter i  - 32      return Letter         virtual  MakeUpper           cout lt  lt   called  MakeUpper    lt  lt   n       delete Letter       private    char  Letter    bool toupper       int  tmain int argc   TCHAR  argv        convertch  makeupper   new MakeUpper  hai       cout lt  lt   Eneterd   hai      lt  lt makeupper- gt convertChar   lt  lt             delete makeupper    convertch  makelower   new MakeLower  HAI       cout lt  lt  Eneterd   HAI      lt  lt makelower- gt convertChar   lt  lt         delete makelower    return 0      From the above sample you can see that the destructor for both MakeUpper and MakeLower class is not called   See the next sample with the virtual destructor   include  stdafx h   include lt iostream gt   using namespace std     program to convert the lower to upper orlower class convertch   public    void convertch      virtual char  convertChar     0  virtual  convertch         defined the virtual destructor     class MakeLower  public convertch   public  MakeLower char  passLetter    tolower   true  Letter   new char 30   strcpy Letter  passLetter     virtual  MakeLower     cout lt  lt   called  MakeLower    lt  lt   n         delete   Letter    char  convertChar     size t len   strlen Letter   for int i  0 i lt len i      Letter i    Letter i    32      return Letter     private  char  Letter  bool tolower      class MakeUpper   public convertch   public  MakeUpper char  passLetter    Letter   new char 30   toupper   true  strcpy Letter  passLetter     char  convertChar      size t len   strlen Letter   for int i  0 i lt len i      Letter i    Letter i  - 32    return Letter    virtual  MakeUpper           cout lt  lt   called  MakeUpper    lt  lt   n   delete Letter    private  char  Letter  bool toupper       int  tmain int argc   TCHAR  argv       convertch  makeupper   new MakeUpper  hai     cout lt  lt   Eneterd   hai      lt  lt makeupper- gt convertChar   lt  lt    n    delete makeupper  convertch  makelower   new MakeLower  HAI     cout lt  lt  Eneterd   HAI      lt  lt makelower- gt convertChar   lt  lt   n      delete makelower  return 0      The virtual destructor will call explicitly the most derived run time destructor of class so that it will be able to clear the object in a proper way   Or visit the link  https   web archive org web 20130822173509 http   www programminggallery com article details php article id 138

User · Answer

Virtual base class destructors are  best practice  - you should always use them to avoid  hard to detect  memory leaks  Using them  you can be sure all destructors in the inheritance chain of your classes are beeing called  in proper order   Inheriting from a base class using virtual destructor makes the destructor of the inheriting class automatically virtual  too  so you do not have to retype  virtual  in the inheriting class destructor declaration

[c++] When to use virtual destructors?

Examples related to c++

Examples related to polymorphism

Examples related to shared-ptr

Examples related to virtual-destructor