What are virtual constructors or destructors?

Answer 1

If an object (with a non-virtual destructor) is destroyed explicitly by applying the delete operator to a base-class pointer to the object, the base-class destructor function (matching the pointer type) is called on the object. There is a simple solution to this problem

Answer 2

The term virtual constructor is often used (somewhat erroneously) when referring to an object factory. That is, a function or class which is used to instantiate objects of more than one type. However, there can never be a situation where we can construct an object of unknown type let alone construct a derived object knowing only its base class, thus there is no such thing as a virtual constructor.

We use a virtual function (also known as a method) to define a runtime interface; an interface to a method that may or may not be known at compile time but which must be known at runtime. Whenever we invoke that method, we expect the most-derived override of that method to be invoked, regardless of which (known) interface we use to invoke that method. This ensures objects behave according to their actual runtime type even when the runtime type cannot be determined at compile time (also known as runtime polymorphism).

During construction, the runtime type of the object being constructed has to be known at compile time because, as previously mentioned, we cannot construct an object of unknown type. After all, if we don't know runtime type of the object we wish to construct, what chance would the compiler have? If we must know the runtime type of the object we wish to construct, what benefit would a virtual constructor provide given there can be no construction override that is more derived than that of the object we wish to construct?

If we want an object of type X, then we must explicitly invoke an X::X constructor. If Y derives from X and we really wanted a Y then we must explicitly invoke a Y::Y constructor. There is no need for a virtual constructor because we always know the exact type of the object we wish to construct at compile time and what is known at compile time can always be statically bound; there is no need to use the virtual function call mechanism (dynamic binding).

Not only must we know the exact type of the object itself, we must also know the exact type of all its bases. That's important because in order to construct a Y which is derived from X, we must first construct an X. The compiler knows this because we already told it that Y derives from X; it's an integral part of the Y class definition. Moreover, when X has a choice of constructors available, we can explicitly instruct the compiler as to which specific X::X to invoke for any given Y::Y. Again, this is an integral part of the Y class definition; even if we do not specify which base class constructor to invoke, its default constructor is implied (if it doesn't have one then Y::Y is ill-formed).

Remember that construction is always bottom-up, starting with the least-derived class. The virtual function call mechanism is intended to provide runtime access to the most-derived override of a given method (regardless of which interface is used) but, during construction, the most-derived method does not exist until all the base classes of the class that defines it have been fully constructed. This is why we (generally) avoid invoking a virtual method from within a constructor. It makes even less sense for the constructor itself to be virtual because there can never be a more-derived constructor than the one that is currently executing!

Destruction, of course, is the complete opposite of construction. Destruction is top-down, destroying the most-derived class first. Thus, invoking a virtual method from within a destructor is best avoided because the most-derived override cannot be any more derived than the class that is currently being destroyed. If a more-derived override existed, it's no longer available!

This does not mean we cannot invoke virtual methods during construction or destruction, but we must be aware of the consequences of doing so. Remember that an object only exists from the point its constructor returns until the point its destructor is invoked. During construction or destruction the object being created or destroyed only exists insofar as its bases exist. At best, it is only a partial object.

Answer 3

There is no such thing as a virtual constructor. Constructors are local to the class in which they are declared, and therefore cannot be inherited. Derived classes will call the default constructor of the least-derived base class first, unless a specific base class construction overload is called via the derived class's initialisation list. All base class constructors required by derived classes must be declared protected or public (private constructors are inaccessible), but no constructor can be declared virtual.

Destructors only need to be declared virtual when there are one or more virtual or pure-virtual methods declared in the class. Derived classes do not need to declare virtual destructors since it is implied by their base class. The only reason for having virtual destructors is to ensure the most-derived class destructor is called first whenever its base class falls from scope. Destruction then cascades up the hierarchy to the base class, which must be destroyed last.

Answer 4

There is no such thing as a pure-virtual destructor. Classes can declare destructors to be virtual to ensure base class destructors call their derived class destructors first, but they cannot be declared pure virtual. This would imply the class is abstract and that the destructor must be overridden by all derived classes. But class destructors cannot be overridden. Every class, including an abstract class, must handle its own destruction. The only reason to declare a virtual destructor (but not a pure-virtual destructor) is when the class has one or more virtual methods besides the destructor.