Inheritance in C++

Inheritance is one of the most fundamental and powerful concepts in object-oriented programming (OOP). It allows one class to acquire the properties and behaviors (data members and member functions) of another class. This concept helps in code reusability, logical organization, and building hierarchical relationships between classes.

In simpler terms, inheritance allows you to define a new class that is based on an existing class. The new class inherits the features of the existing class and can also add new features or modify existing ones. This helps programmers avoid code duplication and makes programs easier to maintain and extend.

In C++, inheritance forms one of the four main pillars of OOP — along with encapsulation, abstraction, and polymorphism. Let us understand inheritance in detail, from basic to advanced concepts, with examples and explanations.

What Is Inheritance?

Inheritance means deriving a new class (called the derived class or subclass) from an existing class (called the base class or superclass). The derived class automatically contains all the data members and functions of the base class. In addition, the derived class can define its own members.

The base class serves as a blueprint, while the derived class builds upon it or specializes it.

For example, consider a general class called Animal. All animals can eat and sleep. But specific animals, like dogs or birds, might have additional behaviors. Instead of writing the eat and sleep functions again for each animal, we can make those animals inherit from the Animal class.

---

Example of Simple Inheritance

#include <iostream>
using namespace std;

class Animal {
public:
void eat() {
    cout &lt;&lt; "Eating..." &lt;&lt; endl;
}
};

class Dog : public Animal {
public:
void bark() {
    cout &lt;&lt; "Barking..." &lt;&lt; endl;
}
};

int main() {
Dog d;
d.eat();   // inherited from Animal
d.bark();  // defined in Dog
return 0;
}

Output:

Eating...
Barking...

In this example, the class Dog inherits from Animal. It automatically gets the eat() function from the base class. It also defines a new behavior bark() that is unique to dogs. The object d can access both functions.

---

Key Terms in Inheritance

1. Base Class: The class whose properties are inherited by another class.
2. Derived Class: The class that inherits from the base class.
3. Access Specifier: Defines how the members of the base class can be accessed by the derived class.
4. Inheritance Type: Defines the visibility of inherited members.

In C++, the syntax for inheritance looks like this:

class DerivedClass : accessSpecifier BaseClass {
// new members or functions
};

The access specifier can be public, protected, or private, and it plays a crucial role in determining how the base class members are treated in the derived class.

---

Types of Inheritance in C++

C++ supports several types of inheritance. These include:

1. Single Inheritance
2. Multiple Inheritance
3. Multilevel Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance

Each type serves different purposes and represents different real-world relationships.

---

Single Inheritance

Single inheritance is the simplest form of inheritance, where one derived class inherits from one base class.

Example:

class Animal {
public:
void eat() {
    cout << "Eating..." << endl;
}
};

class Dog : public Animal {
public:
void bark() {
    cout << "Barking..." << endl;
}
};

In this example, Dog inherits from Animal. It’s a simple one-to-one relationship.

---

Multiple Inheritance

C++ allows a class to inherit from more than one base class. This is called multiple inheritance.

Example:

class Engine {
public:
void start() {
    cout << "Engine started" << endl;
}
};

class Wheels {
public:
void rotate() {
    cout << "Wheels rotating" << endl;
}
};

class Car : public Engine, public Wheels {
public:
void drive() {
    cout << "Car is driving" << endl;
}
};

Here, the class Car inherits from both Engine and Wheels. This means it can access the functions of both classes.

While multiple inheritance is powerful, it must be used carefully to avoid ambiguity and complexity, which we will discuss later.

---

Multilevel Inheritance

Multilevel inheritance means that a class is derived from another derived class. This forms a chain-like structure.

Example:

class Animal {
public:
void eat() {
    cout << "Eating..." << endl;
}
};

class Mammal : public Animal {
public:
void breathe() {
    cout << "Breathing..." << endl;
}
};

class Dog : public Mammal {
public:
void bark() {
    cout << "Barking..." << endl;
}
};

Here, Dog inherits from Mammal, and Mammal inherits from Animal.
Thus, Dog has access to both eat() and breathe() in addition to its own bark() function.

---

Hierarchical Inheritance

In hierarchical inheritance, multiple classes inherit from a single base class.

Example:

class Animal {
public:
void eat() {
    cout << "Eating..." << endl;
}
};

class Dog : public Animal {
public:
void bark() {
    cout << "Barking..." << endl;
}
};

class Cat : public Animal {
public:
void meow() {
    cout << "Meowing..." << endl;
}
};

Here, both Dog and Cat inherit from the same base class Animal. Each subclass adds its own specific behavior.

This type of inheritance is useful for creating groups of classes that share common features but also have unique characteristics.

---

Hybrid Inheritance

Hybrid inheritance is a combination of two or more types of inheritance. It often involves multiple and multilevel inheritance together.

Example:

class A {
public:
void showA() {
    cout << "Class A" << endl;
}
};

class B : public A {
public:
void showB() {
    cout << "Class B" << endl;
}
};

class C {
public:
void showC() {
    cout << "Class C" << endl;
}
};

class D : public B, public C {
public:
void showD() {
    cout << "Class D" << endl;
}
};

Here, class D inherits from both class B and class C, and class B already inherits from A. This combination makes the structure hybrid.

While hybrid inheritance is supported, it should be used carefully, as it can lead to ambiguity problems.

---

Access Specifiers in Inheritance

Access specifiers determine how the base class members are accessible to the derived class. C++ provides three main access specifiers: public, protected, and private.

When inheriting, the chosen access specifier affects the visibility of base class members inside the derived class.

Let’s summarize the rules:

Inherited Members	Public Inheritance	Protected Inheritance	Private Inheritance
Public Members	Public	Protected	Private
Protected Members	Protected	Protected	Private
Private Members	Not Inherited	Not Inherited	Not Inherited

• Public Inheritance: The most common type; the “is-a” relationship is preserved.
• Protected Inheritance: Used when you want derived classes to inherit members but not expose them publicly.
• Private Inheritance: Members of the base class become private to the derived class and cannot be accessed further.

---

Example of Public Inheritance

class Parent {
public:
int value = 10;
};

class Child : public Parent {
public:
void display() {
    cout << "Value = " << value << endl;
}
};

The Child class can directly access value because it’s inherited publicly.

---

Example of Private Inheritance

class Parent {
public:
int value = 10;
};

class Child : private Parent {
public:
void show() {
    cout << "Value = " << value << endl;
}
};

Here, the value is accessible within Child but cannot be accessed through an object of Child directly.

---

Constructor and Destructor Behavior in Inheritance

Constructors and destructors play a crucial role in inheritance. When a derived class object is created, the constructor of the base class is called first, followed by the constructor of the derived class. When the object is destroyed, the destructor of the derived class is called first, followed by that of the base class.

Example:

class Parent {
public:
Parent() {
    cout << "Parent Constructor" << endl;
}
~Parent() {
    cout << "Parent Destructor" << endl;
}
};

class Child : public Parent {
public:
Child() {
    cout << "Child Constructor" << endl;
}
~Child() {
    cout << "Child Destructor" << endl;
}
};

Output:

Parent Constructor
Child Constructor
Child Destructor
Parent Destructor

This sequence ensures proper initialization and cleanup in the inheritance hierarchy.

---

Function Overriding in Inheritance

When a derived class provides a new definition for a function that already exists in the base class, it is called function overriding.

Example:

class Animal {
public:
void sound() {
    cout << "Some sound..." << endl;
}
};

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

If you create a Dog object and call sound(), it will execute the overridden version in the Dog class, not the base class version.

This concept enables polymorphism, allowing different classes to have different implementations of the same function name.

---

Using the Superclass Members

Sometimes you may want to access base class functions even after overriding them. You can use the scope resolution operator (::) to call the base version.

Example:

class Animal {
public:
void sound() {
    cout << "Generic Animal Sound" << endl;
}
};

class Dog : public Animal {
public:
void sound() {
    cout << "Bark!" << endl;
}
void show() {
    Animal::sound();  // call base class function
    sound();          // call derived class function
}
};

This technique allows you to reuse the base implementation when needed.

---

The Diamond Problem in Multiple Inheritance

One of the biggest challenges in multiple inheritance is the Diamond Problem. It occurs when two base classes inherit from the same superclass, and then another class inherits from both of them.

Example:

class A {
public:
void display() {
    cout << "Class A" << endl;
}
};

class B : public A {};
class C : public A {};
class D : public B, public C {};

If you create an object of class D and try to call display(), the compiler will be confused — should it call A’s version through B or through C? This is called ambiguity.

To solve this, C++ introduces virtual inheritance.

---

Virtual Inheritance

Virtual inheritance ensures that only one copy of the base class is shared among all derived classes.

class A {
public:
void display() {
    cout << "Class A" << endl;
}
};

class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

Now, class D will have only one instance of class A. This resolves ambiguity.

Virtual inheritance is important when working with complex hierarchies and multiple inheritance chains.

---

Advantages of Inheritance

1. Code Reusability: You can reuse the functionality of existing classes, reducing redundancy.
2. Extensibility: You can add new features without modifying existing code.
3. Maintainability: The code structure becomes clearer and easier to maintain.
4. Logical Hierarchy: Helps represent real-world relationships like “is-a” (Dog is an Animal).
5. Polymorphism Support: Inheritance enables polymorphism, which allows flexible and dynamic behavior.

---

Disadvantages of Inheritance

While inheritance is powerful, it must be used carefully. Some drawbacks include:

1. Tight Coupling: Changes in base classes can affect derived classes unexpectedly.
2. Complexity: Multiple and hybrid inheritance can make code difficult to understand.
3. Debugging Difficulty: Tracing errors in deep hierarchies can be challenging.
4. Overuse Risk: Not every code relationship should use inheritance — sometimes composition is a better design choice.

---

Inheritance vs Composition

Developers often face a design decision between inheritance (“is-a” relationship) and composition (“has-a” relationship).

• Use inheritance when one class is a specialized version of another (e.g., Dog is an Animal).
• Use composition when one class contains another as a component (e.g., Car has an Engine).

Choosing correctly improves modularity and flexibility.

---

Real-World Example

Consider a simple simulation of a banking system.

class Account {
protected:
double balance;
public:
Account(double b) : balance(b) {}
void deposit(double amount) {
    balance += amount;
}
void displayBalance() {
    cout << "Balance: " << balance << endl;
}
};

class SavingsAccount : public Account {
public:
SavingsAccount(double b) : Account(b) {}
void addInterest() {
    balance += balance * 0.05;
}
};

Here, SavingsAccount inherits from Account. It reuses deposit and balance functionality while adding a new feature for interest. This is a practical application of inheritance.