Types of inheritance in C++ - Time & Space Complexity

Time Complexity: Types of inheritance

O(n)

Understanding Time Complexity

When we use inheritance in C++, the program runs some code to create objects and connect classes. We want to see how the time it takes changes when we add more classes or objects.

How does the program's running time grow as we use different types of inheritance?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Base {
public:
    void baseMethod() {}
};

class Derived : public Base {
public:
    void derivedMethod() {}
};

int main() {
    Derived obj;
    obj.baseMethod();
    obj.derivedMethod();
    return 0;
}
    

This code shows simple single inheritance where one class inherits from another and calls methods from both.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: There are no loops or recursion here; the program just creates one object and calls methods once.
• How many times: Each method is called exactly once.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (number of objects)	Approx. Operations
1	Few operations (create one object, call methods once)
10	About 10 times more operations (create 10 objects, call methods 10 times)
100	About 100 times more operations

Pattern observation: The time grows linearly with the number of objects created and methods called.

Final Time Complexity

Time Complexity: O(n)

This means if you create and use more objects, the time to run grows in a straight line with how many you have.

Common Mistake

[X] Wrong: "Inheritance makes the program run slower exponentially because of all the parent classes."

[OK] Correct: Inheritance itself just connects classes; calling methods on objects grows linearly with how many objects you use, not exponentially.

Interview Connect

Understanding how inheritance affects running time helps you explain your code clearly and shows you know how programs behave as they grow. This skill is useful when designing clean and efficient programs.

Self-Check

"What if we added a loop inside the derived class method that runs n times? How would the time complexity change?"