🎓 Unit 8: Virtual Functions and Polymorphism

A virtual function in C++ is a member function declared in a base class using the virtual keyword and intended to be redefined (overridden) in derived classes. Its primary purpose is to achieve runtime polymorphism, allowing the correct function implementation to be called based on the actual type of the object, even when accessed through a pointer or reference to the base class.

• **virtual keyword:**The virtual keyword is placed before the function's return type in the base class declaration to mark it as virtual.

• Overriding in derived classes:

  Derived classes can provide their own implementations of virtual functions with the same signature (name, return type, and parameters).

• override specifier (C++11 and later):

  While not strictly required, using the override keyword when redefining a virtual function in a derived class is good practice. It explicitly indicates that the function is intended to override a base class virtual function and helps the compiler catch potential errors (e.g., mismatched signatures).

  Syntax:

  class Base{
  public:
      virtual return_type functionName(){
          // Function body
      }
  };
  
  class Derived : public Base{
  public:
      
      // Overriden virtual function of the base class
      return_type functionName(){
          // Function body
      }
  }
  

1. Early Binding vs Late Binding

Binding refers to the process of converting identifiers (such as variable and performance names) into addresses. Binding is done for each variable and functions. For functions, it means that matching the call with the right function definition by the compiler. It takes place either at compile time or at runtime.

🔹 Early Binding (Static Binding)

• Occurs at compile-time.
• The function to be called is determined during compilation.
• Used when no inheritance or virtual functions are involved.

🔹 Late Binding (Dynamic Binding)

• Occurs at run-time.
• The function to be called is determined based on the actual object type during execution.
• Requires virtual functions in base class.