Run-time Polymorphism

This lesson is a quick introductory tour of polymorphism within C++. It is not intended for those who are entirely new to programming. Rather, the people who may find it useful include:

• those who have completed our introductory course, but want a quick review
• those who are already familiar with programming in another language, but are new to C++
• those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course. Those looking for more thorough explanations or additional context should consider completing Chapter 6 of that course.

Previous Course

Intro to Programming with C++

Starting from the fundamentals, become a C++ software engineer, step by step.

View Course

Early Binding

This lesson relates to an important concept that occurs when we’re working with objects from an inheritance hierarchy.

Let’s imagine we have a Monster object. Specific subtypes of Monster inherit from it, and provide their own implementation of the Log method:

1class Monster {
2public:
3  void Log(){ std::cout << "Monster\n"; }
4};
5
6class Dragon : public Monster {
7public:
8  void Log(){ std::cout << "Dragon\n"; }
9};

We have functions and other systems that work with this hierarchy, and we’d like them to call the version of the function defined for the specific type of object they receive.

That is, we’d like a function like the following to call Monster::Log() if provided with a reference to a basic Monster, but Dragon::Log() if provided specifically with a Dragon:

1void CallMethod(Monster& Object){
2  Object.Log();
3}

If we test our code we’ll see that, by default, this does not happen.

When calling methods through references and pointers, C++ uses early binding by default. That means, the compiler figures out what methods to call at compile time, based on the type defined within the parameter list, even if our object is a more specific subtype:

1#include <iostream>
2
3class Monster {
4public:
5  void Log(){ std::cout << "Monster\n"; }
6};
7
8class Dragon : public Monster {
9public:
10  void Log(){ std::cout << "Dragon\n"; }
11};
12
13void CallMethod(Monster& Object){
14  Object.Log();
15}
16
17int main(){
18  Monster BaseObject;
19  std::cout << "The first object is a ";
20  CallMethod(BaseObject);
21
22  Dragon DerivedObject;
23  std::cout << "The second object is a ";
24  CallMethod(DerivedObject);
25}

1The first object is a Monster
2The second object is a Monster

Even though the second invocation of CallMethod is passed a reference to a Dragon object, our program logs "Monster" on both invocations.

This is because the reference in the CallMethod function has the type of Monster, and the Monster::Log function uses early binding. Early binding means the compiler identifies what function to call at compile time, based on the type defined within the parameter list.

In this case, the type within the CallMethod function was a Monster reference, Monster&, so the compiler binds the Object.Log() call to the version of that function that is in the Monster class.

Late Binding with virtual

To flag a method for late binding, we need to add the virtual specifier to it:

1class Monster {
2public:
3  virtual void Log(){
4    std::cout << "Monster\n";
5  }
6};

This has performance implications, as our program now needs to find the correct function at run time.

But, because it happens at run time, our program can investigate exactly what is stored in that location in memory at the point our function is called. It identifies the second call as receiving not just a plain old Monster object, but specifically a Dragon object.

As a result, it calls the more specific function, which was in the Dragon class. With no further changes to our program, we get the desired output:

1The first object is a Monster
2The second object is a Dragon

This is an example of a powerful run-time polymorphism a powerful concept that lets our project expand in complexity, without our systems getting more complex.

Our core system (in this case, the contrived CallMethod() function) has not changed. In fact, that system doesn’t even know there is a class called Dragon. Yet, they can interact with Dragon objects, invoking all the dragon-specific behaviors.

We could add 100 more types of Monster, and our core systems don’t need to change at all to accommodate all that variation. They just call Monster methods, and our specific Monster subtypes get to decide what happens, by overriding those methods as required.

The override keyword

When a child class is overriding a function it is inheriting, we should add the override specifier to that function:

1class Dragon : public Monster {
2public:
3  void Log() override {
4    std::cout << "Dragon" << endl;
5  }
6};

This is optional, but it is highly recommended. Adding the override specifier makes our intent clear, both to other developers and the compiler.

If we attempt to override a function, but we misspell its name, or provide a different argument list, the compiler doesn’t know we’ve made a mistake. It assumes we’re just defining a different function, so it lets the bug slip through.

By adding the override specifier, the compiler will know our intent and will throw an error if the function we’re defining on the derived class is not actually overriding anything on a base class.

Downcasting with dynamic_cast

When we have a pointer or reference of the base type, and we want to access a function or variable on a more derived type, we can use dynamic_cast:

In this method, we have a parameter of the type Monster&, but we suspect it might be a more specific Dragon object, so we downcast it appropriately:

1void CallMethod(Monster& Object) {
2  dynamic_cast<Dragon&>(Object);
3}

To use dynamic_cast, our type must be polymorphic, that is, it must define at least one virtual method. If we otherwise have no need for any virtual method in the class, conventionally we just mark the destructor as virtual:

1class Monster {
2public:
3  virtual ~Monster(){}
4};

Dynamic casting will succeed if the reference or pointer really is the derived type we tried to cast it to. In that successful scenario, it will return a reference or pointer to that same memory location, but with an updated type. This allows us to access derived members:

1#include <iostream>
2
3class Monster {
4public:
5  virtual void BaseFunction(){
6    std::cout << "Monster ";
7  }
8};
9
10class Dragon : public Monster {
11public:
12  void DerivedFunction(){
13    std::cout << "and Dragon";
14  }
15};
16
17void CallMethod(Monster& Obj){
18  Obj.BaseFunction();
19  dynamic_cast<Dragon&>(Obj)
20    .DerivedFunction();
21}
22
23int main(){
24  Dragon DerivedObject;
25  CallMethod(DerivedObject);
26}

1Monster and Dragon

Dynamic casting can fail. This happens when the object doesn’t actually have the type we’re trying to cast it to. Below, we’re trying to dynamic cast to a Dragon, but what we’ve received is just a plain old Monster:

1void CallMethod(Monster& Object) {
2  dynamic_cast<Dragon&>(Object);
3}
4
5int main() {
6  Monster BaseObject;
7  CallMethod(BaseObject);
8}

If dynamic casting a reference fails, as in the above example, our code will throw an exception. We cover exceptions and how to handle them later in this course.

If dynamic casting a pointer fails, it returns a nullptr. We can test for null pointers by using an if statement:

1#include <iostream>
2
3class Monster {
4public:
5  virtual ~Monster(){}
6};
7
8class Dragon : public Monster {};
9
10void CallMethod(Monster* Obj){
11  Dragon* DragonPtr{
12    dynamic_cast<Dragon*>(Obj)
13  };
14  if (DragonPtr) {
15    std::cout << "That's a dragon\n";
16  } else {
17    std::cout << "That isn't";
18  }
19}
20
21int main(){
22  Dragon Scaly;
23  CallMethod(&Scaly);
24
25  Monster Goblin;
26  CallMethod(&Goblin);
27}

1That's a dragon
2That isn't

Summary

Polymorphism is a powerful concept that allows for flexible and extensible code. By utilizing virtual functions and dynamic casting, we can write code that adapts to different object types at runtime. Key takeaways:

• Polymorphism enables code to interact with objects of derived classes through base class references or pointers
• Virtual functions are bound at runtime, allowing the most derived implementation to be called
• The override keyword helps ensure that derived classes properly override base class functions
• dynamic_cast allows for safe downcasting of polymorphic objects, enabling access to derived class members

Next Lesson

Odds and Ends: 10 Useful Techniques

A quick tour of ten useful techniques in C++, covering dates, randomness, attributes and more

ContinueView Course