First Class Functions

Much of the content of this series relates to a programming concept called first-class functions.

A programming language supports first-class functions if its functions can be treated the same way as other types of data, like integers and booleans. For example:

• Functions can be stored as variables, including in data structures such as class objects
• Functions can be passed as arguments to other functions
• Functions can be returned from other functions

C++ supports first-class functions in several different ways. In this chapter, we will cover the three main options we have: function pointers, function objects, and lambdas

But first, let's see a scenario where first-class functions are a useful feature

A Motivating Example

Let’s imagine we have a Party class, which is what enables our characters to group up and take on bigger challenges.

1class Party {
2public:
3  Character* PlayerOne;
4  Character* PlayerTwo;
5  Character* PlayerThree;
6  Character* PlayerFour;
7};
8

Elsewhere in our code, we’ll want to find out more information about this party. For example, we might want to check that everyone is alive:

1bool isEveryoneAlive {
2  MyParty.PlayerOne->isAlive() &&
3  MyParty.PlayerTwo->isAlive() &&
4  MyParty.PlayerThree->isAlive() &&
5  MyParty.PlayerFour->isAlive()
6};
7

Aside from requiring quite a lot of code, this implementation also makes a big assumption - the party will always have exactly 4 members. In reality, if a party has less, this code may throw an exception due to one of the characters being a nullptr.

Worse, if we later expand our Party class to allow additional characters, code like this may still compile, but return the incorrect result because it’s not checking if the new PlayerFive is alive.

Creating a Class Method

An immediate solution probably comes to mind - we can just add a function to our class to handle this:

1class Party {
2public:
3  bool isEveryoneAlive  {
4    return (
5      MyParty.PlayerOne->isAlive() &&
6      MyParty.PlayerTwo->isAlive() &&
7      MyParty.PlayerThree->isAlive() &&
8      MyParty.PlayerFour->isAlive()
9    );
10  };
11  Character* PlayerOne;
12  Character* PlayerTwo;
13  Character* PlayerThree;
14  Character* PlayerFour;
15};
16

Now, our code can just call MyParty.isEveryoneAlive()

That is better, but we’ve only really solved one specific use case. There are many possible questions people will want to ask of our party. For example:

1MyParty.isEveryoneOnline();
2MyParty.isEveryoneAtLeastLevel(50);
3MyParty.isAnyoneAHealer();
4

We can’t predict all the future possibilities, and we wouldn’t want to need to write code for all of those anyway. Thankfully, this is one of the problems first-class functions were designed to solve.

First Class Functions to the Rescue

To solve this problem with first-class functions, let's create a function that implements the actual check we want to do on each member of the party:

1bool isAlive(Character* Character) {
2  return Character->isAlive();
3}
4

To run this check on everyone in the party, we’d like some way to pass this function to a function on the Party class. A method on our party class that checks if every character meets some condition could be called every. So, our function call might look something like this:

1bool isEveryoneAlive { MyParty.every(isAlive) };
2

The beauty of this design is that we can now ask anything of our Party, without the class needing to be expanded or modified:

1bool canStartQuest {
2  MyParty.every(isAlive) &&
3  MyParty.every(isOnline) &&
4  MyParty.every(isAtLeastLevel50) &&
5  MyParty.every(isInTheShire)
6}
7
8bool isAlive(Character* PartyMember) {
9  return PartyMember->isAlive();
10}
11
12bool isOnline(Character* PartyMember) {
13  return PartyMember->isOnline();
14}
15
16bool isAtLeastLevel50(Character* PartyMember) {
17  return PartyMember->GetLevel() >= 50;
18}
19
20bool isInTheShire(Character* PartyMember) {
21  return PartyMember->GetLocation() == LOCATIONS::SHIRE;
22}
23

Over the coming lessons, we will see three ways code like this can be implemented in C++

In the next lesson, we will introduce the first of these: function pointers.