First Class Functions

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

1class Player {
2 public:
3  bool isAlive() const { return true; }
4};
5
6class Party {
7 public:
8  Player PlayerOne;
9  Player PlayerTwo;
10  Player PlayerThree;
11};

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:

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
Party Class|Show
9class Party {/*...*/};
16
17int main() {
18  Party MyParty;
19
20  bool isEveryoneAlive {
21    MyParty.PlayerOne.isAlive() &&
22    MyParty.PlayerTwo.isAlive() &&
23    MyParty.PlayerThree.isAlive()
24  };
25
26  if (isEveryoneAlive) {
27    std::cout << "Everyone is alive";
28  }
29}

1Everyone is alive

Aside from requiring quite a lot of code, this implementation also makes a big assumption - it assumes the party will always have exactly 3 members. In reality, there may be fewer, and we'd want to manage which Player slots are used within the Party class, rather than making external code responsible.

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 PlayerFour is alive.

The root cause here is that our Party isn't encapsulated properly. External code shouldn't be able to poke around the internal workings of our objects like this.

The Party class should take care of details like iterating over its members, and simply expose a friendly public method to access that behaviour.

We covered the importance of encapsulation, and how to implement it, in our beginner course:

Lets implement this isEveryoneAlive() function as a class method. Let's also make all of our Player members private to make our interface simpler.

Then, our code can just call MyParty.isEveryoneAlive():

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
9class Party {
10 public:
11  bool isEveryoneAlive() {
12    return PlayerOne.isAlive() &&
13      PlayerTwo.isAlive() &&
14      PlayerThree.isAlive();
15  }
16
17 private:
18  Player PlayerOne;
19  Player PlayerTwo;
20  Player PlayerThree;
21};
22
23int main() {
24  Party MyParty;
25
26  if (MyParty.isEveryoneAlive()) {
27    std::cout << "Everyone is alive";
28  }
29}

1Everyone is alive

That is better, but we've solved this problem in a very specific way - we're only allowing users of our class to determine if everyone is alive. There are many possible questions people will want to ask of our party.

For example, the outside world might need to know if everyone in the party is online, or above a specific level, or to check if our party has someone who can fill a specifc role:

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

We can't predict everything people might want to use our class for, and we shouldn't need to write code for all of those anyway. Thankfully, this is one of the problems first-class functions were designed to solve.

To solve this problem more flexibly, let's first create a standalone function that implements the check we want to do on each member of the party:

1bool PlayerIsAlive(const Player& P) {
2  return P.isAlive();
3}

A function like this that receives an argument, and returns a boolean representing whether or not that argument satisfies a specific condition is sometimes called a predicate. In this example, our predicate is met if the Player we pass as an argument is alive.

To run this check on everyone in the party, we'd like some way to pass this function to a method on the Party class. This method could then invoke this function for every Player in our Party, and return true if every invocation of this predicate returned true.

For example, a method that checks if every Player meets some condition could be called all_of() and, to check if everyone in our Party is alive, the expression might look something like MyParty.all_of(PlayerIsAlive):

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
9class Party {
10 public:
11  bool all_of(auto Predicate) {
12    return Predicate(PlayerOne) &&
13      Predicate(PlayerTwo) &&
14      Predicate(PlayerThree);
15  }
16
Private Members|Show
17 private:
22};
23
24bool PlayerIsAlive(const Player& P) {
25  return P.isAlive();
26}
27
28int main() {
29  Party MyParty;
30
31  if (MyParty.all_of(PlayerIsAlive)) {
32    std::cout << "Everyone is alive";
33  }
34}

1Everyone is alive

The previous example was accomplished using a function pointer, which we cover in more detail in the next lesson.

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

The outside world provides the function they want to call, whilst our class can handle the iteration, ensuring that function is called for every Player it is managing:

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
10
Party Class|Show
11class Party {/*...*/};
25
26bool PlayerIsAlive(const Player& P) {
27  return P.isAlive();
28}
29
30bool PlayerIsOnline(const Player& P) {
31  return P.isOnline();
32}
33
34bool MinLevel50(const Player& P) {
35  return P.GetLevel() >= 50;
36}
37
38int main() {
39  Party MyParty;
40
41  if (MyParty.all_of(PlayerIsAlive)) {
42    std::cout << "Everyone is alive";
43  }
44
45  if (MyParty.all_of(PlayerIsOnline)) {
46    std::cout << "\nEveryone is online";
47  }
48
49  if (!MyParty.all_of(MinLevel50)) {
50    std::cout << "\nNot everyone is level 50+";
51  }
52}

1Everyone is alive
2Everyone is online
3Not everyone is level 50+

Over the coming lessons, we will see more scenarios where we can apply designs like this and some additional ways they can be implemented in C++

In this lesson, we used function pointers, which are only one of several possibilities. We cover function pointers in more detail in the next lesson.

In this lesson, we introduced the concept of first-class functions, and one of the ways in which C++ allows us to implement this design. The key things we learned include:

• First-class functions allow functions to be stored as variables, passed as arguments, and returned from other functions.
• C++ supports first-class functions in several ways, including function pointers.
• Predicates are functions that return a boolean value based on whether a condition is met.
• The practical example using an all_of() method demonstrated some of the flexibility that first-class functions can provide.