Inheritance is a mechanism in OOP where a child class (derived class) acquires the properties (data and methods) of a parent class (base class). It promotes code reuse and reduces redundancy.

Example:
If class A has variable x and function print(), then class B can inherit them:

class A {
public:
 int x = 10;
 void print() {
  cout<<"Hello"<<endl;
 }
};

class B : public A {};

Now object of B can use:

B b;
b.print();
cout<<b.x;

In Object-Oriented Programming, inheritance involves several important terms that describe relationships between classes.

• Super Class: A class whose properties are inherited by another class. It is also known as the parent or base class.
  Example: class Animal is a superclass of class Dog.
• Parent Class: The class that gives its properties (data and methods) to another class.
  Example: Animal is the parent class of Dog.
• Base Class: Another name for the parent class from which a class is derived.
  Example: Animal is the base class.
• Derived Class: A class that inherits properties from another class. It is also called a child or subclass.
  Example: Dog is the derived class of Animal.
• Child Class: The class that receives properties from the parent class.
  Example: Dog is the child class.
• Subclass: Another term for a derived or child class.
  Example: Dog is a subclass of Animal.

Simple Example:

class Animal {};   // Super / Parent / Base class
class Dog : public Animal {};  // Derived / Child / Subclass

Single inheritance is the simplest type where a child class inherits from only one parent class.

Syntax:

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

Example:

class Animal {
public:
 Animal() {
  cout<<"I am an animal.\n";
 }
};

class Dog : public Animal {
public:
 Dog() {
  cout<<"I am a dog.\n";
 }
};

int main() {
 Dog obj;
}

Output:

I am an animal.
I am a dog.

Explanation:
Dog inherits Animal, so parent constructor runs first, then child.

In multiple inheritance, a child class inherits from more than one parent class.

Syntax:

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

Example:

class Animal {
public:
 Animal() {
  cout<<"I am an animal.\n";
 }
};

class Speak {
public:
 Speak() {
  cout<<"I can speak.\n";
 }
};

class Dog : public Animal, public Speak {};

int main() {
 Dog obj;
}

Output:

I am an animal.
I can speak.

Explanation:
Dog inherits both Animal and Speak → both constructors execute.

In multilevel inheritance, a class is derived from another derived class.Here, class A is the parent class, class B is the child class, which is inherited from the parent class A, and class B is the parent class for class C, which is being inherited from class B.

Syntax:

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

Example:

class Animal {
public:
 Animal() {
  cout<<"I am an animal.\n";
 }
};

class Dog : public Animal {
public:
 Dog() {
  cout<<"I am a dog.\n";
 }
};

class Pug : public Dog {
public:
 Pug() {
  cout<<"I am a pug.\n";
 }
};

int main() {
 Pug obj;
}

Output:

I am an animal.
I am a dog.
I am a pug.

Explanation:
Pug inherits Dog → Dog inherits Animal → chain execution happens.

In hierarchical inheritance, multiple child classes inherit from one parent class.

Syntax:

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

Example:

class Animal {
public:
 Animal() {
  cout<<"I am an animal.\n";
 }
};

class Dog : public Animal {};
class Cat : public Animal {};
class Pig : public Animal {};

int main() {
 Dog d;
 Cat c;
 Pig p;
}

Output:

I am an animal.
I am an animal.
I am an animal.

Explanation:
All child classes inherit from Animal → constructor called for each object.

• Suppose a base class is used to create two classes Parent1 and Parent2
• Both classes have a method sum()
• A child class inherits from both Parent1 and Parent2
• Now if child calls sum(), compiler gets confused → which one to call?

class S1 {
 void sum(int x, int y) {
  System.out.println(x + y);
 }
}

class S2 {
 void sum(int x, int y) {
  System.out.println(x + y);
 }
}

class D1 extends S1, S2 { // ERROR
}

Error: multiple inheritance not supported

• Both S1 and S2 have same method → conflict occurs
• Compiler cannot decide which method to use

The Diamond Problem occurs in multiple inheritance when a class inherits from two classes that have a common base class, causing ambiguity.

Concept:
If a class inherits the same method from two different paths, the compiler becomes confused about which method to use.

Diagram (Diamond Shape):

        Parent
        /   \
   Child1  Child2
        \   /
      GrandChild

Explanation:

• Parent has a method sum()
• Child1 and Child2 inherit sum()
• GrandChild inherits from both Child1 and Child2
• Now GrandChild gets two copies of sum()

Problem:

• When calling sum(), compiler cannot decide:
• Call from Child1 or Child2?

Example (Conceptual):

class Parent {
 void sum() {
  cout<<"Sum from Parent";
 }
};

class Child1 : public Parent {};
class Child2 : public Parent {};

class GrandChild : public Child1, public Child2 {};

int main() {
 GrandChild obj;
 obj.sum(); // Ambiguity error
}

Error:

Error: ambiguous call to sum()

Why Java Avoids This:

• Java does not support multiple inheritance with classes
• This avoids ambiguity completely

Solution in C++:

• Use virtual inheritance

The Diamond Problem creates ambiguity in method calls, which is why languages like Java avoid multiple inheritance using classes.