What is Virtua Deconstructor?

Construction always happens from base to derived. And destruction 'should' happen from derived to base. If you are not using virtual function mechanism, it will work as expected, but consider following example,

base *p = new derived();

Here compiler assumes that, p is 'base' type. So unless you make destructor virtual, it will not call derived's destructor. Which may led to memory leak.

All of these entities only exist for classes that have virtual functions, or are derived from a class that has.

For non-virtual functions, the compiler can resolve any function call at compile time. It is translated into a jump to a different address of the code base. For virtual functions however, the function that has to be called depends on the class type of the object that the function is called on, and that type may not be known at compile time.

As a help to determine these things at run time, the compiler generates a vtable for each class with virtual functions (at compile time, obviously). That table contains function pointers to the methods of this class. At runtime, whenever an object of a class with virtual fucntions is created, it will be intialized with a pointer to that function table corresponding to its class. When a potentially virtual method is called on that object, the runtime system will follow the function table pointer and then look up the function within the referenced vtable.

The exact details of how the entries in a vtable and a vptr look like, depends on the compiler. It may vary for different versions of a compiler. It may even vary depending on the exact type of the class! As a programmer, you shouldn't care about that, unless you're developing a compiler yourself. In that case, you could try and check out the specific compiler documentation.

Essentially, if a desctructor is declared virtual you can properly delete that object using a pointer of a base class type.

Generally if a class has some virtual functions, its desctructor should be made virtual.