**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Object-Oriented Programming (OOP) in C++ **Topic:** Inheritance, polymorphism, virtual functions, and abstract classes. ### Introduction to Inheritance Inheritance is a fundamental concept in object-oriented programming (OOP) that allows one class to inherit properties and behavior from another class. The class that inherits properties and behavior is called the _derived class_ or _subclass_, while the class from which properties and behavior are inherited is called the _base class_ or _superclass_. Inheritance is useful for creating a new class that is a modified version of an existing class. ### Single Inheritance Single inheritance is the simplest form of inheritance, where a derived class inherits from a single base class. Here's an example: ```cpp class Animal { public: void eat() { std::cout << "Eating..." << std::endl; } }; class Dog : public Animal { public: void bark() { std::cout << "Barking..." << std::endl; } }; int main() { Dog myDog; myDog.eat(); // Output: Eating... myDog.bark(); // Output: Barking... return 0; } ``` In this example, the `Dog` class inherits the `eat()` method from the `Animal` class and also has its own `bark()` method. ### Multiple Inheritance Multiple inheritance is when a derived class inherits from more than one base class. Here's an example: ```cpp class Animal { public: void eat() { std::cout << "Eating..." << std::endl; } }; class Mammal { public: void sleep() { std::cout << "Sleeping..." << std::endl; } }; class Dog : public Animal, public Mammal { public: void bark() { std::cout << "Barking..." << std::endl; } }; int main() { Dog myDog; myDog.eat(); // Output: Eating... myDog.sleep(); // Output: Sleeping... myDog.bark(); // Output: Barking... return 0; } ``` In this example, the `Dog` class inherits the `eat()` method from the `Animal` class and the `sleep()` method from the `Mammal` class. ### Polymorphism Polymorphism is the ability of an object to take on many forms. In C++, polymorphism can be achieved through function overloading or function overriding. ### Function Overloading Function overloading is when multiple functions with the same name can be defined, but with different parameters. Here's an example: ```cpp void print(int x) { std::cout << "Printing an integer: " << x << std::endl; } void print(double x) { std::cout << "Printing a double: " << x << std::endl; } int main() { print(5); // Output: Printing an integer: 5 print(3.14); // Output: Printing a double: 3.14 return 0; } ``` In this example, the `print()` function is overloaded to take either an `int` or a `double` as an argument. ### Function Overriding Function overriding is when a derived class provides a different implementation of a function that is already defined in its base class. Here's an example: ```cpp class Animal { public: void sound() { std::cout << "Making a generic sound..." << std::endl; } }; class Dog : public Animal { public: void sound() { std::cout << "Barking..." << std::endl; } }; int main() { Animal myAnimal; Dog myDog; myAnimal.sound(); // Output: Making a generic sound... myDog.sound(); // Output: Barking... Animal* animal = &myDog; animal->sound(); // Output: Making a generic sound... return 0; } ``` In this example, the `Dog` class overrides the `sound()` method from the `Animal` class. However, when called through a base class pointer, the base class method is called. ### Virtual Functions Virtual functions are functions that can be overridden by a derived class. They are used to achieve runtime polymorphism. Here's an example: ```cpp class Animal { public: virtual void sound() { std::cout << "Making a generic sound..." << std::endl; } }; class Dog : public Animal { public: void sound() override { std::cout << "Barking..." << std::endl; } }; int main() { Animal* animal = new Dog(); animal->sound(); // Output: Barking... delete animal; return 0; } ``` In this example, the `sound()` method from the `Animal` class is made virtual, allowing it to be overridden by the `Dog` class. When called through a base class pointer, the derived class method is called. ### Abstract Classes Abstract classes are classes that cannot be instantiated and are used as base classes for other classes. They are useful for defining an interface or a base class that other classes must implement. Here's an example: ```cpp class Animal { public: virtual void sound() = 0; // Pure virtual function }; class Dog : public Animal { public: void sound() override { std::cout << "Barking..." << std::endl; } }; int main() { // Error: Cannot instantiate abstract class // Animal myAnimal; Dog myDog; myDog.sound(); // Output: Barking... return 0; } ``` In this example, the `Animal` class is made abstract by declaring the `sound()` method as a pure virtual function. This means that any derived class must implement the `sound()` method. ### Conclusion In heritage, polymorphism, virtual functions, and abstract classes are powerful features of object-oriented programming that allow you to create complex and flexible class hierarchies. By understanding how to use these features effectively, you can write more efficient and maintainable code. ### Practical Takeaways * Use inheritance to create a new class that is a modified version of an existing class. * Use polymorphism to allow objects of different classes to be treated as objects of a common superclass. * Use virtual functions to achieve runtime polymorphism. * Use abstract classes to define an interface or a base class that other classes must implement. ### Additional Resources * [The C++ Programming Language](https://www.stroustrup.com/4th.html) * [C++11/C++14/C++17/C++20 : Where do we stand](https://www.youtube.com/watch?v=ub3_-tTw7vI) Do you have any questions on this topic?