Polymorphism

A virtual function is a member function that is declared in a base class using the virtual keyword and redefined (overridden) in a derived class. It enables late binding, meaning that the compiler decides which function to call at runtime based on the object type, not the pointer type. This is a key feature of runtime polymorphism.

The term “Polymorphism” refers to the ability to take many forms. When applied to object-oriented programming (OOP), polymorphism allows different classes related by inheritance to behave in various ways under a common interface. Breaking it down, Poly means “many” and morphism means “forms”, implying different behaviors in different contexts.

Concept of Virtual Functions

Virtual functions in C++ allow a base class pointer to invoke derived class functions, achieving runtime polymorphism. The base class’s function is overridden by the derived class function, but the call is resolved at runtime. A key point to remember is that virtual functions aren’t allowed in constructors since the object construction follows a “bottom-up” approach.

Example without Virtual Functions

Let’s look at a simple example where we calculate the area of different shapes without using virtual functions:

#include <iostream>
using namespace std;

class Shape {
public:
    Shape(int l, int w) : length(l), width(w) {}
    int getArea() {
        cout << "This is a call to the base class area\n";
        return 1;
    }

protected:
    int length, width;
};

class Square : public Shape {
public:
    Square(int l = 0, int w = 0) : Shape(l, w) {}
    int getArea() {
        cout << "Square area: " << length * width << endl;
        return length * width;
    }
};

class Rectangle : public Shape {
public:
    Rectangle(int l = 0, int w = 0) : Shape(l, w) {}
    int getArea() {
        cout << "Rectangle area: " << length * width << endl;
        return length * width;
    }
};

int main() {
    Shape* s;
    Square sq(4, 4);
    Rectangle rec(4, 5);

    s = &sq;
    s->getArea();  // Calls base class method
    s = &rec;
    s->getArea();  // Calls base class method

    return 0;
}

Output:

This is a call to the base class area
This is a call to the base class area

Here, despite pointing to derived class objects, the getArea() function of the base class is called due to static binding.

Example with Virtual Functions

Now, let’s modify the code to include virtual functions for achieving runtime polymorphism:

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void calculateArea() {
        cout << "Calculating area in base class" << endl;
    }
    virtual ~Shape() {
        cout << "Shape destructor called" << endl;
    }
};

class Square : public Shape {
public:
    int side;
    Square(int s) : side(s) {}

    void calculateArea() override {
        cout << "Square area: " << side * side << endl;
    }

    ~Square() {
        cout << "Square destructor called" << endl;
    }
};

class Rectangle : public Shape {
public:
    int width, height;
    Rectangle(int w, int h) : width(w), height(h) {}

    void calculateArea() override {
        cout << "Rectangle area: " << width * height << endl;
    }

    ~Rectangle() {
        cout << "Rectangle destructor called" << endl;
    }
};

int main() {
    Shape* shape;
    Square sq(4);
    Rectangle rec(5, 6);

    shape = &sq;
    shape->calculateArea();  // Calls Square's method

    shape = &rec;
    shape->calculateArea();  // Calls Rectangle's method

    return 0;
}

Output:

Square area: 16
Rectangle area: 30

In this example, the calculateArea() function calls are resolved at runtime, based on the actual object being pointed to. This demonstrates the power of virtual functions and runtime polymorphism.

How Virtual Functions are Resolved at Runtime

To resolve virtual functions at runtime, the compiler typically uses two mechanisms:

• vtable: A table of function pointers maintained per class.
• vptr: A pointer to the vtable, maintained per object instance.

At runtime, the vptr helps the compiler determine which function (base or derived) to invoke by consulting the appropriate vtable.

Practical Use of Virtual Functions: Employee Management System

Consider a scenario of managing employees in an organization. Suppose you have a base class Employee and derived classes like Manager and Engineer. Each class may override virtual functions like raiseSalary() or promote(). The virtual mechanism allows these functions to be called based on the actual type of employee without worrying about their specific implementation.

class Employee {
public:
    virtual void raiseSalary() {
        // General salary raise logic
    }
    virtual void promote() {
        // General promotion logic
    }
    virtual ~Employee() {}
};

class Manager : public Employee {
public:
    void raiseSalary() override {
        // Manager-specific raise logic
    }
    void promote() override {
        // Manager-specific promotion logic
    }
};

class Engineer : public Employee {
public:
    void raiseSalary() override {
        // Engineer-specific raise logic
    }
    void promote() override {
        // Engineer-specific promotion logic
    }
};

void applyRaise(Employee* employees[], int size) {
    for (int i = 0; i < size; ++i) {
        employees[i]->raiseSalary();
    }
}