Question

In C++, what is the fundamental problem that the virtual keyword solves when working with inheritance and pointers, and what is the practical difference in behavior when a base class function is declared with versus without it?

Answer 1

The virtual keyword solves the critical problem of static vs. dynamic binding, enabling runtime polymorphism, which is arguably the most powerful feature of Object-Oriented Programming.

In simple terms, virtual tells the compiler: "Don't decide which version of this function to call at compile-time based on the pointer's type; instead, wait until the program is running and call the version that belongs to the actual object the pointer is pointing to."

Let's break this down with a practical example.

---

The Scenario: Without virtual (Static Binding)

Consider a base class Shape and two derived classes, Circle and Square. All have a draw() method.

`cpp

include

class Shape {
public:

// NOTE: No 'virtual' keyword here
void draw() {
    std::cout << "Drawing a generic shape." << std::endl;
}

};

class Circle : public Shape {
public:

void draw() {
    std::cout << "Drawing a circle." << std::endl;
}

};

class Square : public Shape {
public:

void draw() {
    std::cout << "Drawing a square." << std::endl;
}

};

// A function that uses a base class pointer to work with any shape
void drawAnyShape(Shape* shapePtr) {

shapePtr->draw(); // Which draw() gets called?

}

int main() {

Shape s;
Circle c;
Square sq;

std::cout << "Calling drawAnyShape with different objects:" << std::endl;
drawAnyShape(&s);
drawAnyShape(&c);   // Passing a pointer to a Circle object
drawAnyShape(&sq);  // Passing a pointer to a Square object

return 0;

}
`

Behavior and Explanation (Static Binding):

When you compile and run this code, the output will be:

Calling drawAnyShape with different objects: Drawing a generic shape. Drawing a generic shape. Drawing a generic shape.

This is incorrect and not what we want. The reason is static binding (or early binding). At compile-time, the compiler looks at the line shapePtr->draw();. It sees that shapePtr is of type Shape*. Therefore, it binds the call directly to the Shape::draw() function. It has no knowledge of the actual object type (Circle or Square) that the pointer will hold at runtime.

---

The Solution: With virtual (Dynamic Binding)

Now, let's make one tiny but crucial change: add the virtual keyword to the draw() function in the base class.

`cpp

include

class Shape {
public:

// The ONLY change is adding the 'virtual' keyword
virtual void draw() {
    std::cout << "Drawing a generic shape." << std::endl;
}
// It's good practice to have a virtual destructor in a polymorphic base class
virtual ~Shape() {} 

};

class Circle : public Shape {
public:

// 'override' is a modern C++ keyword that ensures we are correctly overriding a virtual function
void draw() override {
    std::cout << "Drawing a circle." << std::endl;
}

};

class Square : public Shape {
public:

void draw() override {
    std::cout << "Drawing a square." << std::endl;
}

};

// This function remains unchanged
void drawAnyShape(Shape* shapePtr) {

shapePtr->draw(); // Which draw() gets called NOW?

}

int main() {

Shape s;
Circle c;
Square sq;

std::cout << "Calling drawAnyShape with different objects:" << std::endl;
drawAnyShape(&s);

drawAnyShape(&c);   // Passing a pointer to a Circle object
drawAnyShape(&sq);  // Passing a pointer to a Square object

return 0;

}
`

Behavior and Explanation (Dynamic Binding):

Now, the output is exactly what we intended:

Calling drawAnyShape with different objects: Drawing a generic shape. Drawing a circle. Drawing a square.

This is dynamic binding (or late binding). The virtual keyword instructs the compiler to generate special code. Under the hood, it creates a Virtual Table (v-table) for each class with virtual functions. Each object of these classes then contains a hidden pointer, the Virtual Pointer (v-ptr), which points to its class's v-table.

When shapePtr->draw() is called, the program performs these steps at runtime:
1. Follows the shapePtr to the object in memory.
2. Finds the object's hidden v-ptr.
3. Follows the v-ptr to the correct v-table (the Circle's v-table if it's a Circle object).
4. Looks up the address of the draw() function in that v-table and calls it.

This allows the drawAnyShape function to be incredibly flexible. It can work with any current or future class derived from Shape without ever needing to be recompiled.

Summary

| Feature | Without virtual (Non-Virtual Function) | With virtual (Virtual Function) |
| ------------------- | -------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| Binding | Static Binding (at compile-time) | Dynamic Binding (at runtime) |
| Resolution | The function call is resolved based on the type of the pointer/reference. | The function call is resolved based on the type of the object being pointed to. |
| Mechanism | Direct function call. | Indirect call through a v-table and v-ptr. |
| Use Case | For functions whose behavior should not change in derived classes. | To achieve polymorphism. Essential for writing generic code that operates on base class interfaces. |
| Result | Fails to achieve polymorphic behavior. | Enables true OOP polymorphism, the cornerstone of flexible and extensible systems. |