#Virtual desktop frame skips manual
#Virtual desktop frame skips code
#Virtual desktop frame skips free

This is your fault though, not that of the baseclass not having a virtual destructor. C++ allows you to shoot yourself in the foot. A class not designed as baseclass should not be inherited from, like e.g.

#Virtual desktop frame skips manual

In this case I don't mean the manual memory management, which is bad in and of itself, but deriving publicly from this class.

#Virtual desktop frame skips code

If your class is not a baseclass, you will hopefully not write code like this.However, there are several assumptions there that need to be make explicit: This kind-of sidesteps the question, so let me elaborate: As many pointed out, you get undesired behaviour if you invoke delete base_ptr and the destructor is not virtual. However, let me add one more with a different view on the issue: You need a virtual destructor if you want to polymorphically delete instances of this class. I think most answers here miss the point, with the exception of the accepted one, which is a good thing. One way to do that is to add a virtual destructor, which you might want anyway to properly clean up resources. If you plan to delete derived instances which have vtables from base class pointers, you need to ensure the base class has a vtable.

#Virtual desktop frame skips free

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. Thus an a or b pointer to a c or d object instance will be fixed up to account for the vtable. In the sample above, struct a and b don't have vtables. 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. If you run the above code you'll see clearly when the issue occurs. In this case, the address you pass to the heap's free routine is invalid and thus the reason for the crash. 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. I'm not suggesting whether you need virtual destructors or not, though I think in general it's a good practice to have them.

This is similar to what's happening above in the 'crash' case.Д¬out << 'buf after adding 8: ' << (void*) buf << endl Crashes due to passing an invalid address to the method which Doesn't crash, but may not produce the results you want. The code below list a few simple structs (the same would be true for classes). 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 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. On the other hand, there is nothing like a virtual constructor.Д¬alling destructor via a pointer to a base class struct Base // defined the virtual destructor

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. The output changed as following: Base Constructor Called You can learn more about virtuality and virtual base class destructor in this article from Herb Sutter.ДЄ virtual constructor is not possible but virtual destructor is possible. 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. To sum up, always make base classes' destructors virtual when they're meant to be manipulated polymorphically. 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. Type shall be a base class of the dynamic type of the object to beДeleted and the static type shall have a virtual destructor or the Object to be deleted is different from its dynamic type, the static Since Base's destructor is not virtual and b is a Base* pointing to a Derived object, delete b has undefined behaviour: Now, let's have a look at the following snippet: Base *b = new Derived() Here, you'll notice that I didn't declare Base's destructor to be virtual. Virtual destructors are useful when you might potentially delete an instance of a derived class through a pointer to base class: class Base