We often use the term “Inheritance” in a programming context. It’s a feature practised in programming to make the best reuse of the codes.  If you recall the concept of “IS-A” in OOP (Object Oriented Programming), you will find it’s based on the Inheritance feature. The implementation of inheritances will help you gain advanced project ideas in C++.

Inheritance is a potent concept in object-oriented programming that enables the construction of new classes based on preexisting ones. One of the interesting types of inheritance that C++ allows is “hybrid inheritance.” To help you better understand hybrid inheritance, this blog will explore its definition, types, and applications.

What is Inheritance?

In the process of Inheritance, the objects of one class acquire the properties and behaviour of another class. Here a new class is derived from the existing base class.  The member class derived is usually called a child class and the base class member of the parent class. After the child class is derived, it inherits all the properties and methods from the parent class.

Additionally, the child class can have its exclusive properties and methods intended for a purpose. The additional features added locally to an existing class will not affect the properties it inherited from the parent class. Thus, the new class will have combined features of both classes.

Check out our free courses to get an edge over the competition.

Inheritance in C++ permits the acquisition of characteristics and behavior from one class by another. A base class is the parent class of a derived class, which is what it inherits from. In addition to inheriting, the child class may have unique attributes and methods designed for particular uses. Importantly, features added locally do not affect inherited characteristics, so the combined traits of parent and child classes are easily incorporated into the new class. In C++, this dynamic enables effective code reuse and adaptable class hierarchies.

Explore Our Software Development Free Courses

Inheritance in C++

Often, in reality, a programmer needs to develop an object that has to:
1)  possess all qualities of its parent, and additionally,
2)  in some aspects, persistence is special. 

Coding such exceptional properties in the main class may not necessarily be practical and economical. In that case, a new class is derived by extending the base class. Also, deriving it from another class having additional qualities. In this manner, you can reuse, extend, or modify attributes and behaviours which are defined in other classes. Thus the child class derived from multiple classes gives an object that is easy to maintain and port. The derived class is the specialized class for the base class. 

Technically, the keyword “extends” is used to inherit a class. C++ uses the colon (“:”) symbol to inherit from a class.

Check out upGrad: Advanced Certification in DevOps

When creating objects in C++ programming that require a dual nature—that is, having both unique properties that distinguish them from their parent and all of the qualities of their parent—inheritance plays a crucial role. It’s possible that the traditional method of adding exceptional qualities straight into the main class isn’t always practical or economical.

A new class that extends the base class and might even derive from another class with extra properties is created to solve this. This method promotes code efficiency and maintainability by enabling the reuse, extension, or change of characteristics and actions defined in different classes. 

A complex object that seamlessly combines inherited traits while accommodating specialized attributes is created by deriving a child class from multiple classes. This results in a remarkable 20% code efficiency that is simple to maintain and easily portable across various contexts. By optimizing development processes and application speed, programmers can construct versatile and adaptive objects with hybrid inheritance in C++ program.

Types of Inheritances

The use of a combination of inheritances and implementation differ for a purpose the classes are derived. There are different types of inheritances available in C++, as listed below:

• Single Inheritance is where a derived class inherits properties and behaviour from a single base class. Example: Class A → Class B. 

In object-oriented programming (OOP), in other words, there can only be one parent class for a derived or child class.

Single inheritance encourages code reuse and creates a hierarchical link between the classes by passing down the methods and attributes of the single base class to the derived class. In addition to adding new properties and methods, the derived class can modify or expand the features inherited from the source class.

Here’s a basic hybrid inheritance program in C++:

Using namespace std, #include <iostream>;

// The base class Animal { public: void eat() { cout \\ "Animal is eating" \\ endl;

// Derived class with only one inheritance Dog: public Animal { public: void bark() { cout \\ "Dog is barking" \\ endl; ;

The function int main() { Dog myDog; myDog.eat(); Inherited from Animal class myDog.bark(); Specifically for Dog class

    0 is returned;

In this instance, single inheritance is used to create the Dog class from the Animal class. The Dog class adds its own method, bark(), and inherits the Animal class's eat() method.

• Hierarchical Inheritance is where more than one derived class is created from a single base class. Example: Class A →  Class B → Class C.In object-oriented programming (OOP), numerous derived classes inherit from a single base or parent class. This kind of inheritance establishes a hierarchical structure using a single base class as the common ancestor of several derived classes.Many specialized classes share the base class features, each representing a more focused or specialized variation of the base class in a hierarchical inheritance structure. As a result, it is possible to create a well-organized class hierarchy and reuse code.Here’s a basic hybrid inheritance example:

  #involve 
  
  using the std namespace;
  
  // Foundational class
  
  class Form {
  
  general public:
  
      draw() void
  
          "Drawing a shape" \\ endl;
  
  // Origin of class 1
  
  circle class: public Shape {
  
  general public:
  
      drawCircle() void {
  
          The line "Drawing a circle" ends at cout;
  
  // Originating class 2
  
  Rectangle class: public Shape {
  
  general public:
  
      drawRectangle() is void.
  
          "Drawing a rectangle" \\ cout \\ endl;
  
  main() int
  
      Revolve in a circle;
  
      rectangular shape;
  
      circle.draw(); // Derived from the class Shape
  
      circle.drawCircle(); // Exclusive to the class Circle
  
      rectangle.draw(); // Derived from the class Shape
  
      Draw a rectangle.Rectangle(); // Exclusive to the Rectangle type
  
      yield 0;
  
  The Circle and Rectangle classes share the base class Shape in this example. This illustrates the hierarchical relationship with Shape serving as the base class and Circle and Rectangle as specialized derived classes. Hierarchical inheritance is demonstrated by the fact that each derived class adds its own unique methods (drawCircle() and drawRectangle()) to the base class's shared draw() method.

• Multiple Inheritance is for deriving a class from multiple base classes. Here, the child objects programmers create will have combined aspects of characteristics and features from multiple parent classes. These objects do follow their hierarchies of base classes. This means in object-oriented programming (OOP), a derived or child class may have more than one parent class.This promotes code reuse and establishes intricate class hierarchies, enabling the derived class to inherit properties and methods from many source classes. The “diamond problem,” in which several paths in the hierarchy inherit the same class, is one issue that can arise from multiple inheritance.Here’s a basic hybrid inheritance in C++ example:

  Compiler

  m

• Multilevel Inheritance is where a child class is derived from another derived class. This feature carries combined aspects of multiple classes and follows their hierarchies.This means within this inheritance, a derived class acts as the base class for another class, resulting in a chain of inheritance. Simply put, it involves a hierarchy of classes, each inheriting from the class directly above it.Here’s a basic example of hybrid inheritance in C++:Compiler

  Copy the programming

  <iostream> #include
  
  using the std namespace;
  
  // Foundational class
  
  category Animal {
  
  general public:
  
      empty eat() {
  
          cout \\ endl; "Animal is eating" \\
  
  // Class 1 (derived; inherits from Animal)
  
  class Dog: Animal in public
  
  general public:
  
      empty bark() {
  
          the line "Dog is barking" \\ endl;
  
  // Derived class 2 (dog inheritance)
  
  class Bulldog: canine in public
  
  general public:
  
      guard() void {
  
          cout \\ endl; "Bulldog is guarding" \\
  
  main() int
  
      MyBulldog, the Bulldog
  
      myBulldog.eat(); // Derived from the class Animal
  
      Bark(); myBulldog; // Derived from Dog class
  
      myBulldog.guard(); // Exclusive to the class Bulldog
  
      yield 0;

  In this instance, a base-to-derived relationship is created as the Dog class is descended from the Animal class. Therefore, a chain of inheritance is formed when the Bulldog class is derived from the Dog class. The eat() and bark() methods from the Animal and Dog classes are inherited by the Bulldog class, which also adds its own method, guard(). 

• Hybrid Inheritance is a heterogeneous feature of using multiple inheritances. Here a child class is derived from one or more combinations of single, hierarchical, and multilevel inheritances. This inheritance is adopted for programs to mix different types of inheritance; for example, when mixing a single inheritance with multiple inheritances or maybe a situation when multiple inheritances are mixed within a single program.Applying hybrid inheritance in OOPs helps develop codes faster, enhances code reusability, reduces errors in codes, and helps create better-defined relationships between classes.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Check Out upGrad Java Bootcamp

Simple Example

Here Class B and Class C both are derived from the base class, Class A.

A hierarchical classification of Cars shows two classes. Both “Petrol Cars” and “Electric Cars” are derived from the base Class ‘Cars. 

Hybrid Inheritance In C++

There could be situations where we need to apply two or more types of inheritance combined to design a program. When a program involves more than one type of inheritance, it is called Hybrid Inheritance.

Hybrid inheritance is a combination of simple, multiple inheritance and hierarchical inheritance. Usually, in multiple inheritances, a class is derived from two classes where one of the parent classes is also a derived class and not a base class. 

Hybrid inheritance in C++ is the inheritance where a class is derived from more than one form or combinations of any inheritance. The hybrid inheritance in C++ is also called multipath inheritance, where one derived class can inherit properties of the base class in different paths. Sometimes also called multipath inheritance. For example, it can be achieved with a combination of both multilevel and hierarchical inheritance.

In short, hybrid inheritance is a combination of two or more types of inheritance. For example, by implementing single and multilevel inheritances in the same program.

Advantages of Hybrid Inheritance in C++

In C++, hybrid inheritance has various benefits, making it a strong and adaptable programming model.

Reusability of Code

Code from several base classes can be reused thanks to hybrid inheritance in Python, which encourages new classes to use pre-existing functionality effectively.

Flexibility in the Class Structure

Combining single, multiple, and multilayer inheritance allows developers to design flexible and sophisticated class hierarchies that may be tailored to unique application requirements.

Modalities in Design

Programmers can create classes with characteristics inherited from several sources via hybrid inheritance, allowing them to change and adapt the codebase without limitations.

Improved Flexibility

Combining various inheritance types improves modularity since classes may be created to encapsulate particular functions, making codes easier to understand and maintain.

Differentiation and Broadcasting

Hybrid inheritance offers a balanced approach to class design by enabling both specialization (adding unique characteristics to derived classes) and generalization (inheriting common features from numerous classes).

Better Capability to Read

When used wisely, hybrid inheritance in Python can enhance code readability by arranging related features into a logical class hierarchy.

Flexibility in Response to Changing Needs

Hybrid inheritance‘s adaptability makes it simpler to change course when project requirements do. Existing classes can be expanded upon and changed by developers without requiring a lot of reorganization.

Effective Use of Resources

Hybrid inheritance allows developers to use existing code instead of creating duplicate features by allowing them to inherit from various classes, which can result in optimal resource utilization.

Despite these benefits, it’s vital to remember that careful design is necessary to minimize potential complications and guarantee that the advantages of hybrid inheritance are realized without jeopardizing the codebase’s maintainability.

Block Diagram of Hybrid Inheritance

The diagram represents the hybrid combination of two inheritances; the single inheritance and the multiple inheritances. Here, in single inheritance, class B is derived from class A. Similarly, in multiple inheritances, Class D is inherited from multiple classes. Here class B and class C. So, a mix of single inheritance and multiple inheritances forms a hybrid inheritance.

Hybrid inheritance is applicable in the scenarios where we are required to apply more than one inheritance in a program.

Explore our Popular Software Engineering Courses

Syntax of Hybrid Inheritance In C++

A typical syntax and semantic for hybrid inheritance in C++ will follow as illustrated below:

Examples of Hybrid Inheritance In C++

Example 1:  Single + Multiple Inheritance

Let’s see how single and multiple inheritances are implemented.

Each block in this diagram represents a class, and the corresponding arrow the inheritance of a class.

Example 2: Single + Multilevel Inheritance

We can also implement other types of inheritance to constitute hybrid inheritances.

Let’s consider a Real-time example.

We derive a car subclass from the class Vehicle. Another class characterizes Racing. When we derive a final entity, both from the Car class and the Racing class, it will give a combined output. This derivative is Ferrari – the racing car.

Here is a simple program to illustrate the concept of hybrid inheritance in C++.

The Sample Code

The Output

Learn Software development Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Read our Popular Articles related to Software Development

Conclusion

Hope this article helped you to understand the concept and types of Hybrid Inheritance in C++. Students in the stream of computer and computing-related programs can enhance their skills and technical credibility, such as OOP concepts. upGrad provides resources and a knowledge base to encourage such professionals to expertise in programming and compete in the industry market. At upGrad, you also get an opportunity to explore professional networking and skill development. 

We hope you will have an excellent learning opportunity in executing these C++ projects. If you are interested to learn more and need mentorship from industry experts, check out upGrad & IIIT Banglore’s Executive PG Program in Full-Stack Software Development.