Polymorphism and Virtual Functions

# CHAPTER 18

Polymorphism and Virtual Functions #

1. Introduction #

2. Learning Objectives #

• Understand Compile-time vs. Runtime Polymorphism.

• Override Base class methods in Derived classes.

• Use the virtual keyword to enable Runtime Polymorphism.

• Understand Virtual Destructors.

• Create Pure Virtual Functions (Abstract classes).

3. Types of Polymorphism #

1. 1. Compile-Time (Early Binding): The compiler knows exactly which function to call when it compiles the code. Achieved via Function Overloading and Operator Overloading.

1. 2. Run-Time (Late Binding): The program decides which function to call *while it is running* based on the actual object type. Achieved via Virtual Functions.

4. The Problem: Function Overriding without virtual #

#include <iostream>
using namespace std;

class Animal {
  public:
    void speak() { cout << "Animal sound" << endl; }
};

class Dog : public Animal {
  public:
    void speak() { cout << "Woof!" << endl; }
};

int main() {
    Animal* ptr = new Dog(); // Base pointer pointing to a Derived object!
    
    ptr->speak(); // Output: "Animal sound" (Wait, it didn't say Woof!)
    
    return 0;
}

Why did this happen? Because ptr is of type Animal*, the compiler defaults to the Animal's version of speak() at compile-time (Early Binding).

5. The Solution: Virtual Functions #

class Animal {
  public:
    // virtual keyword enables runtime polymorphism
    virtual void speak() { cout << "Animal sound" << endl; }
};

class Dog : public Animal {
  public:
    // Use the 'override' keyword (C++11) for safety and readability
    void speak() override { cout << "Woof!" << endl; }
};

int main() {
    Animal* ptr = new Dog(); 
    
    ptr->speak(); // Output: "Woof!" (It works!)
    
    return 0;
}

6. The Virtual Destructor (CRITICAL) #

Rule of Thumb: If your class has ANY virtual functions, it MUST have a virtual destructor.

class Base {
  public:
    virtual ~Base() { cout << "Base destroyed"; }
};

class Derived : public Base {
  public:
    ~Derived() { cout << "Derived destroyed"; }
};
// Now, 'delete ptr;' will correctly call Derived destructor, then Base destructor.

7. Pure Virtual Functions and Abstract Classes #

By assigning = 0 to a virtual function, you make it a Pure Virtual Function. Any class with at least one pure virtual function becomes an Abstract Class, meaning it cannot be instantiated.

class Shape {
  public:
    // Pure Virtual Function
    virtual void draw() = 0; 
};

class Circle : public Shape {
  public:
    // Derived class MUST implement this function!
    void draw() override { cout << "Drawing a Circle" << endl; }
};

int main() {
    // Shape s; // ERROR! Cannot instantiate abstract class
    Shape* s1 = new Circle();
    s1->draw();
    return 0;
}

8. Memory-Level Explanation (The VTable) #

9. Common Mistakes #

• Forgetting virtual on the Destructor: Causes partial deletion of objects and memory leaks.

• Signature Mismatch: If the Base class has virtual void speak() const and the Derived class has void speak(), they are DIFFERENT functions. The override keyword catches these errors at compile time.

10. Exercises #

1. 1. Create an abstract class Vehicle with a pure virtual function move(). Create Car and Boat classes that implement move().

1. 2. Write a program with an array of Vehicle* pointers. Put a Car and a Boat in the array, and loop through them, calling move() on each.

11. MCQ Quiz with Answers #

12. Interview Questions #

• Q: Explain how the VTable and vptr work under the hood.

• Q: Can a constructor be virtual? Why or why not? (Answer: No, because the vptr isn't fully initialized until the constructor finishes).

• Q: What is an Abstract Class? Can it have non-virtual functions? (Answer: Yes, it only needs *one* pure virtual function to become abstract).

13. Summary #

14. Next Chapter Recommendation #