First Class Functions

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

A programming language supports first-class functions if it allows functions to be treated like any other type of data. For example:

• Functions can be stored as variables, class members, or within a container such as an array
• 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 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:

Encapsulation and Access Specifiers

A guide to encapsulation, class invariants, and controlling data access with public and private specifiers.

Using Class Methods

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

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}

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, the outside world might need to know if everyone in the party is online, or a specific level, or to better understand the composition of the party:

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.

Using Predicates

To solve this problem more flexibly, let's first create a 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.

Summary

In this lesson, we introduced the concept of first-class functions, and one of the ways that 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.

Next Lesson

Function Pointers

Learn about function pointers: what they are, how to declare them, and their use in making our code more flexible

ContinueView Course