Inheritance & Polymorphism

What is Inheritance?

Inheritance is an OOP mechanism where a new class (derived/child) acquires properties and behaviors from an existing class (base/parent). The core idea: reuse + extend.

#include <iostream>
using namespace std;

class Base {
public:
    int x;
    void show() { cout << "Base show: " << x << "\n"; }
};

class Derived : public Base {  // colon = "inherits from"
public:
    int y;
    void display() { cout << "Derived display: " << y << "\n"; }
};

int main() {
    Derived d;
    d.x = 10;
    d.y = 20;
    d.show();
    d.display();
    return 0;
}

Types of Inheritance

Single Inheritance — Full Example

#include <iostream>
#include <string>
using namespace std;

// Base class
class Animal {
public:
    string name;
    void eat() { cout << name << " is eating\n"; }
};

// Derived class inherits Animal
class Dog : public Animal {
public:
    void bark() { cout << name << " says Woof!\n"; }
};

int main() {
    Dog d;
    d.name = "Rex";   // inherited from Animal
    d.eat();           // inherited method
    d.bark();          // own method
    return 0;
}

Multiple Inheritance

#include <iostream>
using namespace std;

class Father { public: void wealth() { cout << "Rich\n"; } };
class Mother { public: void talent() { cout << "Creative\n"; } };

class Child : public Father, public Mother {
public:
    void intro() { wealth(); talent(); }
};

int main() {
    Child c;
    c.intro();
    return 0;
}

Multilevel Inheritance

#include <iostream>
using namespace std;

class Grandparent { public: void gp() { cout << "GP\n"; } };
class Parent : public Grandparent { public: void p() { cout << "P\n"; } };
class Child : public Parent { public: void c() { cout << "C\n"; } };

int main() {
    Child ch;
    // Child has access to gp(), p(), and c()
    ch.gp();
    ch.p();
    ch.c();
    return 0;
}

class A { public: int x; };
class B : public A { public: int y; }; // Single
class C : public B { public: int z; }; // Multilevel

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

Member Access in Classes

Inheritance Mode Effect

How members are inherited depends on the inheritance mode used in the derived class:

Code Example

#include <iostream>
using namespace std;

class Base {
public:    int pub = 1;
protected: int prot = 2;
private:   int priv = 3;
};

class D1 : public Base {
public:
    void test() {
        pub  = 10;  // OK — still public
        prot = 20;  // OK — still protected
        // priv = 30; ERROR — not accessible
        cout << "D1 test: pub=" << pub << " prot=" << prot << "\n";
    }
};

class D2 : private Base {
public:
    void test() {
        pub  = 10;  // OK — but now private in D2
        prot = 20;  // OK — but now private in D2
        cout << "D2 test: pub=" << pub << " prot=" << prot << "\n";
    }
};

int main() {
    D1 d1;
    d1.pub = 5;   // OK — public inheritance keeps it public
    d1.test();

    D2 d2;
    // d2.pub = 5; ERROR — private inheritance makes it private
    d2.test();
    return 0;
}

class Base { private: int a; protected: int b; public: int c; };
class Derived : public Base { void test(){ b=1; c=2; /* a=3; ERROR */ } };

The Golden Rule

#include <iostream>
using namespace std;

class Base {
public:
    Base()  { cout << "Base Constructor\n"; }
    ~Base() { cout << "Base Destructor\n"; }
};

class Derived : public Base {
public:
    Derived()  { cout << "Derived Constructor\n"; }
    ~Derived() { cout << "Derived Destructor\n"; }
};

int main() {
    cout << "--- Creating d ---\n";
    {
        Derived d;
        cout << "--- d goes out of scope ---\n";
    }
    return 0;
}

Passing Arguments to Base Constructor

Use initializer list syntax to pass arguments to base class constructor:

#include <iostream>
using namespace std;

class Base {
    int x;
public:
    Base(int a) : x(a) { cout << "Base(" << x << ")\n"; }
};

class Derived : public Base {
    int y;
public:
    Derived(int a, int b) : Base(a), y(b) {  // Base(a) called first
        cout << "Derived(" << y << ")\n";
    }
};

int main() {
    Derived d(10, 20);
    return 0;
}

Multiple Inheritance Constructor Order

#include <iostream>
using namespace std;

class A { public: A() { cout << "A\n"; } };
class B { public: B() { cout << "B\n"; } };
class C : public A, public B {
public:
    C() { cout << "C\n"; }
};

int main() {
    C c;
    return 0;
}

class Base { public: Base(){ cout<<"B"; } };
class Derived : public Base { public: Derived(){ cout<<"D"; } };
int main(){ Derived obj; }

Friend Functions

#include <iostream>
using namespace std;

class Box {
    int length;  // private
public:
    Box(int l) : length(l) {}
    friend void printLength(Box b);  // friend declaration
};

void printLength(Box b) {
    cout << "Length: " << b.length << "\n";  // accessing private!
}

int main() {
    Box b(10);
    printLength(b);  // called without object
    return 0;
}

Friend Class

#include <iostream>
using namespace std;

class Engine;  // forward declaration

class Car {
    int speed = 200;
public:
    friend class Engine;  // Engine can access Car's privates
};

class Engine {
public:
    void tune(Car& c) {
        cout << "Speed: " << c.speed << "\n";  // OK — Engine is friend of Car
    }
};

int main() {
    Car myCar;
    Engine myEngine;
    myEngine.tune(myCar);
    return 0;
}

Inline Functions

The inline keyword requests the compiler to replace a function call with the actual function code — eliminating call overhead.

#include <iostream>
using namespace std;

inline int square(int x) { return x * x; }

int main() {
    cout << square(5) << "\n";  // compiler replaces with: cout << 5*5;
    return 0;
}

class Box { int width; friend void setWidth(Box &b, int w); };
void setWidth(Box &b, int w){ b.width = w; }

The Problem Without virtual

#include <iostream>
using namespace std;

class Animal {
public:
    void speak() { cout << "Animal speaks\n"; }
};

class Dog : public Animal {
public:
    void speak() { cout << "Dog barks\n"; }
};

int main() {
    Animal* ptr = new Dog();
    ptr->speak();  // Output: "Animal speaks" ← WRONG!
    // Without virtual, base class version always called via pointer
    delete ptr;
    return 0;
}

Solution: virtual Keyword

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() { cout << "Animal speaks\n"; }
};

class Dog : public Animal {
public:
    void speak() override { cout << "Dog barks\n"; }
};

class Cat : public Animal {
public:
    void speak() override { cout << "Cat meows\n"; }
};

int main() {
    Animal* p1 = new Dog();
    Animal* p2 = new Cat();
    p1->speak();  // Dog barks ✓
    p2->speak();  // Cat meows ✓
    // Decision made at RUNTIME — Runtime Polymorphism
    
    delete p1;
    delete p2;
    return 0;
}

How it Works — VTable (Internal Mechanics)

Memory Layout:
Animal object: [ vptr → Animal::VTable [ speak → Animal::speak ] ]
Dog object:    [ vptr → Dog::VTable    [ speak → Dog::speak    ] ]

So ptr-speak() goes: ptr → vptr → VTable → correct function

virtual Destructor — CRITICAL

#include <iostream>
using namespace std;

class Base {
public:
    virtual ~Base() { cout << "Base destroyed\n"; }
};

class Derived : public Base {
public:
    ~Derived() { cout << "Derived destroyed\n"; }
};

int main() {
    Base* p = new Derived();
    delete p;
    // Without virtual destructor: only Base destroyed → MEMORY LEAK
    // With virtual destructor: Derived destroyed, then Base ✓
    return 0;
}

Function Overriding vs Overloading

class Base { public: virtual void show(){ cout<<"B"; } };
class Derived : public Base { public: void show(){ cout<<"D"; } };
int main(){ Base *p; Derived d; p=&d; p->show(); }

Pure Virtual Function

A pure virtual function has no body — it FORCES derived classes to implement it:

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() = 0;  // "= 0" makes it pure virtual
};

class Dog : public Animal {
public:
    void speak() override { cout << "Woof\n"; }
};

int main() {
    Dog d;
    d.speak();
    return 0;
}

Abstract Class Rules

#include <iostream>
using namespace std;

class Shape {  // Abstract class
public:
    virtual double area() = 0;      // pure virtual
    virtual double perimeter() = 0; // pure virtual
    virtual void draw() { cout << "Drawing shape\n"; }  // regular virtual
};

class Circle : public Shape {
    double r;
public:
    Circle(double r) : r(r) {}
    double area() override      { return 3.14 * r * r; }
    double perimeter() override { return 2 * 3.14 * r; }
};

class Rectangle : public Shape {
    double w, h;
public:
    Rectangle(double w, double h) : w(w), h(h) {}
    double area() override      { return w * h; }
    double perimeter() override { return 2 * (w + h); }
};

int main() {
    // Shape s;  ← ERROR: cannot instantiate abstract class

    Shape* shapes[] = { new Circle(5), new Rectangle(4,6) };

    for (auto s : shapes) {
        cout << "Area: " << s->area() << "\n";
    }

    for (auto s : shapes) delete s; // Cleanup
    return 0;
}

Interface in C++ (100% Abstract)

C++ doesn't have the interface keyword like Java, but you can simulate it — a class with ALL pure virtual functions acts as an interface:

#include <iostream>
using namespace std;

class IPrintable {  // "Interface"
public:
    virtual void print() = 0;
    virtual void save() = 0;
    virtual ~IPrintable() = default;
};

class Document : public IPrintable {
public:
    void print() override { cout << "Printing Document\n"; }
    void save() override { cout << "Saving Document\n"; }
};

int main() {
    Document doc;
    doc.print();
    doc.save();
    return 0;
}

class Shape { public: virtual void draw()=0; };
class Circle : public Shape { public: void draw(){ cout<<"Draw"; } };

UML Box Structure

+------------------+
|   ClassName      |  ← Class Name (bold)
+------------------+
| - privateAttr    |  ← Attributes
| # protectedAttr  |  
| + publicAttr     |
+------------------+
| + publicMethod() |  ← Methods
| - privateMethod()|
+------------------+

Relationships in UML

Reading a UML Diagram — Example

         +----------+
         |  Animal  |         ← Abstract (italic name)
         +----------+
         | # name   |
         +----------+
         | + speak()*|         ← * = pure virtual
         +----------+
              △               ← Inheritance arrow
       _______|_______
      |                |
 +---------+      +---------+
 |   Dog   |      |   Cat   |
 +---------+      +---------+
 | +speak()|      | +speak()|
 +---------+      +---------+

2-Mark Questions

5-Mark Questions

MCQ Rapid Fire

Revision Sheet — 1-Minute Recall

12 full exam-level programs. Attempt without looking at solution first.

#include 
using namespace std;

class Account {
protected: double balance; int accountNo;
public:
    Account(int no, double bal): accountNo(no), balance(bal){}
    virtual double calculateInterest() = 0;
    virtual void display() = 0;
    virtual ~Account(){}
};
class SavingsAccount : public Account {
    double rate;
public:
    SavingsAccount(int no, double bal, double r): Account(no,bal), rate(r){}
    double calculateInterest() override { return balance*rate/100; }
    void display() override { cout "Savings Acc#" " Interest:" calculateInterest() "\n"; }
};
int main() {
    Account* a = new SavingsAccount(101, 10000, 4.5);
    a-display();
    delete a;
    return 0;
}

#include 
using namespace std;

class Employee {
protected: string name; int id;
public:
    Employee(string n,int i):name(n),id(i){}
    virtual double calculateSalary()=0;
    virtual void display(){cout<<name<<" Salary:"<<calculateSalary()<<"\n";}
    virtual ~Employee(){}
};
class FullTime : public Employee {
    double salary;
public:
    FullTime(string n,int i,double s):Employee(n,i),salary(s){}
    double calculateSalary() override {return salary;}
};
class PartTime : public Employee {
    double rate; int hours;
public:
    PartTime(string n,int i,double r,int h):Employee(n,i),rate(r),hours(h){}
    double calculateSalary() override {return rate*hours;}
};
int main() {
    Employee* e[]={new FullTime("Alice",1,50000),new PartTime("Bob",2,200,80)};
    if(auto x:e){x-display();delete x;}
    return 0;
}

#include 
using namespace std;

class Cylinder;
class Box {
    double l,w,h;
public:
    Box(double l,double w,double h):l(l),w(w),h(h){}
    friend void compare(Box b,Cylinder c);
};
class Cylinder {
    double r,h;
public:
    Cylinder(double r,double h):r(r),h(h){}
    friend void compare(Box b,Cylinder c);
};
void compare(Box b, Cylinder c) {
    double bv=b.l*b.w*b.h, cv=3.14*c.r*c.r*c.h;
    cout<<(bvcv?"Box":"Cylinder")<<" is larger\n";
}
int main(){Box b(3,4,5);Cylinder c(3,7);compare(b,c);    return 0;
}

#include 
using namespace std;

class Media {
protected: string title; int duration;
public:
    Media(string t,int d):title(t),duration(d){}
    virtual void play()=0;
    virtual void getInfo()=0;
    virtual ~Media(){}
};
class Song : public Media {
    string artist;
public:
    Song(string t,int d,string a):Media(t,d),artist(a){}
    void play() override { cout<<"Playing song: "<<title<<" by "<<artist<<"\n"; }
    void getInfo() override { cout<<title<<" | "<<duration<<"s\n"; }
};
class Movie : public Media {
    string director;
public:
    Movie(string t,int d,string dir):Media(t,d),director(dir){}
    void play() override { cout<<"Playing movie: "<<title<<" dir:"<<director<<"\n"; }
    void getInfo() override { cout<<title<<" | "<<duration<<"min\n"; }
};
int main(){
    Media* lib[]={new Song("Blinding Lights",200,"Weeknd"),new Movie("Inception",148,"Nolan")};
    if(auto m:lib){m-play();delete m;}
    return 0;
}

#include 
using namespace std;

// WRONG (ambiguous):
class A {public: void greet(){cout<<"Hello from A\n";}};
class B:public A{};
class C:public A{};
class D:public B,public C{};
// D d; d.greet(); // ERROR: ambiguous

// CORRECT (virtual inheritance):
class A {public: void greet(){cout<<"Hello from A\n";}};
class B: virtual public A{};
class C: virtual public A{};
class D: public B, public C{};
int main(){D d; d.greet();} // OK: one copy of A

#include 
using namespace std;

class A {int x;
public:
    A(int x):x(x){cout<<"A("<<x<<") created\n";}
    ~A(){cout<<"A destroyed\n";}};
class B:public A {int y;
public:
    B(int x,int y):A(x),y(y){cout<<"B("<<y<<") created\n";}
    ~B(){cout<<"B destroyed\n";}};
class C:public B {int z;
public:
    C(int x,int y,int z):B(x,y),z(z){cout<<"C("<<z<<") created\n";}
    ~C(){cout<<"C destroyed\n";}};
int main(){C obj(1,2,3);}  // Output: A(1)-B(2)-C(3)-~C-~B-~A

#include 
using namespace std;

class LibraryItem {
    int itemId;          // private - only this class
protected:
    string title, author; // accessible by derived
public:
    LibraryItem(int id,string t,string a):itemId(id),title(t),author(a){}
    int getId(){return itemId;}
    virtual void display()=0;
    virtual ~LibraryItem(){}
};
class Book : public LibraryItem {
    string ISBN; int pages;
public:
    Book(int id,string t,string a,string isbn,int p):LibraryItem(id,t,a),ISBN(isbn),pages(p){}
    void display() override {
        // title, author accessible (protected)
        cout<<"Book: "<<title<<" by "<<author<<" ISBN:"<<ISBN<<"\n";
    }
};
int main(){
    LibraryItem* items[]={new Book(1,"C++ Primer","Lippman","978-x",976)};
    if(auto i:items){i-display();delete i;}
    return 0;
}

#include 
using namespace std;

class IControllable {
public:
    virtual void turnOn()=0;
    virtual void turnOff()=0;
    virtual string getStatus()=0;
    virtual ~IControllable(){}};
class ISpeakable {
public:
    virtual void speak()=0;
    virtual ~ISpeakable(){}};
class SmartSpeaker:public IControllable,public ISpeakable{
    bool on=false;
public:
    void turnOn() override{on=true;cout<<"Speaker ON\n";}
    void turnOff() override{on=false;cout<<"Speaker OFF\n";}
    string getStatus() override{return on?"ON":"OFF";}
    void speak() override{cout<<"Playing music!\n";}};
int main(){
    SmartSpeaker s;
    IControllable* ctrl=&s;
    ISpeakable* spk=&s;
    ctrl-turnOn();
    spk-speak();
    ctrl-turnOff();
    return 0;
}

#include 
using namespace std;

class Person{
protected: string name; int age;
public:
    Person(string n,int a):name(n),age(a){}
    virtual void display()=0;
    virtual ~Person(){}};
class Student:public Person{
    int rollNo; float gpa; string branch;
public:
    Student(string n,int a,int r,float g,string b):Person(n,a),rollNo(r),gpa(g),branch(b){}
    void display() override{cout<<"Student:"<<name<<" Roll:"<<rollNo<<" GPA:"<<gpa<<"\n";}};
class Professor:public Person{
protected: string dept; double salary;
public:
    Professor(string n,int a,string d,double s):Person(n,a),dept(d),salary(s){}
    void display() override{cout<<"Prof:"<<name<<" Dept:"<<dept<<" Salary:"<<salary<<"\n";}};
class HOD:public Professor{
    int numFaculty;
public:
    HOD(string n,int a,string d,double s,int f):Professor(n,a,d,s),numFaculty(f){}
    void display() override{Professor::display();cout<<"  HOD of "<<dept<<", Faculty:"<<numFaculty<<"\n";}};
int main(){
    Person* uni[]={new Student("Alice",20,101,9.1,"CS"),new Professor("Dr.Smith",45,"Math",80000),new HOD("Dr.Roy",50,"CS",100000,15)};
    if(auto p:uni){p-display();delete p;}
    return 0;
}

#include 
using namespace std;

class WeatherStation;  // forward declaration
class Temperature{
    double celsius;
public:
    Temperature(double c):celsius(c){}
    inline double toCelsius(){return celsius;}
    inline double toFahrenheit(){return celsius*9/5+32;}
    inline double toKelvin(){return celsius+273.15;}
    friend void printReport(WeatherStation ws);};
class WeatherStation{
    string location;
    Temperature reading;
public:
    WeatherStation(string loc,double c):location(loc),reading(c){}
    friend void printReport(WeatherStation ws);};
void printReport(WeatherStation ws){
    cout<<"Location: "<<ws.location<<"\n";
    cout<<"Celsius: "<<ws.reading.toCelsius()<<"\n";
    cout<<"Fahrenheit: "<<ws.reading.toFahrenheit()<<"\n";
    cout<<"Kelvin: "<<ws.reading.toKelvin()<<"\n";}  
int main(){
    WeatherStation w1("Delhi",38),w2("Arctic",-40);
    printReport(w1);printReport(w2);    return 0;
}

Every program below is 100% compilable with full headers, main(), and expected output. Study the dry runs to understand memory execution step-by-step.

#include 
using namespace std;

#include <iostream>
using namespace std;

class Vehicle {
protected:
    string brand;
    int speed;
public:
    Vehicle(string b, int s) : brand(b), speed(s) {
        cout << "Vehicle constructor: " << brand << "\n";
    }
    virtual void describe() {
        cout << "Brand: " << brand << ", Speed: " << speed << "\n";
    }
    virtual ~Vehicle() { cout << "Vehicle destructor: " << brand << "\n"; }
};

class Car : public Vehicle {
protected:
    string fuelType;
public:
    Car(string b, int s, string f) : Vehicle(b, s), fuelType(f) {
        cout << "Car constructor: " << fuelType << "\n";
    }
    void describe() override {
        Vehicle::describe();
        cout << "Fuel: " << fuelType << "\n";
    }
    ~Car() { cout << "Car destructor\n"; }
};

class ElectricCar : public Car {
    int batteryRange;
public:
    ElectricCar(string b, int s, int r)
        : Car(b, s, "Electric"), batteryRange(r) {
        cout << "ElectricCar constructor: range=" << batteryRange << "\n";
    }
    void describe() override {
        Car::describe();
        cout << "Battery Range: " << batteryRange << " km\n";
    }
    ~ElectricCar() { cout << "ElectricCar destructor\n"; }
};

int main() {
    cout << "=== Creating ElectricCar ===\n";
    ElectricCar* ec = new ElectricCar("Tesla", 200, 500);
    cout << "\n=== Calling describe() ===\n";
    ec-describe();
    cout << "\n=== Deleting via base pointer ===\n";
    Vehicle* vp = ec;
    delete vp;
    return 0;
}

#include 
using namespace std;

#include <iostream>
#include <cmath>
using namespace std;

class Shape {                          // Abstract base class
public:
    string color;
    Shape(string c) : color(c) {}
    virtual double area()      = 0;    // pure virtual
    virtual double perimeter() = 0;    // pure virtual
    virtual void display() {
        cout << "[" << color << "] ";
    }
    virtual ~Shape() {}
};

class Circle : public Shape {
    double radius;
public:
    Circle(string c, double r) : Shape(c), radius(r) {}
    double area()      override { return 3.14159 * radius * radius; }
    double perimeter() override { return 2 * 3.14159 * radius; }
    void display() override {
        Shape::display();
        cout << "Circle r=" << radius
             << " | Area=" << area()
             << " | Perimeter=" << perimeter() << "\n";
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(string c, double w, double h)
        : Shape(c), width(w), height(h) {}
    double area()      override { return width * height; }
    double perimeter() override { return 2 * (width + height); }
    void display() override {
        Shape::display();
        cout << "Rect " << width << "x" << height
             << " | Area=" << area()
             << " | Perimeter=" << perimeter() << "\n";
    }
};

class Triangle : public Shape {
    double a, b, c;
public:
    Triangle(string col, double a, double b, double c)
        : Shape(col), a(a), b(b), c(c) {}
    double perimeter() override { return a + b + c; }
    double area() override {
        double s = perimeter() / 2;           // Heron's formula
        return sqrt(s*(s-a)*(s-b)*(s-c));
    }
    void display() override {
        Shape::display();
        cout << "Triangle " << a << "," << b << "," << c
             << " | Area=" << area() << "\n";
    }
};

int main() {
    Shape* shapes[] = {
        new Circle("Red", 5),
        new Rectangle("Blue", 4, 6),
        new Triangle("Green", 3, 4, 5)
    };

    double totalArea = 0;
    cout << "=== Shape Report ===\n";
    if(Shape* s : shapes) {
        s-display();
        totalArea += s-area();
    }
    cout << "Total Area: " << totalArea << "\n";

    if(Shape* s : shapes) delete s;
    return 0;
}

#include 
using namespace std;

#include <iostream>
using namespace std;

class Celsius;  // Forward declaration

class Fahrenheit {
    double fahr;
public:
    Fahrenheit(double f) : fahr(f) {}
    inline double getFahr() const { return fahr; }
    friend void printComparison(Fahrenheit f, Celsius c);
};

class Celsius {
    double cel;
public:
    Celsius(double c) : cel(c) {}
    inline double getCel() const { return cel; }
    inline double toFahrenheit() const { return cel * 9.0/5.0 + 32; }
    friend void printComparison(Fahrenheit f, Celsius c);
};

// Friend function — accesses BOTH classes' private members
void printComparison(Fahrenheit f, Celsius c) {
    cout << "Fahrenheit value  : " << f.fahr << "°F\n";
    cout << "Celsius value     : " << c.cel  << "°C\n";
    cout << "Celsius as °F     : " << c.toFahrenheit() << "°F\n";
    cout << "Are they equal?   : "
         << (f.fahr == c.toFahrenheit() ? "YES" : "NO") << "\n";
}

int main() {
    Fahrenheit boiling(212.0);
    Celsius    water(100.0);
    printComparison(boiling, water);

    cout << "\n";
    Fahrenheit freezing(32.0);
    Celsius    ice(0.0);
    printComparison(freezing, ice);
    return 0;
}