Inheritance in C++ with Modifiers

Inheritance in C++: An Overview

What is Inheritance in C++?

Example of Inheritance in C++

        #include <iostream>
class Animal {
public:
  void eat() {
    std::cout << "Animal is eating." << std::endl;
  }
};
class Dog : public Animal {
public:
  void bark() {
    std::cout << "Dog is barking." << std::endl;
  }
};
int main() {
  Dog dog;
  dog.eat(); // Animal is eating.
  dog.bark(); // Dog is barking.
  return 0;
}

The Dog class in this example derives from the Animal class. This means that the Dog class includes all of the members of the Animal class, as well as any extra members defined by it. The Dog class defines an additional member method called bark() in this situation.The main() function creates a Dog class object and calls its eat() and bark() member functions.

Output

        Animal is eating.Dog is barking.

Why use inheritance in C++?

• By allowing you to inherit common members from a base class into derived classes, inheritance increases code reusability.
• This eliminates the need for duplicating code and reduces the total coding effort.
• Inheritance aids in the hierarchical organization of code by reflecting the links between various classes.
• This improves the readability and maintainability of the code.
• Inheritance is the foundation for polymorphism, allowing objects of different classes to respond to the same method calls in different ways.
• This increases C++ object-oriented program flexibility and extension.

When to use inheritance in C++

• When you have a class hierarchy: If you have a group of related classes, and there is a considerable amount of code that is shared by all of them, then inheritance is an acceptable option.
• When you want to construct polymorphic classes: Inheritance is an excellent choice if you want to create classes that can respond to the same message in multiple ways.
• When you need to organize your code: If you wish to organize your code more logically and understandably, inheritance might be a useful concept.

Types of Inheritance Classes:

1. Base Class
2. Derived Class

1. Derived Class

2. Base Class

A base class is one that other classes inherit from. The base class defines the attributes and methods that its derived classes inherit. In addition, the base class can specify its properties and methods.

Example of Inheritance Classes

        
#include <iostream>
class Shape {
public:
 virtual void draw() = 0;
};
class Circle : public Shape {
public:
 Circle(int radius) : radius(radius) {}
 void draw() override {
  std::cout << "Drawing a circle with radius " << radius << std::endl;
 }
private:
 int radius;
};
class Rectangle : public Shape {
public:
 Rectangle(int width, int height) : width(width), height(height) {}
 void draw() override {
  std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl;
 }
private:
 int width;
 int height;
};
int main() {
 Circle circle(5);
 Rectangle rectangle(10, 20);
 circle.draw();
 rectangle.draw();
 return 0;
}

Output

Drawing a circle with radius 5

Drawing a rectangle with width 10 and height 20

Access Modes of Inheritance

1. Public Mode

2. Protected Mode

3. Private Mode

C++ protected Members

• Protected members are a sort of access specifier in C++ that regulates the accessibility of class members.
• Protected members can be accessed from within the class, as well as from any derived classes and friend functions in C++.
• They are, however, inaccessible from outside the class or from any other classes that are not inherited from it.

Here is a table summarising protected members' accessibility:

Example of C++ Protected Members

        
#include <iostream>
class Base {
protected:
 int data;
public:
 Base(int data) {
  this->data = data;
 }
 int getData() {
  return data;
 }
};
class Derived : public Base {
public:
 Derived(int data) : Base(data) {}
 int getDerivedData() {
  return data * 2;
 }
};
int main() {
 Base base(10);
 Derived derived(20);
 // Output: 10
 std::cout << base.getData() << std::endl;
 // Output: 20
 std::cout << derived.getData() << std::endl;
 // Output: 40
 std::cout << derived.getDerivedData() << std::endl;
 return 0;
}

In this example, the Base class's data member is protected, limiting access to the Base class, its derived classes, and friend methods of the Base class. The data member is unreachable outside of these bounds. The Derived class receives access to the data member by inheriting from the Base class, allowing the getDerivedData() method to access and alter it. This demonstrates how protected members can be accessed in a controlled manner within class hierarchies.

Output

102040

Types of Inheritance in C++

1. Single Inheritance: A single inheritance occurs when a class inherits from only one parent class.
2. Multiple Inheritance: Multiple Inheritance occurs when a class inherits from two or more parent classes.
3. Multilevel inheritance: Multilevel inheritance occurs when one class inherits from another, which in turn inherits from another, and so on.
4. Hierarchical Inheritance: Multiple classes inherit from a single-parent class in a hierarchical inheritance.
5. Hybrid Inheritance: Multiple inheritance and multilevel inheritance are combined in hybrid inheritance.

Summary