What is the process of inheritance in c plus plus?

Answer 1

There are two ways to create a new class from an existing class (and thus make use of the existing code without duplicating that code). We can either embed an instance of the existing class as a member of the new class or we can derive the new class from the existing class. The former method is known as composition while the latter is known as inheritance. Composition is necessary when the member is a fundamental (built-in) data type but can also be applied to user-defined types while inheritance can only be applied to user-defined types.

Although a class may inherit from any user-defined type, some classes are not intended for this purpose thus they can only be used in compositions. In order to derive a new class from an existing class, the existing class must be a base class. The minimum definition of a base class is that the class must have a virtual destructor. Fundamental types have neither a constructor nor a destructor, hence they cannot act as base classes.

Base classes typically have one or more virtual methods thus if you declare any virtual methods you must also declare a virtual destructor. Note that, unlike Java where all methods are virtual by default, C++ methods are always non-virtual by default.

When you derive a new class from a base class, the new class inherits all the public and protected methods of the base class, but none of the private members nor any friends of the base class.

Virtual methods of the base class are methods that are expected to be overridden by its derivatives. If the base class is an abstract base class it will also have one or more pure virtual methods. These methods must be overridden by a derivative otherwise that derivative becomes abstract also. Derived classes may also act as base classes.

You may also override non-virtual methods, however these are not treated as overrides. These have the affect of "hiding" the base class implementation and will prevent polymorphic behaviour.

Polymorphism is achieved through virtual methods. When a virtual method is implicitly invoked, the most-derived override of that method is automatically invoked, regardless of the source of the call. This makes it possible for a base class to invoke the more specific behaviour of its own derivative without requiring any specialised knowledge about those derivatives. In other words, it allows us to write code in a more generic manner, catering for new types of derivative that do not yet exist. Those types inherit all the generic methods and can specialise those methods as required.

In some cases we may wish to prevent any further specialisation of a particular method. To do so we can specify that the override is final. If we derive a new class from this class and attempt to override a final method, a compiler error will tell us that this is illegal. We can also use this facility to prevent any further specialisation of a class by declaring the class itself as final.

All methods that are declared virtual in a base class are implicitly virtual in the derived class, whether overridden or not. Therefore we can override those methods without explicitly declaring them virtual. Although it is considered good programming practice to explicitly include the virtual specifier in an override, C++11 allows us to explicitly use the override specifier instead, thus providing a visual clue that the method was inherited rather than merely declared virtual.

Note that when a base class declares a virtual destructor, the derived class destructor is implicitly virtual as well (including the compiler-generated default destructor). However, destructors are not functions per se and are not inherited as such. However, the virtual aspect of the destructor is required to ensure that an object is destroyed in the correct sequence. If you hold a pointer to a base class object and destroy that object, the most-derived object in the inheritance hierarchy must be destroyed first -- which is why the destructor must be virtual. If it were not declared virtual, only the base class would be destroyed, which would leave an incomplete derived object in memory, which would inevitably result in undefined behaviour should you later attempt to destroy that derivative.

Note that the destruction sequence of a derived object is the complete opposite of the construction sequence. To construct a derived object, its least-derived base class constructor must be invoked first. This is why constructors can never be declared virtual.

In addition to the constructors, an object's copy assignment operator (and its move move assignment operator in C++11) cannot be declared virtual either. Each class of object must define their own operator or use the compiler-generated default operator.