virtual destructors

When should i make the destrucor virtual.Is it when I have virtual functions in my class.
But if I dont make the destructor virtual it still works!

Quote:

---

Originally Posted by crvenkapa

When should i make the destrucor virtual.Is it when I have virtual functions in my class.
But if I dont make the destructor virtual it still works!

---

It works until you try to delete an object via a pointer to a base class instead of a pointer to the actual class itself...

Your destructor should be virtual if the class will be derived from. Here's an example where the destructor of a base class is not declared virtual:

Code:

---

#include <iostream>

class Base
{
public:
  ~Base() { std::cout<<"Base::~Base\n"; }
private:
};

class Derived: public Base
{
public:
  ~Derived() { std::cout<<"Derived::~Derived\n"; }
};

int main()
{
  {
  Derived d1;
  Base* d2 = new Derived;
  delete d2; //only base destructor called
                  //this is not the behavior we want

  } //derived and base destructor called for d1

}

---

When your child class derives from a base class and you are using pointers to allocate your classes

Code:

---

#include <iostream>

class CBaseClass
{
public:
        CBaseClass() : mVal(10){}
        ~CBaseClass()
        {
                std::cout<<"Base Destructor";
                std::cin.get();
        };
protected:
        int mVal;
};

class CChildClass : public CBaseClass
{
public:
        CChildClass()
        {
                mPtr = new int;
        }
        ~CChildClass()
        {
                std::cout<<"Child Destructor";
                delete mPtr;
                std::cin.get();
        }       
private:
        int *mPtr;
};

int main()
{
        CBaseClass *childClass = new CChildClass();

        delete childClass;
}

---

What doesn't get called here? That is no good now we have a memory leak.

Now the proper way:

Code:

---

#include <iostream>

class CBaseClass
{
public:
        CBaseClass() : mVal(10){}
        virtual ~CBaseClass()
        {
                std::cout<<"Base Destructor";
                std::cin.get();
        };
protected:
        int mVal;
};

class CChildClass : public CBaseClass
{
public:
        CChildClass()
        {
                mPtr = new int;
        }
        virtual ~CChildClass()
        {
                std::cout<<"Child Destructor";
                delete mPtr;
                std::cin.get();
        }       
private:
        int *mPtr;
};

int main()
{
        CBaseClass *childClass = new CChildClass();

        delete childClass;
}

---

What happens here. Looks like everything got clean up and was called.

>> Your destructor should be virtual if the class will be derived from.
Publically derived from and used polymorphically. There are some cases where classes can be publically derived from but are not intended to be used polymorphically, so the virtual destructor is not necessary.

Also, in JaWiB's example when you delete d2 (or in prog-bman's first example), the result is undefined behavior. It might actually work. It might also crash. If it does work on your machine this time, you cannot rely on that, and should therefore always make the destructor virtual if the class is intended to be a base class that is used polymorphically.

Probably worth noting that none of the standard library classes have virtual destructors (to the best of my knowledge) so be careful if you decide to subclass them publicly.

Doesn't matter so much for private and protected inheritance.

Quote:

---

Doesn't matter so much for private and protected inheritance.

---

Pardon me for interjecting on this point, but I think this isn't accurate if you mean that virtual destructors could be avoided if inheritance is private or protected.

I think the importance is the same - could you explain?

Generally privately inherited classes are not used polymorphically, which is why it is not necessary to make the destructor virtual in those cases.