C++ Polymorphism

Definition: The word Polymorphism means "many forms." In C++, it occurs when there is a hierarchy of classes related by inheritance. It allows us to perform a single action in different ways. Most commonly, polymorphism happens when a derived (child) class overrides a method from its base (parent) class to provide its own specific behavior.

Why: Polymorphism is a cornerstone of the beginner C++ OOP syllabus because it allows for high-level abstraction. You can write a single piece of code that works with a general "Parent" type, but it will automatically trigger the correct "Child" behavior depending on which object is actually being used at runtime.

The "Same Name, Different Behavior" Principle

In procedural programming, you might need different function names like catSound() and dogSound(). With polymorphism, you simply call sound(), and the object knows exactly what noise to make based on its specific class type.

Example: Method Overriding

In this example, both the Animal class and the Cat class have a method named sound(). Because the Cat class provides its own version, it "overrides" the parent version when called by a Cat object:

#include <iostream>
using namespace std;

// Base class
class Animal {
  public:
    void sound() {
        cout << "The animal makes a generic sound" << endl;
    }
};

// Derived class
class Cat : public Animal {
  public:
    // Overriding the base class method
    void sound() {
        cout << "Meow" << endl;
    }
};

int main() {
    Animal myAnimal;
    Cat myCat;

    myAnimal.sound(); // Outputs: The animal makes a generic sound
    myCat.sound();    // Outputs: Meow

    return 0;
}

Types of Polymorphism in C++

Key Notes

• The virtual Keyword: To achieve true runtime polymorphism where a base class pointer can call a derived class method, you must declare the base method as virtual (e.g., virtual void sound()).
• Extensibility: Polymorphism makes it easy to add new classes. If you want to add a Dog class later, you just create it and give it a sound() method; you don't need to change any of the code that already uses the Animal interface.
• Interface Consistency: It provides a consistent interface for different data types. For example, a Shape class might have an area() method that works differently for a Square and a Circle, but the developer only needs to remember one method name.
• Memory and Performance: Runtime polymorphism (using virtual functions) has a very small performance cost due to the "vtable" (virtual table) lookup, but the benefits in code organization and flexibility far outweigh the cost in most applications.