Pure Virtual Functions

We’ve previously seen the benefits of polymorphism.

When we have a variable or function parameter that is a pointer or a reference to a type, objects of any class that inherit from that type can be used.

In the following example, we have a Taunt function that accepts a reference to a Character. We can pass an object of a type of Orc to this function.

This works because Orc inherits from Character, therefore all Orcs are also Characters:

1class Character {};
2
3class Orc : public Character {};
4
5void Taunt(Character& Taunter) {
6  // ...
7};
8
9int main() {
10  Orc Basher;
11  Taunt(Basher);
12}

Run-time Polymorphism

Learn how to write flexible and extensible C++ code using polymorphism, virtual functions, and dynamic casting

We’ve also seen how we can use virtual functions to override the behavior of those base implementations. This allows our function to behave differently based on the specific subtype of Character it receives. This is the essence of polymorphism:

1#include <iostream>
2
3class Character {
4public:
5  virtual std::string GetTaunt() {
6    return "???";
7  }
8};
9
10class Orc : public Character {
11public:
12  std::string GetTaunt() override {
13    return "Come get some!";
14  }
15};
16
17void Taunt(Character& Taunter) {
18  std::cout << Taunter.GetTaunt();
19};
20
21int main() {
22  Orc Basher;
23  Taunt(Basher);
24}

1Come get some!

This allows our code to manage complexity elegantly. We could have hundreds of different character subtypes, each with unique behaviors. But, that is all hidden away within their respective class code - our Taunt() function never needs to change.

A common problem arises with this design: the function we want to call needs to exist on the base class, but it’s not always obvious what that base function should do, or what value it should return.

1class Character {
2public:
3  virtual std::string GetTaunt() {
4    return "???";
5  }
6};

The Character class only really exists as a way to create a standardized interface among all its subtypes. We never expect to create basic Character objects - we’re always going to create more specific objects.

So, in this scenario, GetTaunt() on our Character class can be a pure virtual function.

Pure Virtual Functions

To create a pure virtual function, we assign it a value of 0:

1class Character {
2public:
3  virtual std::string GetTaunt() = 0;
4};

After making this change, Character is now an abstract class. Abstract classes have two properties:

1. It is no longer possible to create objects from this class - Character objects will now need to be created from more specific subclasses
2. If a subclass of Character does not override this function to provide an implementation, that class will also be abstract

1#include <string>
2
3// Abstract - GetTaunt() is pure virtual
4class Character {
5public:
6  virtual std::string GetTaunt() = 0;
7};
8
9// Abstract - GetTaunt() is pure virtual
10class Fish : public Character {};
11
12// Not Abstract - GetTaunt() is implemented
13class Orc : public Character {
14public:
15  std::string GetTaunt() override {
16    return "Come get some!";
17  }
18};
19
20int main() {
21  // We can't create objects from abstract types
22  // These statements will cause compiler errors
23  Character Henry;
24  Fish Flappy;
25
26  // We can only instantiate non-abstract types
27  Orc Basher;
28}

1error C2259: 'Character': cannot instantiate abstract class
2error C2259: 'Fish': cannot instantiate abstract class

Typically, classes that are not abstract are referred to as "concrete". So, in the above example, Orc is a "concrete class".

Optional Implementations

There is an additional technique that allows pure virtual functions to have an optional implementation. It looks like this:

1#include <string>
2
3class Character {
4public:
5  virtual std::string GetTaunt() = 0;
6};
7
8std::string Character::GetTaunt() {
9  return "Default taunt";
10}

Here, Character is still an abstract class, but, for classes that inherit from Character, a default implementation of this function is available.

If any child classes want to use that implementation, they need to explicitly call it:

1class Human : public Character {
2public:
3  std::string GetTaunt() override {
4    return Character::GetTaunt();
5  }
6};

Typically, the motivation for doing this is that we expect most subclasses will need to override this function. If it’s not overridden, we want the class to explicitly confirm they’re happy with the default implementation.

This mitigates scenarios where a developer wasn’t aware that something normally needs to be overridden, or they simply forgot to do so.

Interfaces

Many other object-oriented programming languages have the concept of interfaces. Interfaces specify a set of requirements for an object but do not provide any code to implement those requirements.

C++ does not have a formal implementation of interfaces, but the same behavior can be achieved using a combination of abstract classes and multiple inheritance.

Multiple Inheritance and Virtual Base Classes

A guide to multiple inheritance in C++, including its common problems and how to solve them

A class that has no variables, and only pure-virtual functions, is effectively an interface. By convention, classes that are intended to be used as interfaces use some agreed naming convention, such as prepending an I at the start of their name:

1class ITaunter {
2public:
3  virtual std::string GetTaunt() = 0;
4};

This gives us an alternative way to implement our design. Now, our GetTaunt() function no longer needs to accept a Character&, it can instead accept an ITaunter&:

1void Taunt(ITaunter& Taunter) {
2  std::cout << Taunter.GetTaunt();
3};

This frees us from needing to define GetTaunt() in our Character base class. It also gives us more flexibility in our design. All characters can still be Character objects, but now, each class can decide whether or not it also wants to be an ITaunter.

It does that by inheriting from ITaunter, and implementing the ITaunter requirements - that is, implementing the functions that are defined as pure-virtuals on the ITaunter class.

If a class does that, its objects then also have the ITaunter type, and can be passed to any functions that accept that type. Below, both Orc and Fish objects are Characters, but Orc is additionally an ITaunter:

1#include <iostream>
2
3class Character {};
4class Fish : public Character {};
5
6class ITaunter {
7public:
8  virtual std::string GetTaunt() = 0;
9};
10
11class Orc : public Character, public ITaunter {
12public:
13  std::string GetTaunt() override {
14    return "Come get some!";
15  }
16};
17
18void Taunt(ITaunter& Taunter) {
19  std::cout << Taunter.GetTaunt();
20};
21
22int main() {
23  // A Character that can taunt
24  Orc Basher;
25  Taunt(Basher); 
26
27  // A Character that cannot taunt
28  Fish Flappy;
29  Taunt(Flappy); 
30}

1error C2664: 'void Taunt(ITaunter &)': cannot convert argument 1 from 'Fish' to 'ITaunter &'

Summary

In this lesson, we explored pure virtual functions, abstract classes, and interfaces, showcasing how these features give us more flexibility in our designs.

Main Points Learned:

• Pure virtual functions are declared with = 0 and make a class abstract, preventing it from being instantiated directly.
• Abstract classes serve as a blueprint for derived classes, requiring them to implement the pure virtual functions.
• A pure virtual function can have an implementation that derived classes can optionally use.
• Concrete classes are non-abstract and provide implementations for all inherited pure virtual functions, making them instantiable.
• C++ uses abstract classes with pure virtual functions to achieve interface-like behavior.
• Multiple inheritance allows a class to implement multiple interfaces by inheriting from abstract classes.

Next Lesson

List, Aggregate, and Designated Initialization

A quick guide to creating objects using lists, including std::initializer_list, aggregate and designated initialization

ContinueView Course