Pure Virtual Functions, Abstract Classes and Interfaces

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 inherits from that subtype can be used.

In this 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& Character) {
6  // ...
7};
8
9int main() {
10  Orc Basher;
11  Taunt(Basher);
12}
13

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

1Come get some!
2

This allows our code to manage complexity in an elegant way. 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.

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

The Character class only really exists as a way to create a standardized interface among all its subtypes. We never expect to actually create base 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 string GetTaunt() = 0;
4};
5

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// Abstract - GetTaunt is pure virtual
2class Character {
3public:
4  virtual string GetTaunt() = 0;
5};
6
7// Abstract - GetTaunt is pure virtual
8class Fish : public Character {};
9
10// Not Abstract - GetTaunt is implemented
11class Orc : public Character {
12public:
13  virtual string GetTaunt() override {
14    return Character::GetTaunt();
15  }
16};
17
18int main() {
19  // Cannot create objects from abstract classes
20  Character Henry;
21  Fish Flappy;
22
23  // Can only create objects from non-abstract classes
24  Orc Basher;
25}
26

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

Pure Virtual Functions with Implementations

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

1class Character {
2public:
3  virtual string GetTaunt() = 0;
4};
5
6string Character::GetTaunt() {
7  return "Default taunt!";
8}
9

Here, Character is still an abstract class, but, for classes that inherit from Character, a default implementation of this function is available if they want to use it. If they want to use it, they need to explicitly call it:

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

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. 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 abstract classes. 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 have an I at the start of their name:

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

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  cout << Taunter.GetTaunt() << endl;
3};
4

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 that specific subtype is capable of performing this additional action.

It does that by inheriting from and implementing the requirements of ITaunter. Once a class does that, its objects are then able to be passed to the GetTaunt function.

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