C++ Object Oriented Programming: Function Overriding

Study Notes

Function overriding occurs when a derived class provides a specific implementation of a function that is already defined in its base class.
This allows the derived class to modify the behavior of the function.
Function overriding in C++ can only occur in the presence of inheritance.
Overridden functions must have the same function signature (i.e., the number of parameters and their data type).

Early binding refers to the compile-time association of a function call with a function definition.
In simple function overriding (without virtual), the compiler determines which function to call based on the type of the pointer or reference, not the actual object type.
Function overriding does not work correctly in C++ without the virtual keyword.

Declaring a function as virtual in the base class allows it to be dynamically bound at runtime, known as late binding (or dynamic binding).
This means the function call is resolved at runtime based on the actual object type.
Rules for creating a virtual function in C++:
- The functions cannot be static
- You derive them using the “virtual” keyword
- Virtual functions need to be a member of some base class
- The prototype of these functions should be the same for both the base and derived class
- Virtual functions are accessible using object pointers
- Redefining the virtual function in the derived class is optional, but it needs to be defined in the base class
- The function call resolving is done at run-time
- Virtual functions enable dynamic (or runtime) polymorphism, allowing the program to decide which function implementation to invoke at runtime based on the type of the object being referred to.

An abstract class in C++ is a class that cannot be instantiated but serves as a blueprint for derived classes.
An abstract class is a base class from which other classes can inherit.
Abstract classes define common characteristics and behavior that derived classes should possess while allowing each derived class to have its own specific implementation.
Abstract classes cannot be used to instantiate objects, but classes that can be used to instantiate objects are called concrete classes.
A pure virtual function is declared by using the = 0 syntax in the base class, indicating that the function does not have an implementation in the base class and must be overridden in any derived class that is not abstract.
A class that contains at least one pure virtual function is considered an abstract class and cannot be instantiated.
Derived classes must provide an implementation for all inherited pure virtual functions unless they are also abstract.
Benefits of Abstract classes:
- Abstraction: Abstract classes allow you to define common behavior and characteristics that derived classes should possess, promoting code reusability and a clear and consistent interface for related classes.
- Polymorphism: Abstract classes play a crucial role in achieving polymorphism, allowing you to treat objects of derived classes as objects of the abstract class, providing a powerful mechanism for polymorphic behavior.