Question

What is polymorphism in C++, and how can it be implemented using virtual functions?

Answer 1

Let's break down polymorphism in C++ in a clear, structured way.

What is Polymorphism?

At its core, Polymorphism is one of the fundamental principles of Object-Oriented Programming (OOP). The word itself comes from Greek: "poly" (meaning many) and "morph" (meaning forms).

In programming, this translates to the ability of an object, function, or interface to take on many different forms. The most common and powerful application of this is having a single, generic interface that can be used to interact with different types of related objects.

Simple Analogy:
Imagine you have a universal remote control (the interface). This remote has a "power" button.
When you point it at your TV and press "power", the TV turns on.
When you point it at your Stereo System and press the same "power" button, the stereo turns on.
* When you point it at your Gaming Console, the console turns on.

You are using the exact same action (pressing the "power" button) but getting a different, specific result depending on the object you are interacting with. This is the essence of polymorphism.

In C++, there are two main types of polymorphism:
1. Compile-time (Static) Polymorphism: The decision of which function to call is made at compile time. This is achieved through function overloading and operator overloading.
2. Run-time (Dynamic) Polymorphism: The decision of which function to call is delayed until runtime. This is the more powerful form of polymorphism and is achieved using virtual functions. Your question is focused on this type.

---

How to Implement Polymorphism Using Virtual Functions

Run-time polymorphism is achieved through a combination of inheritance, base class pointers/references, and the virtual keyword. It allows you to write generic code that works with a family of classes without needing to know their specific types at compile time.

Here are the key ingredients and the step-by-step process:

Key Ingredients:

1. A Base Class: A class that defines a common interface for a group of related classes.
2. The virtual keyword: Used in the base class to declare a function whose implementation can be overridden by derived classes. This tells the compiler, "Don't decide which version of this function to call now; wait until the program is running."
3. Derived Classes: Classes that inherit from the base class and provide their own specific implementation (override) for the virtual function.
4. Base Class Pointers or References: A pointer or reference of the base class type that points to an object of a derived class. This is the mechanism through which polymorphism is invoked.

Step-by-Step Implementation with a Code Example

Let's use the classic example of geometric shapes. All shapes can be drawn, but how you draw a circle is different from how you draw a square.

Step 1: Create a Base Class with a virtual function.

We'll create a Shape class. Its draw() method doesn't have a meaningful implementation, so we'll just make it print a generic message. The crucial part is marking it as virtual.

`cpp

include

include

// 1. Base Class with a virtual function
class Shape {
public:

// The 'virtual' keyword enables dynamic dispatch (run-time polymorphism).
virtual void draw() const {
    std::cout << "Drawing a generic shape..." << std::endl;
}

// It's crucial to have a virtual destructor in a polymorphic base class!
virtual ~Shape() {} 

};
`
> Important Note on Virtual Destructors: If you plan to delete a derived class object through a base class pointer (delete shapePtr;), you must declare the destructor in the base class as virtual. Otherwise, only the base class destructor will be called, leading to memory leaks.

Step 2: Create Derived Classes that Override the Virtual Function.

Now we create Circle and Rectangle classes that inherit from Shape. They provide their own specific versions of the draw() method. The override keyword is a modern C++ best practice; it tells the compiler you intend to override a base class function and will cause a compile error if you make a mistake (e.g., a typo in the function name).

`cpp
// 2. Derived Classes that override the virtual function
class Circle : public Shape {
public:

// 'override' is a safety check to ensure we are actually overriding a base virtual function.
void draw() const override {
    std::cout << "Drawing a circle: O" << std::endl;
}

};

class Rectangle : public Shape {
public:

void draw() const override {
    std::cout << "Drawing a rectangle: []" << std::endl;
}

};
`

Step 3: Use Base Class Pointers to Demonstrate Polymorphism.

In our main function, we'll create a pointer of type Shape*. We can make this pointer point to a Circle object and then to a Rectangle object. When we call draw() through this pointer, C++ will determine the actual type of the object at runtime and call the correct draw() method.

`cpp
// A function that uses a Shape pointer, demonstrating that
// it doesn't need to know the specific type of shape.
void drawAnyShape(const Shape* shape) {

shape->draw(); // The correct draw() is called here at RUNTIME!

}

int main() {

Circle myCircle;
Rectangle myRectangle;
Shape myShape;

Shape* shapePtr; // 3. A single pointer to the base class

// Point to a Circle object and call draw()
shapePtr = &myCircle;
shapePtr->draw(); // Calls Circle::draw()

// Point to a Rectangle object and call draw()
shapePtr = &myRectangle;
shapePtr->draw(); // Calls Rectangle::draw()

// Point to the base Shape object
shapePtr = &myShape;
shapePtr->draw(); // Calls Shape::draw()

std::cout << "\n--- Using a function ---\n";
drawAnyShape(&myCircle);
drawAnyShape(&myRectangle);

return 0;

}
`

Expected Output:

`
Drawing a circle: O
Drawing a rectangle: []
Drawing a generic shape...

--- Using a function ---
Drawing a circle: O
Drawing a rectangle: []
`

How Does It Work Under the Hood? (The V-Table)

The "magic" of virtual functions is typically implemented by compilers using a Virtual Table (or vtable).

1. V-Table Creation: For any class that has at least one virtual function, the compiler creates a static array of function pointers called the vtable. This table holds the addresses of the virtual functions for that specific class.
2. V-Pointer (vptr) Creation: The compiler adds a hidden pointer, the vptr, as a member to each object of that class. This vptr points to the vtable for its class.
3. Runtime Resolution: When you make a call like shapePtr->draw(), the program performs these steps at runtime:
   • It follows the shapePtr to the object in memory.
   • It reads the object's hidden vptr.
   • It follows the vptr to the class's vtable.
   • It looks up the address of the correct draw() function in the vtable and calls it.

Because the vptr in a Circle object points to the Circle vtable, and the vptr in a Rectangle object points to the Rectangle vtable, the correct function is called dynamically. This process is called dynamic dispatch or late binding.