C++ Inheritance

Prev Next

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a class to acquire the properties and methods of another class. This mechanism promotes code reusability, improves organization, and establishes a natural hierarchy between classes.

Key Terms

• Base Class: The class from which properties and methods are inherited.

• Derived Class: The class that inherits properties and methods from the base class. It can also have additional features.

Benefits of Inheritance

1. Code Reusability: By inheriting from a base class, the derived class can reuse the code written in the base class, reducing redundancy.

2. Code Organization: Inheritance helps in organizing code better by grouping related functionality into base and derived classes.

3. Extensibility: Derived classes can extend or modify the functionality of base classes, making it easier to enhance the program without modifying existing code.

Types of Inheritance

• Single inheritance

• Multiple inheritance

• Hierarchical inheritance

• Multilevel inheritance

• Hybrid inheritance

1. Single Inheritance

Involves a single base class and a single derived class.

Example:

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

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

class Derived : public Base {
  public:
    void display() { cout << "Derived class"; }
};

int main() {
  Derived d;
  d.show(); // From Base
  d.display(); // From Derived

  return 0;
}

Output:

Base classDerived class

2. Multiple Inheritance

A derived class inherits from multiple base classes.

Example:

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

class Base1 {
  public:
    void show() { cout << "Base1 class"; }
};

class Base2 {
  public:
    void display() { cout << "Base2 class"; }
};

class Derived : public Base1, public Base2 {
  public:
    void print() { cout << "Derived class"; }
};

int main() {
  Derived d;
  d.show(); // From Base1
  d.display(); // From Base2
  d.print(); // From Derived

  return 0;
}

Output:

Base1 classBase2 classDerived class

3. Hierarchical Inheritance

Multiple derived classes inherit from a single base class.

Example:

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

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

class Derived1 : public Base {
  public:
    void display() { cout << "Derived1 class"; }
};

class Derived2 : public Base {
  public:
    void print() { cout << "Derived2 class"; }
};

int main() {
  Derived1 d1;
  Derived2 d2;
  d1.show(); // From Base
  d2.show(); // From Base

  return 0;
}

Output:

Base classBase class

4. Multilevel Inheritance

A derived class inherits from another derived class, forming a chain.

Example:

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

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

class Intermediate : public Base {
  public:
    void display() { cout << "Intermediate class"; }
};

class Derived : public Intermediate {
  public:
    void print() { cout << "Derived class"; }
};

int main() {
  Derived d;
  d.show(); // From Base
  d.display(); // From Intermediate
  d.print(); // From Derived

  return 0;
}

Output:

Base classIntermediate classDerived class

5. Hybrid Inheritance

Combines multiple types of inheritance. It can lead to complexity and ambiguity, especially in C++.

Example:

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

class Base1 {
  public:
    void show() { cout << "Base1 class"; }
};

class Base2 {
  public:
    void display() { cout << "Base2 class"; }
};

class Intermediate : public Base1 {
  public:
    void print() { cout << "Intermediate class"; }
};

class Derived : public Intermediate, public Base2 {
  public:
    void result() { cout << "Derived class"; }
};

int main() {
  Derived d;
  d.show(); // From Base1
  d.display(); // From Base2
  d.print(); // From Intermediate
  d.result(); // From Derived

  return 0;
}

Output:

Base1 classBase2 classIntermediate classDerived class

Visibility Modes

1. Public Inheritance: Public and protected members of the base class remain public and protected in the derived class. Derived class objects can access these members.

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

class Base {
  public:
    int publicVar;
  protected:
    int protectedVar;
};

class Derived : public Base {
  public:
    void access() {
      publicVar = 10; // Accessible
      protectedVar = 20; // Accessible
    }
};

int main() {
  Derived d;
  d.access();
  cout << "Public variable: " << d.publicVar << endl;
  // cout << "Protected variable: " << d.protectedVar << endl; // Error: protected member cannot be accessed directly

  return 0;
}

2. Protected Inheritance: Public and protected members of the base class become protected in the derived class. This restricts access to these members outside of the derived class.

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

class Base {
  public:
    int publicVar;
};

class Derived : protected Base {
  public:
    void access() {
      publicVar = 10; // Accessible within Derived
    }
};

int main() {
  Derived d;
  d.access();
  // d.publicVar = 20; // Error: publicVar is not accessible directly

  return 0;
}

3. Private Inheritance: Public and protected members of the base class become private in the derived class. The derived class itself can access these members, but they are not accessible to objects of the derived class.

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

class Base {
  public:
    int publicVar;
};

class Derived : private Base {
  public:
    void access() {
      publicVar = 10; // Accessible within Derived
    }
};

int main() {
  Derived d;
  d.access();
  // d.publicVar = 20; // Error: publicVar is not accessible directly

  return 0;
}

Accessing Base Class Members

• Direct Access: Derived classes can access public and protected members of the base class.

• Via Member Functions: Derived class member functions can call base class member functions and access base class data members.

Conclusion

Inheritance in C++ facilitates code reusability and helps in building a hierarchical relationship between classes. It allows for better organization and management of code, making it easier to extend and maintain. The various types of inheritance and visibility modes offer flexibility in how classes interact with each other.

Prev Next