Types of Inheritance in C++ What Should You Know?

Have you ever wondered how some popular software systems are built? It’s all thanks to a powerful mechanism called inheritance in object-oriented programming (OOP). Inheritance allows programmers to create new classes built upon existing ones, enabling code reuse and efficient software development. Imagine you are building a system that requires several classes, each of which shares some common attributes and behaviours. 

Instead of writing the same code repeatedly, you can use inheritance to create a base class and derive new classes from it, saving you time and effort.

Inheritance is not only efficient but also versatile. In C++, there are several types of inheritance, each with unique benefits and use cases. 

In this article, we’ll take a complete look at the different types of inheritance in C++, providing relevant codes, explanations and real-life examples throughout the article. 

Different Types of Inheritance in C++

C++ programming language offers five different kinds of inheritance options to its programmers. Depending on the context and the requirements, developers and programmers can work with either of these types of inheritance. 

Single Inheritance

Single inheritance is the most common type of inheritance in C++. In single inheritance, a derived class inherits from a single base class. This means that a class inherits all the public and protected data members and member functions of the base class while having the ability to add its own data members and member functions.

Check out the code snippet below to get the syntax and understanding of single inheritance: 

// Base Class

class Animal {

public:

    void eat() {

        std::cout << “Animal is eating” << std::endl;

    }

};

// Derived Class

class Dog : public Animal {

public:

    void bark() {

        std::cout << “Dog is barking” << std::endl;

    }

};

In this example, we have a base class called Animal with a single member function eat(). We then define a derived class Dog that inherits publicly from Animal. Dog also has its own member function bark(). By using single inheritance, Dog can access the eat() function of the Animal class and add its own behaviour with the bark() function.

When to use Single Inheritance in C++

Programmers can use single inheritance to create a derived class that adds functionality to the base class. 

For example, you can use single inheritance when creating a game involving different characters, such as warriors, mages, and archers. All of these characters share some common attributes and behaviours, such as health points, attack power, and movement speed. By using single inheritance, you can create a base class called Character that contains the common attributes and behaviours and derive each character class from it to add their unique functionality.

In multiple inheritance, one derived class can inherit from multiple base classes. This means that a class can have more than one direct parent class. As a result, the derived class inherits all the public and protected data members and member functions of each base class.

Here’s an example of multiple inheritance:

// Base Class 1

class Shape {

public:

    virtual double area() = 0;

};

// Base Class 2

class Color {

public:

    virtual std::string getColor() = 0;

};

// Derived Class

class Rectangle : public Shape, public Color {

public:

    double area() override {

        return width * height;

    }

    std::string getColor() override {

        return color;

    }

private:

    double width = 5.0;

    double height = 3.0;

    std::string color = “blue”;

};

In this example, we have two base classes, Shape and Color, each with its virtual function. We then define a derived class Rectangle that inherits from both Shape and Color. Rectangle overrides the virtual functions of both base classes to provide its own implementation. By using multiple inheritance, Rectangle can inherit the properties of both base classes, Shape and Color, to create a rectangle with a specific colour and area.

When to use Multiple Inheritance in C++

Use multiple inheritance when you want to combine functionality from multiple base classes. For example, consider a GUI application that requires different types of controls, such as buttons, checkboxes, and textboxes. Each control type has its functionality and behaviour, but they also share some common functionality, such as handling user events and displaying text. 

By using multiple inheritance, you can create a base class called Control that contains the common functionality, and derive each control type from it, as well as other base classes that contain their specific functionality.

In hierarchical inheritance, a single base class is inherited by multiple derived classes. Like multiple inheritance, the derived classes in hierarchical inheritance obtain all the public and protected data members and member functions of the base class.

Here’s a code snippet to help you understand the implementation of hierarchical inheritance in C++:

// Base Class

class Animal {

public:

    virtual void makeSound() = 0;

};

// Derived Class 1

class Cat : public Animal {

public:

    void makeSound() override {

        std::cout << “Meow” << std::endl;

    }

};

// Derived Class 2

class Dog : public Animal {

public:

    void makeSound() override {

        std::cout << “Woof” << std::endl;

    }

};

In this example, we have a base class called Animal with a virtual function makeSound(). We then define two derived classes, Cat and Dog, that both inherit from Animal. Each derived class overrides the makeSound() function to provide its own implementation. Using hierarchical inheritance, we can create different types of animals that share common behaviours, such as making a sound.

When to use Hierarchical Inheritance in C++

Use hierarchical inheritance when you want to create multiple derived classes that share common functionality. For example, consider a banking application that requires different types of accounts, such as savings accounts, checking accounts, and credit card accounts. All of these account types share some common attributes and behaviours, such as account number, balance, and interest rate. 

By using hierarchical inheritance, you can create a base class called Account that contains the common attributes and behaviours and derive each account type from it to add its unique functionality.

Multilevel Inheritance

Multilevel inheritance in C++ is a type of inheritance where a derived class is inherited by another derived class. In this scenario, the derived class inherits all the public and protected data members and member functions of its immediate parent class, which in turn inherits from its own parent class, and so on.

Here is how you can programmatically implement multilevel inheritance in C++: 

// Base Class

class Vehicle {

public:

    void start() {

        std::cout << “Vehicle is starting” << std::endl;

    }

};

// Intermediate Class

class Car : public Vehicle {

public:

    void drive() {

        std::cout << “Car is driving” << std::endl;

    }

};

// Derived Class

class SportsCar : public Car {

public:

    void accelerate() {

        std::cout << “Sports car is accelerating” << std::endl;

    }

};

When to use multilevel inheritance in C++

Use multilevel inheritance when you want to create a derived class that inherits from another derived class and adds its functionality. For example, consider a software system that requires different types of vehicles, such as cars, trucks, and motorcycles. These vehicle types share some common attributes and behaviours, such as speed, acceleration, and braking. 

By using multilevel inheritance, you can create a base class called Vehicle that contains the common attributes and behaviours and derive intermediate classes such as Car and Truck from it to add their specific functionality. Then, you can derive the SportsCar class from the Car class to add its unique functionality.

Hybrid inheritance is a combination of two or more types of inheritance. Also referred to as virtual inheritance, a derived class in hybrid inheritance inherits from multiple base classes, some of which are inherited through multiple paths. This can create complex inheritance hierarchies and can be challenging to understand and maintain.

Check Out upGrad’s Software Development Courses to upskill yourself.

Here’s an example of hybrid inheritance in C++:

// Base Class 1

class Animal {

public:

    virtual void makeSound() = 0;

};

// Base Class 2

class CanFly {

public:

    virtual void fly() = 0;

};

// Base Class 3

class CanSwim {

public:

    virtual void swim() = 0;

};

// Derived Class

class Bat : public Animal, public CanFly {

public:

    void makeSound() override {

        std::cout << “Screech!” << std::endl;

    }

    void fly() override {

        std::cout << “Bat is flying” << std::endl;

    }

};

// Derived Class

class Penguin : public Animal, public CanSwim {

public:

    void makeSound() override {

        std::cout << “Hooonk!” << std::endl;

    }

    void swim() override {

        std::cout << “Penguin is swimming” << std::endl;

    }

};

When to use Hybrid Inheritance in C++

In addition to the four types of inheritance discussed earlier, hybrid inheritance can be useful in certain scenarios where multiple types of inheritance are required. Use hybrid inheritance to combine the benefits of multiple inheritance types.

For example, consider a software system that requires different types of animals, some of which can fly while others can swim. You can use hybrid inheritance to create a base class called Animal and derive two intermediate classes, CanFly and CanSwim, from it. Finally, using hybrid inheritance, you can derive the Bat and Penguin classes from both intermediate classes. The Bat class would inherit from Animal and CanFly, while the Penguin class would inherit from Animal and CanSwim. This way, you can create different types of animals with unique combinations of abilities.

Hybrid inheritance in C++ can be useful in complex software systems where multiple types of inheritance are required. However, it can also create complex inheritance hierarchies that can be challenging to understand and maintain. As with other types of inheritance, choosing the right type for your specific software development project requirements and design goals is crucial.

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

Important Things to Keep in Mind When Using Inheritance:

While inheritance is a powerful mechanism in C++, it also has a few factors to consider when implementing. 

1. Avoid Deep Inheritance Hierarchies: Deep inheritance hierarchies can lead to code that is difficult to read, understand, and maintain. Keep your inheritance hierarchies as shallow as possible to improve code readability and maintainability.
2. Use Access Modifiers Wisely: Access modifiers (public, protected, and private) control the visibility of data members and member functions in a class. Use them wisely to avoid exposing implementation details that should not be visible outside the class.
3. Avoid Diamond Inheritance: Diamond inheritance occurs when a class inherits from two classes that inherit from the same base class. This can lead to ambiguity and is generally best avoided.
4. Avoid Overusing Inheritance: While inheritance can be useful, it’s important to avoid overusing it. In some cases, composition or other design patterns may be a better choice.

Takeaway

To summarise, inheritance is a crucial concept in C++ programming that every programming student should master. By understanding the different types of inheritance and their use cases, you can create efficient, organised, and maintainable code, thus becoming a better software developer.

If you found this article interesting, you can further enhance your knowledge of software development by enrolling in upGrad’s DevOps Certification Program offered in collaboration with IIIT Bangalore. This program covers various aspects of software development, including coding, testing, and deployment, and can help you become a skilled software developer in the industry.