Polymorphism & Virtual Functions

What Is Polymorphism?

Polymorphism ("many forms") means you can treat objects of different derived classes through a single common type — usually a base class pointer or reference — and have the correct, specific behaviour run automatically for whatever object actually sits behind that pointer.

Using the Animal/Dog/Cat hierarchy from Lesson 12: imagine you have a list of Animal* pointers, some pointing to Dog objects, some to Cat objects. Polymorphism lets you loop through that list calling animal->speak() on each one — and get "Woof!" for the dogs and "Meow!" for the cats, without writing any if checks for the type.

The Gotcha — Why Plain Functions Don't Work

Here's the part that surprises almost every C++ beginner: by default, member functions are not polymorphic. If you call a method through a base class pointer, C++ runs the base class's version of that method — even if the pointer is actually pointing at a derived object.

#include <iostream>
using namespace std;

class Animal {
public:
    // NOT virtual — this is the mistake
    void speak() {
        cout << "The animal makes a sound." << endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        cout << "The dog barks." << endl;
    }
};

int main() {
    Dog d;
    Animal* ptr = &d;   // a base pointer to a derived object

    ptr->speak();       // you'd EXPECT "The dog barks." — but you get the base version!

    return 0;
}

Output — probably not what you expected:

The animal makes a sound.

The virtual Keyword — Fixing the Gotcha

Mark the base class method virtual, and C++ switches to dynamic dispatch: at run time, it looks at the actual object behind the pointer and calls that object's version of the function — exactly the behaviour polymorphism promises.

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() {   // now virtual — enables dynamic dispatch
        cout << "The animal makes a sound." << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {   // override — this replaces Animal's version
        cout << "The dog barks." << endl;
    }
};

int main() {
    Dog d;
    Animal* ptr = &d;

    ptr->speak();   // NOW correctly calls Dog::speak()

    return 0;
}

Output — now correct:

The dog barks.

The only change was adding virtual to the base class declaration. Once a function is virtual in the base class, it stays virtual through the entire hierarchy — you don't need to repeat the keyword in every derived override (though many style guides recommend it for readability).

The override Keyword — Safety Net

Writing override after a derived function's parameter list (as in void speak() override) tells the compiler: "I intend for this to override a virtual function from my base class." If you make a typo — wrong name, wrong parameter types, or forgot virtual in the base — the compiler will now give you an error instead of silently compiling broken code.

A Preview: Pure Virtual Functions & Abstract Classes

Sometimes a base class shouldn't provide any default implementation — it should just force every derived class to supply its own. You do that with a pure virtual function, written with = 0 instead of a body:

class Shape {
public:
    virtual double area() const = 0;   // pure virtual — no body, makes Shape abstract
};

class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    double area() const override {
        return 3.14159 * radius * radius;
    }
};

// Shape s;         ← COMPILE ERROR: cannot instantiate an abstract class
// Circle c(2.0);   ← fine: Circle implements area(), so it can be created

A class containing at least one pure virtual function becomes an abstract class — you cannot create objects of it directly. It exists purely to define a required interface ("every Shape must be able to report its area") that concrete derived classes like Circle must implement. You'll use this pattern often once you start designing larger C++ programs.

Lesson Summary