Conventional base class in c plus plus?

Answer 1

A conventional base class is a class that has a virtual destructor. Virtual destructors are important in most class hierarchies because while we may not always know the exact type of the most-derived class in a hierarchy, we will always know at least one of its base classes. If we destroy that base, it is reasonable to expect the entire object to be destroyed, not just the base, and this can only be achieved with a virtual destructor.

Note that a virtual destructor must be declared in the least-derived class in the hierarchy to ensure correct polymorphic behaviour.

Classes not intended to be used as base classes do not have virtual destructors. This does not mean they cannot be used as base classes, but if you choose to use them as base classes you must be aware of the "unconventional" problems that can arise, particularly when destroying objects through pointers or references to their base classes as will lead to resource leaks.

If you do not wish a class to be used as a base class, then the class should be declared final (since C++11). All other classes can still be used as base classes, however only classes with virtual destructors behave polymorphically.

Typically, if we define at least one virtual function in a class, we should also define a virtual destructor for that class. However, derived classes implicitly inherit virtual destructors from their bases thus the absence of a virtual destructor in a derived class should not be taken to mean the derived class is not intended to be used as a base class; always look at the least-derived class definition to determine if a virtual destructor exists or not.

Along with the final specifier, the overridespecifier was also introduced in C++11. This makes it much easier to document virtual functions and their overrides. That is, we can use the virtual specifier solely to introduce a new virtual function into the class hierarchy, and use the overridespecifier to show that we are explicitly overriding a virtual function rather than simply introducing a new virtual function. We can also use the final specifier to indicate that an individual virtual function cannot be overridden any further:

struct X {

virtual void f ();

virtual ~X ();

};

struct Y : X {

void f () override; // implies X::f() is either virtual or is itself an override

~Y () override; // implies ~X() is virtual or is itself an override

};

struct Z : Y {

void f () override; // implies Y::f() is either virtual or is itself an override

~Z () override; // implies ~Y() is virtual or is itself an override

};

The override and final keywords are only useful if used consistently. However, being part of the language itself means we can now enlist the help of the compiler to catch subtle errors that couldn't be easily caught before:

struct X {

void f () override; // error! X did not inherit an f () thus it cannot be an override!

virtual void g (); // ok

virtual ~X(); // ok

};

struct Y : X {

void g () override final; // ok

~Y () override; // ok

};

struct Z : Y {

void g () override; // error! Y::f() is declared final -- it cannot be overridden!

~Z () override; // ok

};

struct Z2 : Z final {}; // ok

struct Z3 : Z2 {}; // error: Z2 is final -- cannot be used as a base class!

Answer 2

Base classes allow one class to derive from another. A derived class inherits all of the public and protected members of its base classes, thus a base class provides a common interface to all of its derivatives. Circles and squares are both types of shape, thus a shape class can be used as a common base class for both. This makes it possible to create collections of different types of objects, provided we hold references or pointers to the common base class of those objects.

Classes intended to be used as base classes usually have one or more virtual methods, thus enabling polymorphic behaviour. That is, whenever we invoke a virtual method, the most-derived override of that method is always executed regardless of which object in the hierarchy was used to invoke the method. In this way, base classes need not know anything about their derivatives; we obtain the correct behaviour by invoking the virtual methods we know about. This is important when we know the base class interface of an object at compile time but do not know the object's actual runtime-type. We could use a dynamic cast to obtain the actual runtime type, but a dynamic cast is much more expensive than invoking a virtual method and is often indicative of a design error. However, dynamic casts are useful when we don't have access to the base class source code and therefore cannot provide a suitable virtual interface.

Given that any class within a class hierarchy can be destroyed at any time, the least-derived base class or classes must have a virtual destructor to ensure the most-derived class is always destroyed first. Object construction, on the other hand, is always bottom-up, starting with the least-derived base class in the hierarchy. During construction of any given class, its direct base classes (if any) are constructed first, followed by its member objects. That is; a derived object cannot be constructed until all its base classes are constructed. Virtual destructors ensure object destruction is the exact reverse of object construction.

Abstract base classes are base classes that declare one or more pure-virtual methods. Unlike "ordinary" virtual methods which may be overridden by a derived class, pure-virtual methods must be overridden. Moreover, while a class that declares a virtual method must provide an implementation for that method, a pure-virtual method does not require an implementation. Once overridden by a derived class, a pure-virtual method becomes a virtual method with respect to any other derivatives of that class.

Abstract base classes differ from "ordinary" base classes in that they cannot be instantiated by themselves; they can only be instantiated through derivation. This mirrors real-life abstractions; we cannot instantiate a shape object by itself, we can only instantiate a specific type of shape, such as a square or circle. Thus the shape class is an abstraction; we can certainly imagine such an object exists, but it cannot physically exist by itself.