Cpp Programming Run Time Polymorphism And Vtable Complete Guide

Runtime Polymorphism

Runtime Polymorphism, also known as dynamic polymorphism, allows objects to be treated as instances of their parent class instead of their actual class. The most common use of runtime polymorphism is when a parent class reference is used to refer to a child class object.

In C++, this mechanism is typically achieved using virtual functions.

Steps to Implement Runtime Polymorphism:

1. Define Base and Derived Classes: Create a base class that contains virtual functions. This will enable polymorphism.
2. Override Virtual Functions in Derived Class: Extend the functionality by overriding the virtual functions in the derived classes.
3. Create Pointers or References to Base Class: Use pointers or references of the base class to point to objects of the derived class.
4. Invoke Overridden Functions: When calling the virtual function using the base class pointer/reference, the appropriate version of the function from the derived class will be executed at runtime.

Example Code

Let’s create two simple classes Animal and Dog where Dog inherits from Animal. We will define a virtual function speak in the Animal class which is overridden by Dog.

#include <iostream>
using namespace std;

// Base class
class Animal {
public:
    // Virtual function
    virtual void speak() {
        cout << "Some generic animal sound!" << endl;
    }
};

// Derived class
class Dog : public Animal {
public:
    // Override the speak function
    void speak() override {
        cout << "Woof Woof!" << endl;
    }
};

int main() {
    Animal* animalPtr;  // Base class pointer
    Dog dogObj;         // Derived class object
    
    // Point base class pointer to derived class object
    animalPtr = &dogObj;
    
    // Call the overridden function
    animalPtr->speak();  // Outputs: Woof Woof!
    
    return 0;
}

Explanation:

1. Class Animal: This is our base class with a virtual function speak.
2. Class Dog: Inherits from Animal and overrides the speak function.
3. Pointer animalPtr: A pointer of type Animal is created.
4. Object dogObj: An object of type Dog is created.
5. Assigning Pointer: The animalPtr pointer is assigned to point to the dogObj. Since animalPtr is a pointer to Animal, dogObj must have been an instance of a class derived from Animal.
6. Function call: The function speak() is called on animalPtr, but since speak is virtual and has been overridden in the derived class Dog, the Dog class’s speak() function is executed, producing "Woof Woof!".

The Concept of vtable (Virtual Table)

When you declare a virtual function in a class, C++ does several things behind the scenes to enable polymorphism. One such mechanism is the Virtual Table (often abbreviated as vtable).

Vtable is a lookup table that stores addresses of virtual functions in derived classes.

How it works:

1. Base Class: For the first class containing virtual functions, C++ creates a vtable storing addresses of these virtual functions.
2. Derived Classes: Each subsequent derived class gets its own vtable, which stores addresses of the functions present in its own class and those it inherits.
3. Pointer or Reference: Whenever you have a pointer or reference of the base class pointing to an object of the derived class, C++ uses the vtable to find and call the correct overriding function.

Vtable Illustration Example:

Let’s extend the above example to include one more derived class Cat and add more information to understand the usage of the vtable.

#include <iostream>
using namespace std;

// Base class
class Animal {
public:
    virtual void speak() {
        cout << "Some generic animal sound!" << endl;
    }

    virtual void eat() {
        cout << "Eating some food." << endl;
    }
};

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

    void eat() override {
        cout << "Eating dog food." << endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void speak() override {
        cout << "Meow Meow!" << endl;
    }

    void eat() override {
        cout << "Eating cat food." << endl;
    }
};

int main() {
    Animal* animalPtr;  // Base class pointer

    Dog dogObj;         // Derived class object
    Cat catObj;         // Another derived class object

    // Point base class pointer to derived class object Dog
    animalPtr = &dogObj;
    animalPtr->speak();  // Outputs: Woof Woof!
    animalPtr->eat();    // Outputs: Eating dog food.

    // Point base class pointer to derived class object Cat
    animalPtr = &catObj;
    animalPtr->speak();  // Outputs: Meow Meow!
    animalPtr->eat();    // Outputs: Eating cat food.

    return 0;
}

How Vtable is Used in the Above Example:

• Base Class Animal: Has a vtable containing pointers to the speak() and eat() functions.
• Derived Class Dog: Has its own vtable which points to Dog::speak() and Dog::eat().
• Derived Class Cat: Has its own vtable which points to Cat::speak() and Cat::eat().

When you assign animalPtr to point to dogObj, the compiler adjusts the pointer to use Dog's vtable. When you assign animalPtr to point to catObj, the compiler adjusts the pointer to use Cat's vtable.

During runtime, when you invoke animalPtr->speak() or animalPtr->eat(), the function is resolved based on the vtable pointed to by animalPtr.

Thus, even though animalPtr is of type Animal *, the correct speak and eat methods of the derived classes (Dog and Cat) get called because the compiler uses the vtable pointed to by animalPtr to find and invoke the correct functions.

Summary of Key Points:

• Virtual Functions: Allow overriding in derived classes.
• Base Class Pointer: Can point to objects of derived classes.
• Dynamic Binding: Occurs at runtime to determine which method to call.
• Vtable: Stores addresses of virtual functions, enabling polymorphic behavior.