What is the process of creating a new derived class from a base class?

Answer 1

To derive a new class from an existing class, your new class must inherit from the existing class. This is achieved in the declaration of the class:

class oldclass{};
class newclass : public oldclass {};

In the above example, newclass inherits publicly from oldclass. What this means is that the public and protected members of oldclass are public and protected members of newclass. If you specify protected inheritance, the public members of oldclass become protected members of newclass. If you specify private inheritance, the public and protected members of oldclass become private members of newclass. Regardless of the type of inheritance specified at this point, you can still override the access of individually inherited members. In most cases you will use public inheritance unless there is a specific need to alter access rights to the base class members. Note that this does not affect the base class itself; only objects derived from the base class are affected.

Having inherited the base class and all its public and protected members, you can then override the base class behaviour to provide more specific methods and data members for your derivative. However, note that only virtual methods are expected to be overridden. If you override a non-virtual method, you will effectively hide the base class method along with any and all overloads of that method. Thus it is important to ensure the base class has a virtual destructor. If it doesn't, this will only lead to problems when your derived class falls from scope because derived classes must be destroyed in sequence, from the most-derived to the least-derived. This can only be achieved when all destructors other than the most-derived destructor are declared virtual.

It should also be noted that there's no point in having a base class with no virtual methods other than the destructor. The only reason for having a virtual destructor in the first place is because the base class has one or more virtual methods.

Abstract base classes are similar to normal classes except they also contain one or more pure-virtual methods. This means that you must provide an implementation for all the pure-virtual methods inherited from the base class (with normal virtual methods, overriding is optional) otherwise your derivative becomes an abstract base class itself. However, derived classes can inherit implementations of pure-virtual methods from other intermediate base classes, other than the one that initially declared the method pure-virtual, which itself may or may not provide an implementation.

It's often the case that, where an implementation is provided by a base class virtual method, you are expected to call that method from your derived class override. However some implementations may be expected to be completely overridden. The documentation for the base class will determine if and when to call the base class implementation.

In some cases, you may wish to derive a class from two or more base classes, known as multiple inheritance. To do so, you simply provide a comma-separated list, like so:

class base1{};
class base2{};
class derived : public base1, public base2 {};

When you combine multiple inheritance with multi-level inheritance, be aware that this may result in two or more instances of a common base class:

class base {};
class inter1 : public base {};
class inter2 : public base {};
class derived : public inter1, inter2 {};

This creates an ambiguity because derived inherits two separate instances of base, one from inter1 and the other from inter2. There are various ways to remove the ambiguity, however the preferred method is to make base a virtual base class, like so:


class base {};
class inter1 : virtual public base {};
class inter2 : public virtual base {};
class derived : public inter1, inter2 {};

Note that the virtual keyword can be placed before or after the inheritance specifier, it makes no difference. Now derived will inherit directly from base, and that one instance is shared with both inter1 and inter2. There may still be ambiguity where both inter1 and inter2 override the same virtual method of base, but this can be easily dealt with by providing a more specific override in the derived class.