Inheritance in C++

In software engineering, writing code from scratch for every new variation of an component introduces structural bloat and maintenance overhead. Inheritance is an essential pillar of Object-Oriented Programming (OOP) that resolves this issue. It allows a new class (Derived or Child Class) to absorb, reuse, modify, and extend the properties and behaviors of an existing class (Base or Parent Class).

By implementing inheritance hierarchies, you establish logical "is-a" relationships (e.g., a Dog is an Animal, a Laptop is a ComputeDevice), promoting code reusability and clean architectural extensibility.

1. Types of Inheritance in C++

C++ is highly flexible, supporting multiple structural combinations to organize parent and child relationships.

A. Single Inheritance

A single child class derives directly from exactly one parent class. This is the cleanest and most common model.

Single Inheritance Example

#include <iostream>

class Base {};
class Derived : public Base {};

B. Multiple Inheritance

A single child class derives directly from two or more distinct parent classes simultaneously.

Multiple Inheritance Example

class Engine {};
class Chassis {};
class Car : public Engine, public Chassis {};

Architectural Pitfall: Explicit Scope Ambiguity

When multiple parent classes contain identical member signatures, the compiler cannot automatically deduce which one to run, triggering a compilation error.

Multiple Inheritance Ambiguity Example

#include <iostream>

class Transmitter {
public:
    void broadcast() { std::cout << "Sending radio waves...\n"; }
};

class Receiver {
public:
    void broadcast() { std::cout << "Echoing audio signals...\n"; }
};

class Transceiver : public Transmitter, public Receiver {};

int main() {
    Transceiver device;
    // device.broadcast(); // Error: Request for member 'broadcast' is ambiguous

    // Resolution: Enforce the C++ Scope Resolution Operator (::)
    device.Transmitter::broadcast(); 
    device.Receiver::broadcast();
    return 0;
}

C. Multilevel Inheritance

A class derives from a child class, creating a linear multi-generational lineage chain.

Multilevel Inheritance Example

class Vehicle {};
class WheeledVehicle : public Vehicle {};
class Truck : public WheeledVehicle {};

D. Hierarchical Inheritance

Multiple distinct child classes all split from a singular parent base class.

Hierarchical Inheritance Example

class SystemLog {};
class ErrorLog : public SystemLog {};
class SecurityLog : public SystemLog {};

E. Hybrid Inheritance

A complex combination mixing two or more of the structural forms described above.

F. Virtual Inheritance & The Diamond Problem

Hybrid setups often create a classic diamond structure where a grandchild class inherits from two intermediate classes, both sharing a common top-tier grandparent class.

Without protection, the grandchild object gets two duplicate copies of the grandparent's attributes, causing ambiguity and wasting memory. To resolve this, use the virtual keyword during inheritance.

Virtual Inheritance Example

#include <iostream>

class PowerSource {
public:
    int voltage = 12;
};

// Virtual inheritance ensures only one shared master instance exists
class Battery : public virtual PowerSource {};
class Alternator : public virtual PowerSource {};

class PowerGrid : public Battery, public Alternator {
public:
    void displayVoltage() {
        // Without virtual inheritance, this would fail due to ambiguity
        std::cout << "Grid Voltage: " << voltage << "V\n"; 
    }
};

int main() {
    PowerGrid regionalGrid;
    regionalGrid.displayVoltage();
    return 0;
}

2. Access Specifiers in Inheritance Modes

The choice of access specifier when defining your inheritance relationship (class Derived : public Base) dictates how members of the base class are exposed in the derived class.

Visibility Mapping Matrix

Base Member Visibility	Public Inheritance Mode (: public)	Protected Inheritance Mode (: protected)	Private Inheritance Mode (: private)
public	Becomes public in child	Becomes protected in child	Becomes private in child
protected	Becomes protected in child	Becomes protected in child	Becomes private in child
private	Hidden (Inaccessible)	Hidden (Inaccessible)	Hidden (Inaccessible)

Production Best Practice

Always use public inheritance unless you have a specific, advanced architectural reason to do otherwise. private or protected inheritance patterns generally break the "is-a" relationship model, turning it into a "has-a" implementation details layout.

3. Concrete Implementation: Single Inheritance

Single Inheritance Example

#include <iostream>
#include <string>

class NetworkDevice {
public:
    std::string ipAddress;
    
    void ping() {
        std::cout << "Device at " << ipAddress << " responded in 12ms.\n";
    }
};

// Publicly deriving capabilities
class DatabaseServer : public NetworkDevice {
public:
    std::string databaseEngine;

    void processQuery() {
        std::cout << "Executing query optimization via " << databaseEngine << ".\n";
    }
};

int main() {
    DatabaseServer targetNode;
    targetNode.ipAddress = "10.0.0.45"; // Inherited property
    targetNode.databaseEngine = "PostgreSQL";

    targetNode.ping();         // Inherited action
    targetNode.processQuery(); // Custom specialized action
    return 0;
}

4. Method Overriding Mechanics

A child class can change the implementation of an inherited parent function to better fit its specialized role.

• To enable safe runtime resolution, mark the parent class function as virtual.
• Use the modern override keyword in the child class signature. This tells the compiler to double-check that the function names and types match perfectly, catching bugs early.

Method Overriding Example

#include <iostream>

class CryptographicKey {
public:
    virtual void generate() {
        std::cout << "Generating generic 128-bit baseline security keys.\n";
    }
    virtual ~CryptographicKey() = default; // Essential for safe polymorphic deletion
};

class RSAKey : public CryptographicKey {
public:
    void generate() override { // Overriding behavior
        std::cout << "Generating high-security 4096-bit RSA prime pair keys.\n";
    }
};

int main() {
    CryptographicKey* securityKeyPipeline = new RSAKey();
    
    // Executes child method at runtime via lookup pointer tables (Vtables)
    securityKeyPipeline->generate(); 
    
    delete securityKeyPipeline;
    return 0;
}

5. Order of Constructor & Destructor Execution

Constructors are not inherited. When you create an instance of a child class, the computer executes constructors and destructors in a strict, sequential chain:

1. Base Class Constructor executes first (building the parent layer).
2. Derived Class Constructor executes second (building the child layer extension).
3. Derived Class Destructor executes first during cleanup.
4. Base Class Destructor executes last, clearing out the core parent resources.

Constructor Parameter Routing Example

If a parent class constructor requires parameters, the child class must explicitly forward those values up the chain using a member initialization list.

Constructor Parameter Routing Example

#include <iostream>
#include <string>

class StorageVolume {
public:
    int capacityGB;
    
    StorageVolume(int size) : capacityGB(size) {
        std::cout << "Allocating " << capacityGB << "GB Storage Master Block.\n";
    }
};

class SolidStateDrive : public StorageVolume {
public:
    int readSpeedMBs;

    // Forwarding structural sizing down to the parent class constructor
    SolidStateDrive(int size, int speed) : StorageVolume(size), readSpeedMBs(speed) {
        std::cout << "Configuring SSD controllers for " << readSpeedMBs << " MB/s.\n";
    }
};

int main() {
    SolidStateDrive primaryDrive(2000, 7000);
    return 0;
}

Output

Allocating 2000GB Storage Master Block.
Configuring SSD controllers for 7000 MB/s.

6. Engineering Decisions: Structural Trade-offs

Engineering Vector	Advantages Provided	Operational Constraints introduced
Code Base Reusability	Eliminates duplicate boilerplate algorithms across similar models.	Modifying a base class can accidentally break functionality across dozens of dependent derived classes (Fragile Base Class Problem).
Polymorphic APIs	Allows developers to write unified code that operates on different types of objects interchangeably.	Slight execution indirection cost due to runtime virtual table processing lookup layers.
Class Extensibility	Simplifies adding new child modules without disturbing working production code assets.	Overusing deep multi-layered inheritance trees leads to hard-to-read, tightly-coupled code structures.

Architectural Principle

Professional engineers often prioritize Composition over Inheritance. If a class simply needs the functionality of another class without establishing a clear "is-a" identity, embed that class as a private member variable instead (has-a mapping layout).