Inheritance allows one class to acquire the properties and behavior of another class.

class Derived : access_modifier Base {
    // members
};


#include <iostream>
using namespace std;

class Person {
public:
    void showPerson() {
        cout << "I am a person\n";
    }
};

class Student : public Person {
public:
    void showStudent() {
        cout << "I am a student\n";
    }
};

int main() {
    Student s;
    s.showPerson();   // inherited
    s.showStudent();
}


#include <iostream>
using namespace std;

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

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

class Puppy : public Dog {
public:
    void weep() { cout << "Weeping...\n"; }
};

int main() {
    Puppy p;
    p.eat();
    p.bark();
    p.weep();
}


A derived class inherits from more than one base class.

#include <iostream>
using namespace std;

class Teacher {
public:
    void teach() { cout << "Teaching...\n"; }
};

class Researcher {
public:
    void research() { cout << "Researching...\n"; }
};

class Professor : public Teacher, public Researcher {
public:
    void guide() { cout << "Guiding students...\n"; }
};

int main() {
    Professor p;
    p.teach();
    p.research();
    p.guide();
}


One base class with multiple derived classes.

      Base
    /   |   \
 D1    D2    D3


#include <iostream>
using namespace std;

class Shape {
public:
    void draw() { cout << "Drawing shape...\n"; }
};

class Circle : public Shape {
public:
    void area() { cout << "Circle area formula\n"; }
};

class Rectangle : public Shape {
public:
    void area() { cout << "Rectangle area formula\n"; }
};

int main() {
    Circle c;
    Rectangle r;

    c.draw();
    c.area();

    r.draw();
    r.area();
}


A combination of two or more inheritance types.

Often leads to the diamond problem, solved using virtual inheritance.

#include <iostream>
using namespace std;

class A {
public:
    void show() { cout << "From A\n"; }
};

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

class D : public B, public C {};

int main() {
    D obj;
    obj.show(); // no ambiguity
}


class A {
public:
    A() { cout << "A constructor\n"; }
};

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


Same function signature in base and derived classes.

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

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

int main() {
    Base* b = new Derived();
    b->show();
}
