Inheritance is a fundamental concept in C++ programming, particularly in object-oriented programming (OOP). In this tutorial, we will explore what inheritance is, why it is used, the different modes of inheritance, and the various types of inheritance in C++. We will also provide practical examples to illustrate these concepts. ## What is Inheritance in C++? Inheritance in C++ is a mechanism where a derived class (child class) acquires properties and behaviors from a base class (parent class). This concept is similar to how a child inherits traits from their parents. In C++, the derived class can access the members of the base class, promoting code reusability and reducing redundancy. ### Key Terms - **Base Class**: The class whose properties are inherited. - **Derived Class**: The class that inherits properties from the base class. ## Why Use Inheritance in C++? Inheritance is utilized in C++ for several reasons: - **Code Reusability**: It allows programmers to reuse existing code, reducing the need to write the same code multiple times. - **Reduction of Redundancy**: By inheriting common properties and methods, redundancy in code is minimized. ### Example of Code Reusability Consider two classes: `TwoWheeler` and `FourWheeler`. Both classes may have similar properties like `color`, `brand`, and `mileage`. Instead of defining these properties in both classes, we can create a base class called `Vehicle` and have both `TwoWheeler` and `FourWheeler` inherit from it. This way, the common properties are defined only once in the `Vehicle` class. ## Modes of Inheritance In C++, inheritance can be categorized into three modes: 1. **Public Inheritance**: Public members of the base class remain public in the derived class, and protected members remain protected. 2. **Protected Inheritance**: Public and protected members of the base class become protected in the derived class. 3. **Private Inheritance**: Public and protected members of the base class become private in the derived class. ## Types of Inheritance C++ supports several types of inheritance: ### 1. Single Inheritance In single inheritance, a single derived class inherits from a single base class. The derived class can access the members of the base class, but not vice versa. #### Syntax ```cpp class DerivedClass : public BaseClass { // class members }; ``` ### 2. Multiple Inheritance Multiple inheritance occurs when a derived class inherits from more than one base class. This allows the derived class to inherit properties from multiple sources. #### Syntax ```cpp class DerivedClass : public BaseClass1, public BaseClass2 { // class members }; ``` ### 3. Multi-Level Inheritance In multi-level inheritance, a derived class is inherited from another derived class, forming a chain of inheritance. #### Syntax ```cpp class BaseClass1 { // class members }; class DerivedClass1 : public BaseClass1 { // class members }; class DerivedClass2 : public DerivedClass1 { // class members }; ``` ### 4. Hierarchical Inheritance Hierarchical inheritance involves multiple derived classes inheriting from a single base class. This structure allows different classes to share common properties. #### Syntax ```cpp class BaseClass { // class members }; class DerivedClass1 : public BaseClass { // class members }; class DerivedClass2 : public BaseClass { // class members }; ``` ### 5. Hybrid Inheritance Hybrid inheritance is a combination of two or more types of inheritance. It can include multiple and hierarchical inheritance. ## Practical Examples To solidify our understanding, let's look at some practical examples of inheritance in C++. ### Example 1: Single Inheritance ```cpp #include using namespace std; class Beverage { public: void drinks() { cout << "All drinks are available." << endl; } }; class Coffee : public Beverage { public: void mocha() { cout << "Mocha tastes the best." << endl; } }; int main() { Coffee c; c.drinks(); c.mocha(); return 0; } ``` ### Example 2: Multiple Inheritance ```cpp #include using namespace std; class Party { public: int meals; void food() { cout << "Enter number of meals: "; cin >> meals; } }; class Drinks { public: int drinks; void liquor() { cout << "Enter number of drinks: "; cin >> drinks; } }; class Bill : public Party, public Drinks { public: void total() { int totalBill = (meals * 90) + (drinks * 60); cout << "Total bill for the party is: " << totalBill << endl; } }; int main() { Bill b; b.food(); b.liquor(); b.total(); return 0; } ``` ### Example 3: Multi-Level Inheritance ```cpp #include using namespace std; class Chemistry { public: int marks1; void getChemistryMarks() { cout << "Enter marks in Chemistry: "; cin >> marks1; } }; class Physics : public Chemistry { public: int marks2; void getPhysicsMarks() { cout << "Enter marks in Physics: "; cin >> marks2; } }; class Maths : public Physics { public: int marks3; void getMathsMarks() { cout << "Enter marks in Maths: "; cin >> marks3; } void totalMarks() { int total = marks1 + marks2 + marks3; cout << "Total marks: " << total << endl; } }; int main() { Maths m; m.getChemistryMarks(); m.getPhysicsMarks(); m.getMathsMarks(); m.totalMarks(); return 0; } ``` ## Conclusion Inheritance is a powerful feature in C++ that enhances code reusability and reduces redundancy. Understanding the different modes and types of inheritance is crucial for effective programming in C++. By practicing with the examples provided, you can gain a deeper understanding of how inheritance works in C++. Keep experimenting with different inheritance structures to strengthen your programming skills.