Inheritance in C++

Inheritance is a core Object-Oriented Programming (OOP) concept that allows one class to inherit the properties and behaviors of another class. It helps create a new class from an existing class, improving code reusability and hierarchical organization of classes.

• A derived class can reuse the data members and member functions of the base class without rewriting the code.
• A derived class can add new members or modify existing functionality according to requirements.
• Inheritance helps reduce code duplication and supports extensibility in C++ programs.

Example: In the following example, Animal is the base class and Dog, Cat and Cow are derived classes that extend the Animal class.

#include <iostream>
using namespace std;

class Animal
{
  public:
    void sound()
    {
        cout << "Animal makes a sound" << endl;
    }
};

class Dog : public Animal
{
  public:
    void sound()
    {
        cout << "Dog barks" << endl;
    }
};

class Cat : public Animal
{
  public:
    void sound()
    {
        cout << "Cat meows" << endl;
    }
};

class Cow : public Animal
{
  public:
    void sound()
    {
        cout << "Cow moos" << endl;
    }
};

int main()
{
    Dog d;
    d.sound();

    Cat c;
    c.sound();

    Cow cow;
    cow.sound();

    return 0;
}

Dog barks
Cat meows
Cow moos

Explanation:

• Animal is the base class with a function sound().
• Dog, Cat, and Cow are derived classes, each defining their own sound() method.
• In main(), objects of Dog, Cat, and Cow are created separately.
• When we call sound() on each object, the respective child class method runs (Dog barks, Cat meows, Cow moos).

Syntax

class ChildClass : public ParentClass
{
// Additional fields and methods
};

How Inheritance Works in C++?

Inheritance in C++ allows a class to acquire the properties and behaviors of another class using the colon (:) operator. It helps create a relationship between classes, enabling code reuse and easier maintenance.

• The derived (child) class inherits accessible data members and member functions from the base (parent) class.
• Inheritance reduces code duplication and promotes code reusability.
• The child class can add new features or override inherited functions to provide its own implementation.

Types of Inheritance in C++

Below are the different types of inheritance which are supported by C++.

1. Single Inheritance

In single inheritance, a sub-class is derived from only one super class. It inherits the properties and behavior of a single-parent class. Sometimes, it is also known as simple inheritance.

#include <iostream>
using namespace std;

class Vehicle {
public:
    Vehicle() {
        cout << "This is a Vehicle" << endl;
    }
};

class Car : public Vehicle {
public:
    Car() {
        cout << "This Vehicle is Car" << endl;
    }
};

int main() {
   
    Car obj;
    return 0;
}

This is a Vehicle
This Vehicle is Car

2. Multiple Inheritance

In Multiple inheritance, one class can have more than one superclass and inherit features from all parent classes.

#include <iostream>
using namespace std;

class LandVehicle
{
  public:
    void landInfo()
    {
        cout << "This is a LandVehicle" << endl;
    }
};

class WaterVehicle
{
  public:
    void waterInfo()
    {
        cout << "This is a WaterVehicle" << endl;
    }
};

// Derived class inheriting from both base classes
class AmphibiousVehicle : public LandVehicle, public WaterVehicle
{
  public:
    AmphibiousVehicle()
    {
        cout << "This is an AmphibiousVehicle" << endl;
    }
};

int main()
{
    AmphibiousVehicle obj;

    obj.waterInfo();
    obj.landInfo();

    return 0;
}

This is an AmphibiousVehicle
This is a WaterVehicle
This is a LandVehicle

3. Multilevel Inheritance

Multilevel inheritance in C++ means a class is derived from another derived class, forming a chain of inheritance.

#include <iostream>
using namespace std;

class Vehicle
{
  public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};

// Derived class from Vehicle
class FourWheeler : public Vehicle
{
  public:
    FourWheeler()
    {
        cout << "4 Wheeler Vehicles" << endl;
    }
};

// Derived class from FourWheeler
class Car : public FourWheeler
{
  public:
    Car()
    {
        cout << "This 4 Wheeler Vehicle is a Car" << endl;
    }
};

int main()
{
    Car obj;
    return 0;
}

This is a Vehicle
4 Wheeler Vehicles
This 4 Wheeler Vehicle is a Car

4. Hierarchical Inheritance

In hierarchical inheritance, more than one subclass is inherited from a single base class. i.e. more than one derived class is created from a single base class. For example, cars and buses both are vehicle.

#include <iostream>
using namespace std;

class Vehicle
{
  public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};

class Car : public Vehicle
{
  public:
    Car()
    {
        cout << "This Vehicle is Car" << endl;
    }
};

class Bus : public Vehicle
{
  public:
    Bus()
    {
        cout << "This Vehicle is Bus" << endl;
    }
};

int main()
{
    Car obj1;
    Bus obj2;
    return 0;
}

This is a Vehicle
This Vehicle is Car
This is a Vehicle
This Vehicle is Bus

5. Hybrid Inheritance

When two or more types of inheritance are combined in one program. For example, a class might use multiple inheritance and also be part of a multilevel inheritance chain.

#include <iostream>
using namespace std;

class Vehicle
{
  public:
    Vehicle()
    {
        cout << "This is a Vehicle" << endl;
    }
};

class Fare
{
  public:
    Fare()
    {
        cout << "Fare of Vehicle" << endl;
    }
};

class Car : public Vehicle
{
  public:
    Car()
    {
        cout << "This Vehicle is a Car" << endl;
    }
};

class Bus : public Vehicle, public Fare
{
  public:
    Bus()
    {
        cout << "This Vehicle is a Bus with Fare";
    }
};

int main()
{
    Bus obj2;
    return 0;
}

This is a Vehicle
Fare of Vehicle
This Vehicle is a Bus with Fare

Hybrid Inheritance can lead to the diamond problem in C++. This happens when a class inherits from two classes that both share the same base class. As a result the derived class gets multiple copies of the base class members, which creates ambiguity about which one to use.

Note : The solution is to use virtual inheritance, so only a single copy of the base class is shared.

Virtual inheritance is used to solve the diamond problem in C++. It ensures that when a class inherits the same base class through multiple inheritance paths, only one shared copy of the base class is inherited, avoiding ambiguity.

Advantages of Inheritance in C++

• Code Reusability: Derived class can directly reuse data members and methods of its base class, avoiding code duplication.
• Abstraction : Supports abstract classes (classes with pure virtual functions) that define a common interface, enforcing abstraction.
• Class Hierarchy : You can build hierarchies (base → derived → further derived) to model real-world relationships.
• Polymorphism : Fully supports runtime polymorphism through virtual functions, and also compile-time polymorphism via function overloading and templates.

Situations where Inheritance may not be suitable

• Changes in the base class can affect all derived classes, making the code tightly dependent.
• Flexibility is reduced, as inheritance fixes relationships, while composition allows easier modification.
• Deep or complex class hierarchies make the code harder to understand, maintain, and debug.
• Multiple inheritance can create ambiguity when the same base class is inherited more than once (diamond problem).
• Using virtual functions can introduce a small runtime overhead due to dynamic dispatch.