C++ Polymorphism

One call, the right version

You have an Animal and two kinds of animal. You want speak() to mean bark for a dog and meow for a cat, even when the code that calls speak only knows it has an Animal.

That is polymorphism: the same name, different behavior chosen from the real type of the object. In C++ you mark the base function virtual and the derived function override.

Without virtual, the base wins

If speak is not virtual, a call through an Animal* always runs Animal::speak, even when the pointer points at a Dog. The compiler binds the call to the type of the pointer, not the object.

You will see this the first time you store mixed types behind a base pointer and every one of them prints the base message. The fix is one keyword on the base function.

virtual speak() and override

Write virtual on the function in the base class. In the derived class, write the same signature and add override. override asks the compiler to check that you really replaced a virtual function. A typo in the name then fails at compile time instead of silently doing nothing.

#include <iostream>
using namespace std;

class Animal {
public:
  virtual void speak() {
    cout << "..." << endl;
  }
};

class Dog : public Animal {
public:
  void speak() override {
    cout << "woof" << endl;
  }
};

class Cat : public Animal {
public:
  void speak() override {
    cout << "meow" << endl;
  }
};

int main() {
  Dog d;
  Cat c;
  d.speak();
  c.speak();
  return 0;
}

Direct calls on d and c already pick the derived version. Virtual matters most when the static type is the base.

A base pointer calls the derived function

Take the address of a Dog and store it in an Animal*. Call speak through that pointer. Because speak is virtual, the program runs Dog::speak.

#include <iostream>
using namespace std;

class Animal {
public:
  virtual void speak() {
    cout << "..." << endl;
  }
};

class Dog : public Animal {
public:
  void speak() override {
    cout << "woof" << endl;
  }
};

int main() {
  Dog d;
  Animal* p = &d;
  p->speak();
  return 0;
}

p is typed as Animal*. The object is still a Dog. The arrow-> calls a method through a pointer. You do not need new for this: the dog lives on the stack, and p only holds its address.

Several types, one loop

Put pointers to different animals in a small list. The loop only knows Animal*. Each object still speaks as itself.

#include <iostream>
using namespace std;

class Animal {
public:
  virtual void speak() {
    cout << "..." << endl;
  }
};

class Dog : public Animal {
public:
  void speak() override {
    cout << "woof" << endl;
  }
};

class Cat : public Animal {
public:
  void speak() override {
    cout << "meow" << endl;
  }
};

int main() {
  Dog d;
  Cat c;
  Animal* zoo[2] = {&d, &c};
  for (int i = 0; i < 2; i++) {
    zoo[i]->speak();
  }
  return 0;
}

That is the payoff. Drawing code, UI widgets, and game entities all use this pattern: store base pointers, call one virtual method, get the derived work.

Rules that keep this small

• Mark the function virtual in the base. Once is enough; derived classes inherit that.
• Write override on the replacement. C++11 and later, including C++17 on StudyGrid.
• The signatures must match: return type, name, and parameters.
• Do not delete through a base pointer until you have a virtual destructor. This chapter does not allocate.